templates

Documentation

Index

• Variables
• func LoadAll(t *Templates) (err error)
• type Output
  • func (o *Output) Write() error
• type SSHTemplates
  • func (t *SSHTemplates) Validate() (err error)
• type Step
• type StepSSH
• type Template
  • func (t *Template) Load() error
  • func (t *Template) LoadBytes(b []byte) error
  • func (t *Template) Output(data interface{}) (Output, error)
  • func (t *Template) Render(data interface{}) ([]byte, error)
  • func (t *Template) Validate() error
  • func (t *Template) ValidateRequiredData(data map[string]string) error
• type TemplateType
• type Templates
  • func DefaultTemplates() *Templates
  • func (t *Templates) Validate() (err error)

Variables

var DefaultSSHTemplateData = map[string]string{

	"include.tpl": `Host *
{{- if or .User.GOOS "none" | eq "windows" }}
	Include "{{ .User.StepPath | replace "\\" "/" | trimPrefix "C:" }}/ssh/config"
{{- else }}
	Include "{{.User.StepPath}}/ssh/config"
{{- end }}`,

	"config.tpl": `Match exec "step ssh check-host %h"
{{- if .User.User }}
	User {{.User.User}}
{{- end }}
{{- if or .User.GOOS "none" | eq "windows" }}
	UserKnownHostsFile "{{.User.StepPath}}\ssh\known_hosts"
	ProxyCommand C:\Windows\System32\cmd.exe /c step ssh proxycommand %r %h %p
{{- else }}
	UserKnownHostsFile "{{.User.StepPath}}/ssh/known_hosts"
	ProxyCommand step ssh proxycommand %r %h %p
{{- end }}
`,

	"known_hosts.tpl": `@cert-authority * {{.Step.SSH.HostKey.Type}} {{.Step.SSH.HostKey.Marshal | toString | b64enc}}
{{- range .Step.SSH.HostFederatedKeys}}
@cert-authority * {{.Type}} {{.Marshal | toString | b64enc}}
{{- end }}
`,

	"sshd_config.tpl": `Match all
	TrustedUserCAKeys /etc/ssh/ca.pub
	HostCertificate /etc/ssh/{{.User.Certificate}}
	HostKey /etc/ssh/{{.User.Key}}`,

	"ca.tpl": `{{.Step.SSH.UserKey.Type}} {{.Step.SSH.UserKey.Marshal | toString | b64enc}}
{{- range .Step.SSH.UserFederatedKeys}}
{{.Type}} {{.Marshal | toString | b64enc}}
{{- end }}
`,
}

DefaultSSHTemplateData contains the data of the default templates used on ssh.

var DefaultSSHTemplates = SSHTemplates{
	User: []Template{
		{
			Name:         "include.tpl",
			Type:         Snippet,
			TemplatePath: "templates/ssh/include.tpl",
			Path:         "~/.ssh/config",
			Comment:      "#",
		},
		{
			Name:         "config.tpl",
			Type:         File,
			TemplatePath: "templates/ssh/config.tpl",
			Path:         "ssh/config",
			Comment:      "#",
		},
		{
			Name:         "known_hosts.tpl",
			Type:         File,
			TemplatePath: "templates/ssh/known_hosts.tpl",
			Path:         "ssh/known_hosts",
			Comment:      "#",
		},
	},
	Host: []Template{
		{
			Name:         "sshd_config.tpl",
			Type:         Snippet,
			TemplatePath: "templates/ssh/sshd_config.tpl",
			Path:         "/etc/ssh/sshd_config",
			Comment:      "#",
			RequiredData: []string{"Certificate", "Key"},
		},
		{
			Name:         "ca.tpl",
			Type:         Snippet,
			TemplatePath: "templates/ssh/ca.tpl",
			Path:         "/etc/ssh/ca.pub",
			Comment:      "#",
		},
	},
}

DefaultSSHTemplates contains the configuration of default templates used on ssh. Relative paths are relative to the StepPath.

Functions

func LoadAll

func LoadAll(t *Templates) (err error)

LoadAll preloads all templates in memory. It returns an error if an error is found parsing at least one template.

Types

type Output

type Output struct {
	Name    string       `json:"name"`
	Type    TemplateType `json:"type"`
	Path    string       `json:"path"`
	Comment string       `json:"comment"`
	Content []byte       `json:"content"`
}

Output represents the text representation of a rendered template.

func (*Output) Write

func (o *Output) Write() error

Write writes the Output to the filesystem as a directory, file or snippet.

type SSHTemplates

type SSHTemplates struct {
	User []Template `json:"user"`
	Host []Template `json:"host"`
}

SSHTemplates contains the templates defining ssh configuration files.

func (*SSHTemplates) Validate

func (t *SSHTemplates) Validate() (err error)

Validate returns an error if a template is not valid.

type Step

type Step struct {
	SSH StepSSH
}

Step represents the default variables available in the CA.

type StepSSH

type StepSSH struct {
	HostKey           ssh.PublicKey
	UserKey           ssh.PublicKey
	HostFederatedKeys []ssh.PublicKey
	UserFederatedKeys []ssh.PublicKey
}

StepSSH holds SSH-related values for the CA.

type Template

type Template struct {
	*template.Template
	Name         string       `json:"name"`
	Type         TemplateType `json:"type"`
	TemplatePath string       `json:"template"`
	Path         string       `json:"path"`
	Comment      string       `json:"comment"`
	RequiredData []string     `json:"requires,omitempty"`
	Content      []byte       `json:"-"`
}

Template represents on template file.

func (*Template) Load

func (t *Template) Load() error

Load loads the template in memory, returns an error if the parsing of the template fails.

func (*Template) LoadBytes

func (t *Template) LoadBytes(b []byte) error

LoadBytes loads the template in memory, returns an error if the parsing of the template fails.

func (*Template) Output

func (t *Template) Output(data interface{}) (Output, error)

Output renders the template and returns a template.Output struct or an error.

func (*Template) Render

func (t *Template) Render(data interface{}) ([]byte, error)

Render executes the template with the given data and returns the rendered version.

func (*Template) Validate

func (t *Template) Validate() error

Validate returns an error if the template is not valid.

func (*Template) ValidateRequiredData

func (t *Template) ValidateRequiredData(data map[string]string) error

ValidateRequiredData checks that the given data contains all the keys required.

type TemplateType

type TemplateType string

TemplateType defines how a template will be written in disk.

const (
	// Snippet will mark a template as a part of a file.
	Snippet TemplateType = "snippet"
	// File will mark a templates as a full file.
	File TemplateType = "file"
	// Directory will mark a template as a directory.
	Directory TemplateType = "directory"
)

type Templates

type Templates struct {
	SSH  *SSHTemplates          `json:"ssh,omitempty"`
	Data map[string]interface{} `json:"data,omitempty"`
}

Templates is a collection of templates and variables.

func DefaultTemplates

func DefaultTemplates() *Templates

DefaultTemplates returns the default templates.

func (*Templates) Validate

func (t *Templates) Validate() (err error)

Validate returns an error if a template is not valid.