Version: v1.6.5 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Oct 30, 2020 License: MPL-2.0 Imports: 33 Imported by: 0




View Source
View Source
View Source
View Source
const PackerKeyDefault = 100 * time.Millisecond

PackerKeyDefault 100ms is appropriate for shared build infrastructure while a shorter delay (e.g. 10ms) can be used on a workstation. See PackerKeyEnv.

View Source
const PackerKeyEnv = "PACKER_KEY_INTERVAL"

PackerKeyEnv is used to specify the key interval (delay) between keystrokes sent to the VM, typically in boot commands. This is to prevent host CPU utilization from causing key presses to be skipped or repeated incorrectly.


View Source
var RetryExhaustedError error = fmt.Errorf("Function never succeeded in Retry")


func GetTerminalDimensions added in v1.3.0

func GetTerminalDimensions() (width, height int, err error)

call into one of the platform-specific implementations to get the current terminal dimensions

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.

func NewRunner added in v0.11.0

func NewRunner(steps []multistep.Step, config PackerConfig, ui packer.Ui) multistep.Runner

NewRunner returns a multistep.Runner that runs steps augmented with support for -debug and -on-error command line arguments.

func NewRunnerWithPauseFn added in v0.11.0

func NewRunnerWithPauseFn(steps []multistep.Step, config PackerConfig, ui packer.Ui, state multistep.StateBag) multistep.Runner

NewRunnerWithPauseFn returns a multistep.Runner that runs steps augmented with support for -debug and -on-error command line arguments. With -debug it puts the multistep.DebugPauseFn that will pause execution between steps into the state under the key "pauseFn".

func PopulateProvisionHookData added in v1.5.0

func PopulateProvisionHookData(state multistep.StateBag) map[string]interface{}

func Retry added in v0.11.0

func Retry(initialInterval float64, maxInterval float64, numTries uint, function RetryableFunc) error

Retry retries a function up to numTries times with exponential backoff. If numTries == 0, retry indefinitely. If interval == 0, Retry will not delay retrying and there will be no exponential backoff. If maxInterval == 0, maxInterval is set to +Infinity. Intervals are in seconds. Returns an error if initial > max intervals, if retries are exhausted, or if the passed function returns an error.

func ShellCommand added in v1.4.5

func ShellCommand(command string) *exec.Cmd

ShellCommand takes a command string and returns an *exec.Cmd to execute it within the context of a shell (/bin/sh).


type CDConfig added in v1.6.3

type CDConfig struct {
	// A list of files to place onto a CD that is attached when the VM is
	// booted. This can include either files or directories; any directories
	// will be copied onto the CD recursively, preserving directory structure
	// hierarchy. Symlinks will have the link's target copied into the directory
	// tree on the CD where the symlink was. File globbing is allowed.
	// Usage example (JSON):
	// “`json
	// "cd_files": ["./somedirectory/meta-data", "./somedirectory/user-data"],
	// "cd_label": "cidata",
	// “`
	// Usage example (HCL):
	// “`hcl
	// cd_files = ["./somedirectory/meta-data", "./somedirectory/user-data"]
	// cd_label = "cidata"
	// “`
	// The above will create a CD with two files, user-data and meta-data in the
	// CD root. This specific example is how you would create a CD that can be
	// used for an Ubuntu 20.04 autoinstall.
	// Since globbing is also supported,
	// “`hcl
	// cd_files = ["./somedirectory/*"]
	// cd_label = "cidata"
	// “`
	// Would also be an acceptable way to define the above cd. The difference
	// between providing the directory with or without the glob is whether the
	// directory itself or its contents will be at the CD root.
	// Use of this option assumes that you have a command line tool installed
	// that can handle the iso creation. Packer will use one of the following
	// tools:
	//   * xorriso
	//   * mkisofs
	//   * hdiutil (normally found in macOS)
	//   * oscdimg (normally found in Windows as part of the Windows ADK)
	CDFiles []string `mapstructure:"cd_files"`
	CDLabel string   `mapstructure:"cd_label"`

An iso (CD) containing custom files can be made available for your build.

By default, no extra CD will be attached. All files listed in this setting get placed into the root directory of the CD and the CD is attached as the second CD device.

This config exists to work around modern operating systems that have no way to mount floppy disks, which was our previous go-to for adding files at boot time.

func (*CDConfig) Prepare added in v1.6.3

func (c *CDConfig) Prepare(ctx *interpolate.Context) []error

type CommandWrapper added in v1.4.5

type CommandWrapper func(string) (string, error)

CommandWrapper is a type that given a command, will possibly modify that command in-flight. This might return an error.

type FloppyConfig added in v0.11.0

type FloppyConfig struct {
	// A list of files to place onto a floppy disk that is attached when the VM
	// is booted. Currently, no support exists for creating sub-directories on
	// the floppy. Wildcard characters (\\*, ?, and \[\]) are allowed. Directory
	// names are also allowed, which will add all the files found in the
	// directory to the floppy.
	FloppyFiles []string `mapstructure:"floppy_files"`
	// A list of directories to place onto the floppy disk recursively. This is
	// similar to the `floppy_files` option except that the directory structure
	// is preserved. This is useful for when your floppy disk includes drivers
	// or if you just want to organize it's contents as a hierarchy. Wildcard
	// characters (\\*, ?, and \[\]) are allowed. The maximum summary size of
	// all files in the listed directories are the same as in `floppy_files`.
	FloppyDirectories []string `mapstructure:"floppy_dirs"`
	FloppyLabel       string   `mapstructure:"floppy_label"`

A floppy can be made available for your build. This is most useful for unattended Windows installs, which look for an Autounattend.xml file on removable media. By default, no floppy will be attached. All files listed in this setting get placed into the root directory of the floppy and the floppy is attached as the first floppy device. The summary size of the listed files must not exceed 1.44 MB. The supported ways to move large files into the OS are using `http_directory` or [the file provisioner](/docs/provisioners/file).

func (*FloppyConfig) Prepare added in v0.11.0

func (c *FloppyConfig) Prepare(ctx *interpolate.Context) []error

type HTTPConfig added in v0.9.0

type HTTPConfig struct {
	// Path to a directory to serve using an HTTP server. The files in this
	// directory will be available over HTTP that will be requestable from the
	// virtual machine. This is useful for hosting kickstart files and so on.
	// By default this is an empty string, which means no HTTP server will be
	// started. The address and port of the HTTP server will be available as
	// variables in `boot_command`. This is covered in more detail below.
	HTTPDir string `mapstructure:"http_directory"`
	// These are the minimum and maximum port to use for the HTTP server
	// started to serve the `http_directory`. Because Packer often runs in
	// parallel, Packer will choose a randomly available port in this range to
	// run the HTTP server. If you want to force the HTTP server to be on one
	// port, make this minimum and maximum port the same. By default the values
	// are `8000` and `9000`, respectively.
	HTTPPortMin int `mapstructure:"http_port_min"`
	HTTPPortMax int `mapstructure:"http_port_max"`
	// This is the bind address for the HTTP server. Defaults to so that
	// it will work with any network interface.
	HTTPAddress string `mapstructure:"http_bind_address"`
	// This is the bind interface for the HTTP server. Defaults to the first
	// interface with a non-loopback address. Either `http_bind_address` or
	// `http_interface` can be specified.
	HTTPInterface string `mapstructure:"http_interface" undocumented:"true"`

Packer will create an http server serving `http_directory` when it is set, a random free port will be selected and the architecture of the directory referenced will be available in your builder.

Example usage from a builder:

`wget http://{{ .HTTPIP }}:{{ .HTTPPort }}/foo/bar/preseed.cfg`

func (*HTTPConfig) Prepare added in v0.9.0

func (c *HTTPConfig) Prepare(ctx *interpolate.Context) []error

type ISOConfig added in v0.9.0

type ISOConfig struct {
	// The checksum for the ISO file or virtual hard drive file. The type of
	// the checksum is specified within the checksum field as a prefix, ex:
	// "md5:{$checksum}". The type of the checksum can also be omitted and
	// Packer will try to infer it based on string length. Valid values are
	// "none", "{$checksum}", "md5:{$checksum}", "sha1:{$checksum}",
	// "sha256:{$checksum}", "sha512:{$checksum}" or "file:{$path}". Here is a
	// list of valid checksum values:
	//  * md5:090992ba9fd140077b0661cb75f7ce13
	//  * 090992ba9fd140077b0661cb75f7ce13
	//  * sha1:ebfb681885ddf1234c18094a45bbeafd91467911
	//  * ebfb681885ddf1234c18094a45bbeafd91467911
	//  * sha256:ed363350696a726b7932db864dda019bd2017365c9e299627830f06954643f93
	//  * ed363350696a726b7932db864dda019bd2017365c9e299627830f06954643f93
	//  * file:
	//  * file:file://./local/path/file.sum
	//  * file:./local/path/file.sum
	//  * none
	// Although the checksum will not be verified when it is set to "none",
	// this is not recommended since these files can be very large and
	// corruption does happen from time to time.
	ISOChecksum string `mapstructure:"iso_checksum" required:"true"`
	// A URL to the ISO containing the installation image or virtual hard drive
	// (VHD or VHDX) file to clone.
	RawSingleISOUrl string `mapstructure:"iso_url" required:"true"`
	// Multiple URLs for the ISO to download. Packer will try these in order.
	// If anything goes wrong attempting to download or while downloading a
	// single URL, it will move on to the next. All URLs must point to the same
	// file (same checksum). By default this is empty and `iso_url` is used.
	// Only one of `iso_url` or `iso_urls` can be specified.
	ISOUrls []string `mapstructure:"iso_urls"`
	// The path where the iso should be saved after download. By default will
	// go in the packer cache, with a hash of the original filename and
	// checksum as its name.
	TargetPath string `mapstructure:"iso_target_path"`
	// The extension of the iso file after download. This defaults to `iso`.
	TargetExtension string `mapstructure:"iso_target_extension"`

By default, Packer will symlink, download or copy image files to the Packer cache into a "`hash($iso_url+$iso_checksum).$iso_target_extension`" file. Packer uses [hashicorp/go-getter]( in file mode in order to perform a download.

go-getter supports the following protocols:

* Local files * Git * Mercurial * HTTP * Amazon S3

Examples: go-getter can guess the checksum type based on `iso_checksum` length, and it is also possible to specify the checksum type.



"iso_checksum": "946a6077af6f5f95a51f82fdc44051c7aa19f9cfc5f737954845a6050543d7c2",
"iso_url": ""



"iso_checksum": "",
"iso_url": ""



"iso_checksum": "file://./shasums.txt",
"iso_url": ""



"iso_checksum": "file:./shasums.txt",
"iso_url": ""


In HCL2:


iso_checksum = "946a6077af6f5f95a51f82fdc44051c7aa19f9cfc5f737954845a6050543d7c2"
iso_url = ""



iso_checksum = ""
iso_url = ""



iso_checksum = "file://./shasums.txt"
iso_url = ""



iso_checksum = "file:./shasums.txt",
iso_url = ""


func (*ISOConfig) Prepare added in v0.9.0

func (c *ISOConfig) Prepare(*interpolate.Context) (warnings []string, errs []error)

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"`
	PackerOnError       string            `mapstructure:"packer_on_error"`
	PackerUserVars      map[string]string `mapstructure:"packer_user_variables"`
	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_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 RetryableFunc added in v1.0.0

type RetryableFunc func(uint) (bool, error)

RetryableFunc performs an action and returns a bool indicating whether the function is done, or if it should keep retrying, and an error which will abort the retry and be returned by the Retry function. The 0-indexed attempt is passed with each call.

type StepCleanupTempKeys added in v1.3.1

type StepCleanupTempKeys struct {
	Comm *communicator.Config

func (*StepCleanupTempKeys) Cleanup added in v1.3.1

func (s *StepCleanupTempKeys) Cleanup(state multistep.StateBag)

func (*StepCleanupTempKeys) Run added in v1.3.1

type StepCreateCD added in v1.6.3

type StepCreateCD struct {
	// Files can be either files or directories. Any files provided here will
	// be written to the root of the CD. Directories will be written to the
	// root of the CD as well, but will retain their subdirectory structure.
	Files []string
	Label string

	CDPath string
	// contains filtered or unexported fields

StepCreateCD will create a CD disk with the given files.

func (*StepCreateCD) AddFile added in v1.6.3

func (s *StepCreateCD) AddFile(dst, src string) error

func (*StepCreateCD) Cleanup added in v1.6.3

func (s *StepCreateCD) Cleanup(multistep.StateBag)

func (*StepCreateCD) Run added in v1.6.3

type StepCreateFloppy

type StepCreateFloppy struct {
	Files       []string
	Directories []string
	Label       string

	FilesAdded map[string]bool
	// contains filtered or unexported fields

StepCreateFloppy will create a floppy disk with the given files.

func (*StepCreateFloppy) Add added in v0.11.0

func (s *StepCreateFloppy) Add(dircache directoryCache, src string) error

func (*StepCreateFloppy) Cleanup

func (s *StepCreateFloppy) Cleanup(multistep.StateBag)

func (*StepCreateFloppy) Run

type StepDownload added in v0.3.2

type StepDownload struct {
	// The checksum and the type of the checksum for the download
	Checksum string

	// A short description of the type of download being done. Example:
	// "ISO" or "Guest Additions"
	Description string

	// The name of the key where the final path of the ISO will be put
	// into the state.
	ResultKey string

	// The path where the result should go, otherwise it goes to the
	// cache directory.
	TargetPath string

	// A list of URLs to attempt to download this thing.
	Url []string

	// Extension is the extension to force for the file that is downloaded.
	// Some systems require a certain extension. If this isn't set, the
	// extension on the URL is used. Otherwise, this will be forced
	// on the downloaded file for every URL.
	Extension string

StepDownload downloads a remote file using the download client within this package. This step handles setting up the download configuration, progress reporting, interrupt handling, etc.


cache packer.Cache
ui    packer.Ui

func (*StepDownload) Cleanup added in v0.3.2

func (s *StepDownload) Cleanup(multistep.StateBag)

func (*StepDownload) Run added in v0.3.2

func (*StepDownload) UseSourceToFindCacheTarget added in v1.6.5

func (s *StepDownload) UseSourceToFindCacheTarget(source string) (*url.URL, string, error)

type StepHTTPServer added in v0.9.0

type StepHTTPServer struct {
	HTTPDir     string
	HTTPPortMin int
	HTTPPortMax int
	HTTPAddress string
	// contains filtered or unexported fields

This step creates and runs the HTTP server that is serving files from the directory specified by the 'http_directory` configuration parameter in the template.


ui     packer.Ui


http_port int - The port the HTTP server started on.

func (*StepHTTPServer) Cleanup added in v0.9.0

func (s *StepHTTPServer) Cleanup(multistep.StateBag)

func (*StepHTTPServer) Run added in v0.9.0

type StepOutputDir added in v1.3.4

type StepOutputDir struct {
	Force bool
	Path  string
	// contains filtered or unexported fields

StepOutputDir sets up the output directory by creating it if it does not exist, deleting it if it does exist and we're forcing, and cleaning it up when we're done with it.

func (*StepOutputDir) Cleanup added in v1.3.4

func (s *StepOutputDir) Cleanup(state multistep.StateBag)

func (*StepOutputDir) Run added in v1.3.4

type StepProvision

type StepProvision struct {
	Comm packer.Communicator

func (*StepProvision) Cleanup

func (s *StepProvision) Cleanup(state multistep.StateBag)

func (*StepProvision) Run


Path Synopsis
Package shell defines code that is common in shells
Package shell defines code that is common in shells
Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL