common

Documentation

Index

• func CheckUnusedConfig(md *mapstructure.Metadata) *packer.MultiError
• func DecodeConfig(target interface{}, raws ...interface{}) (*mapstructure.Metadata, error)
• func DownloadableURL(original string) (string, error)
• func HashForType(t string) hash.Hash
• func MultistepDebugFn(ui packer.Ui) multistep.DebugPauseFn
• type DownloadClient
  • func NewDownloadClient(c *DownloadConfig) *DownloadClient
  • func (d *DownloadClient) Cancel()
  • func (d *DownloadClient) Get() (string, error)
  • func (d *DownloadClient) PercentProgress() uint
  • func (d *DownloadClient) VerifyChecksum(path string) (bool, error)
• type DownloadConfig
• type Downloader
• type HTTPDownloader
  • func (*HTTPDownloader) Cancel()
  • func (d *HTTPDownloader) Download(dst io.Writer, src *url.URL) error
  • func (d *HTTPDownloader) Progress() uint
  • func (d *HTTPDownloader) Total() uint
• type PackerConfig
• type StepConnectSSH
  • func (s *StepConnectSSH) Cleanup(map[string]interface{})
  • func (s *StepConnectSSH) Run(state map[string]interface{}) multistep.StepAction
• type StepCreateFloppy
  • func (s *StepCreateFloppy) Cleanup(map[string]interface{})
  • func (s *StepCreateFloppy) Run(state map[string]interface{}) multistep.StepAction
• type StepProvision
  • func (*StepProvision) Cleanup(map[string]interface{})
  • func (*StepProvision) Run(state map[string]interface{}) multistep.StepAction
• type Template
  • func NewTemplate() (*Template, error)
  • func (t *Template) Process(s string, data interface{}) (string, error)
  • func (t *Template) Validate(s string) error

Functions

func CheckUnusedConfig

func CheckUnusedConfig(md *mapstructure.Metadata) *packer.MultiError

CheckUnusedConfig is a helper that makes sure that the there are no unused configuration keys, properly ignoring keys that don't matter.

func DecodeConfig

func DecodeConfig(target interface{}, raws ...interface{}) (*mapstructure.Metadata, error)

DecodeConfig is a helper that handles decoding raw configuration using mapstructure. It returns the metadata and any errors that may happen. If you need extra configuration for mapstructure, you should configure it manually and not use this helper function.

func DownloadableURL

func DownloadableURL(original string) (string, error)

DownloadableURL processes a URL that may also be a file path and returns a completely valid URL. For example, the original URL might be "local/file.iso" which isn't a valid URL. DownloadableURL will return "file:///local/file.iso"

func HashForType

func HashForType(t string) hash.Hash

HashForType returns the Hash implementation for the given string type, or nil if the type is not supported.

func MultistepDebugFn

func MultistepDebugFn(ui packer.Ui) multistep.DebugPauseFn

MultistepDebugFn will return a proper multistep.DebugPauseFn to use for debugging if you're using multistep in your builder.

Types

type DownloadClient

type DownloadClient struct {
	// contains filtered or unexported fields
}

A DownloadClient helps download, verify checksums, etc.

func NewDownloadClient

func NewDownloadClient(c *DownloadConfig) *DownloadClient

NewDownloadClient returns a new DownloadClient for the given configuration.

func (*DownloadClient) Cancel

func (d *DownloadClient) Cancel()

func (*DownloadClient) Get

func (d *DownloadClient) Get() (string, error)

func (*DownloadClient) PercentProgress

func (d *DownloadClient) PercentProgress() uint

PercentProgress returns the download progress as a percentage.

func (*DownloadClient) VerifyChecksum

func (d *DownloadClient) VerifyChecksum(path string) (bool, error)

VerifyChecksum tests that the path matches the checksum for the download.

type DownloadConfig

type DownloadConfig struct {
	// The source URL in the form of a string.
	Url string

	// This is the path to download the file to.
	TargetPath string

	// DownloaderMap maps a schema to a Download.
	DownloaderMap map[string]Downloader

	// If true, this will copy even a local file to the target
	// location. If false, then it will "download" the file by just
	// returning the local path to the file.
	CopyFile bool

	// The hashing implementation to use to checksum the downloaded file.
	Hash hash.Hash

	// The checksum for the downloaded file. The hash implementation configuration
	// for the downloader will be used to verify with this checksum after
	// it is downloaded.
	Checksum []byte
}

DownloadConfig is the configuration given to instantiate a new download instance. Once a configuration is used to instantiate a download client, it must not be modified.

type Downloader

type Downloader interface {
	Cancel()
	Download(io.Writer, *url.URL) error
	Progress() uint
	Total() uint
}

A downloader is responsible for actually taking a remote URL and downloading it.

type HTTPDownloader

type HTTPDownloader struct {
	// contains filtered or unexported fields
}

HTTPDownloader is an implementation of Downloader that downloads files over HTTP.

func (*HTTPDownloader) Cancel

func (*HTTPDownloader) Cancel()

func (*HTTPDownloader) Download

func (d *HTTPDownloader) Download(dst io.Writer, src *url.URL) error

func (*HTTPDownloader) Progress

func (d *HTTPDownloader) Progress() uint

func (*HTTPDownloader) Total

func (d *HTTPDownloader) Total() uint

type PackerConfig

type PackerConfig struct {
	PackerBuildName   string            `mapstructure:"packer_build_name"`
	PackerBuilderType string            `mapstructure:"packer_builder_type"`
	PackerDebug       bool              `mapstructure:"packer_debug"`
	PackerForce       bool              `mapstructure:"packer_force"`
	PackerUserVars    map[string]string `mapstructure:"packer_user_variables"`
}

PackerConfig is a struct that contains the configuration keys that are sent by packer, properly tagged already so mapstructure can load them. Embed this structure into your configuration class to get it.

type StepConnectSSH

type StepConnectSSH struct {
	// SSHAddress is a function that returns the TCP address to connect to
	// for SSH. This is a function so that you can query information
	// if necessary for this address.
	SSHAddress func(map[string]interface{}) (string, error)

	// SSHConfig is a function that returns the proper client configuration
	// for SSH access.
	SSHConfig func(map[string]interface{}) (*gossh.ClientConfig, error)

	// SSHWaitTimeout is the total timeout to wait for SSH to become available.
	SSHWaitTimeout time.Duration
	// contains filtered or unexported fields
}

StepConnectSSH is a multistep Step implementation that waits for SSH to become available. It gets the connection information from a single configuration when creating the step.

Uses:

ui packer.Ui

Produces:

communicator packer.Communicator

func (*StepConnectSSH) Cleanup

func (s *StepConnectSSH) Cleanup(map[string]interface{})

func (*StepConnectSSH) Run

func (s *StepConnectSSH) Run(state map[string]interface{}) multistep.StepAction

type StepCreateFloppy

type StepCreateFloppy struct {
	Files []string
	// contains filtered or unexported fields
}

StepCreateFloppy will create a floppy disk with the given files. The floppy disk doesn't support sub-directories. Only files at the root level are supported.

func (*StepCreateFloppy) Cleanup

func (s *StepCreateFloppy) Cleanup(map[string]interface{})

func (*StepCreateFloppy) Run

func (s *StepCreateFloppy) Run(state map[string]interface{}) multistep.StepAction

type StepProvision

type StepProvision struct{}

StepProvision runs the provisioners.

Uses:

communicator packer.Communicator
hook         packer.Hook
ui           packer.Ui

Produces:

<nothing>

func (*StepProvision) Cleanup

func (*StepProvision) Cleanup(map[string]interface{})

func (*StepProvision) Run

func (*StepProvision) Run(state map[string]interface{}) multistep.StepAction

type Template

type Template struct {
	UserVars map[string]string
	// contains filtered or unexported fields
}

Template processes string data as a text/template with some common elements and functions available. Plugin creators should process as many fields as possible through this.

func NewTemplate

func NewTemplate() (*Template, error)

NewTemplate creates a new template processor.

func (*Template) Process

func (t *Template) Process(s string, data interface{}) (string, error)

Process processes a single string, compiling and executing the template.

func (*Template) Validate

func (t *Template) Validate(s string) error

Validate the template.