func (p *AWSBoxPostProcessor) Configure(raws ...interface{}) error { md, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) validates := map[string]*string{ "output": &p.config.OutputPath, "vagrantfile_template": &p.config.VagrantfileTemplate, } for n, ptr := range validates { if err := p.config.tpl.Validate(*ptr); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error parsing %s: %s", n, err)) } } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func (b *Builder) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return err } // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare()...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare()...) // Accumulate any errors if b.config.AMIName == "" { errs = packer.MultiErrorAppend( errs, errors.New("ami_name must be specified")) } else { _, err = template.New("ami").Parse(b.config.AMIName) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed parsing ami_name: %s", err)) } } if errs != nil && len(errs.Errors) > 0 { return errs } log.Printf("Config: %+v", b.config) return nil }
func (p *Provisioner) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } if p.config.TempConfigDir == "" { p.config.TempConfigDir = DefaultTempConfigDir } // Accumulate any errors errs := common.CheckUnusedConfig(md) if p.config.LocalStateTree == "" { errs = packer.MultiErrorAppend(errs, errors.New("Please specify a local_state_tree")) } else if _, err := os.Stat(p.config.LocalStateTree); err != nil { errs = packer.MultiErrorAppend(errs, errors.New("local_state_tree must exist and be accessible")) } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.ImageConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) if errs != nil && len(errs.Errors) > 0 { return nil, errs } log.Println(common.ScrubConfig(b.config, b.config.Password)) return nil, nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars b.config.tpl.Funcs(awscommon.TemplateFuncs) // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.WinRMConfig.Prepare(b.config.tpl)...) if errs != nil && len(errs.Errors) > 0 { return nil, errs } return nil, nil }
func (b *Builder) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } b.config.tpl.UserVars = b.config.PackerUserVars b.config.tpl.Funcs(awscommon.TemplateFuncs) // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) if errs != nil && len(errs.Errors) > 0 { return errs } log.Println(common.ScrubConfig(b.config), b.config.AccessKey, b.config.SecretKey) return nil }
func TestPostProcessor_PostProcess(t *testing.T) { driver := &docker.MockDriver{} p := &PostProcessor{Driver: driver} _, err := common.DecodeConfig(&p.config, testConfig()) if err != nil { t.Fatalf("err %s", err) } artifact := &packer.MockArtifact{ BuilderIdValue: dockerimport.BuilderId, IdValue: "1234567890abcdef", } result, keep, err := p.PostProcess(testUi(), artifact) if _, ok := result.(packer.Artifact); !ok { t.Fatal("should be instance of Artifact") } if !keep { t.Fatal("should keep") } if err != nil { t.Fatalf("err: %s", err) } if !driver.TagImageCalled { t.Fatal("should call TagImage") } if driver.TagImageImageId != "1234567890abcdef" { t.Fatal("bad image id") } if driver.TagImageRepo != "foo:bar" { t.Fatal("bad repo") } }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Defaults if p.config.DiskMode == "" { p.config.DiskMode = "thick" } // Accumulate any errors errs := new(packer.MultiError) if _, err := exec.LookPath("ovftool"); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("ovftool not found: %s", err)) } templates := map[string]*string{ "cluster": &p.config.Cluster, "datacenter": &p.config.Datacenter, "datastore": &p.config.Datastore, "diskmode": &p.config.DiskMode, "host": &p.config.Host, "vm_network": &p.config.VMNetwork, "password": &p.config.Password, "resource_pool": &p.config.ResourcePool, "username": &p.config.Username, "vm_folder": &p.config.VMFolder, "vm_name": &p.config.VMName, } for key, ptr := range templates { if *ptr == "" { errs = packer.MultiErrorAppend( errs, fmt.Errorf("%s must be set", key)) } *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", key, err)) } } if len(errs.Errors) > 0 { return errs } return nil }
func NewConfig(raws ...interface{}) (*Config, []string, error) { c := new(Config) md, err := common.DecodeConfig(c, raws...) if err != nil { return nil, nil, err } c.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, nil, err } // Default Pull if it wasn't set hasPull := false for _, k := range md.Keys { if k == "Pull" { hasPull = true break } } if !hasPull { c.Pull = true } errs := common.CheckUnusedConfig(md) templates := map[string]*string{ "export_path": &c.ExportPath, "image": &c.Image, } for n, ptr := range templates { var err error *ptr, err = c.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if c.ExportPath == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("export_path must be specified")) } if c.Image == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("image must be specified")) } if errs != nil && len(errs.Errors) > 0 { return nil, nil, errs } return c, nil, nil }
func (builder *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&builder.config, raws...) if err != nil { return nil, err } builder.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } builder.config.tpl.UserVars = builder.config.PackerUserVars builder.config.tpl.Funcs(awscommon.TemplateFuncs) if builder.config.VolumeSize == 0 { builder.config.VolumeSize = 12 } if builder.config.VolumeType == "" { builder.config.VolumeType = "standard" } if builder.config.RootDeviceName == "" { builder.config.RootDeviceName = "/dev/xvda" } builder.ensureWorkerDeviceMapping() // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, builder.config.AccessConfig.Prepare(builder.config.tpl)...) errs = packer.MultiErrorAppend(errs, builder.config.BlockDevices.Prepare(builder.config.tpl)...) errs = packer.MultiErrorAppend(errs, builder.config.AMIConfig.Prepare(builder.config.tpl)...) errs = packer.MultiErrorAppend(errs, builder.config.RunConfig.Prepare(builder.config.tpl)...) templates := map[string]*string{ "worker_device_name": &builder.config.WorkerDeviceName, "root_device_name": &builder.config.RootDeviceName, } for n, ptr := range templates { var err error *ptr, err = builder.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if errs != nil && len(errs.Errors) > 0 { return nil, errs } log.Println(common.ScrubConfig(builder.config, builder.config.AccessKey, builder.config.SecretKey)) return nil, nil }
func (p *Provisioner) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) if p.config.StagingDir == "" { p.config.StagingDir = DefaultStagingDir } // Templates templates := map[string]*string{ "staging_dir": &p.config.StagingDir, } for n, ptr := range templates { var err error *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } // Validation err = validateFileConfig(p.config.PlaybookFile, "playbook_file", true) if err != nil { errs = packer.MultiErrorAppend(errs, err) } for _, path := range p.config.PlaybookPaths { err := validateDirConfig(path, "playbook_paths") if err != nil { errs = packer.MultiErrorAppend(errs, err) } } for _, path := range p.config.RolePaths { if err := validateDirConfig(path, "role_paths"); err != nil { errs = packer.MultiErrorAppend(errs, err) } } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func (p *Provisioner) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars if p.config.TempConfigDir == "" { p.config.TempConfigDir = DefaultTempConfigDir } // Accumulate any errors errs := common.CheckUnusedConfig(md) templates := map[string]*string{ "bootstrap_args": &p.config.BootstrapArgs, "minion_config": &p.config.MinionConfig, "local_state_tree": &p.config.LocalStateTree, "temp_config_dir": &p.config.TempConfigDir, } for n, ptr := range templates { var err error *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if p.config.LocalStateTree != "" { if _, err := os.Stat(p.config.LocalStateTree); err != nil { errs = packer.MultiErrorAppend(errs, errors.New("local_state_tree must exist and be accessible")) } } if p.config.MinionConfig != "" { if _, err := os.Stat(p.config.MinionConfig); err != nil { errs = packer.MultiErrorAppend(errs, errors.New("minion_config must exist and be accessible")) } } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } if p.config.AmiId == nil { p.config.AmiId = make(map[string][]string, 0) } return nil }
func (p *PostProcessor) Configure(raw_config ...interface{}) error { var err error _, err = common.DecodeConfig(&p.c, raw_config...) if err != nil { return err } p.docker_build_fn = docker_build // configure the build function if err = p.prepare_config_template(); err != nil { return err } return nil }
func (p *PostProcessor) configureSingle(config *Config, raws ...interface{}) error { md, err := common.DecodeConfig(config, raws...) if err != nil { return err } config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } config.tpl.UserVars = config.PackerUserVars // Defaults if config.OutputPath == "" { config.OutputPath = "packer_{{ .BuildName }}_{{.Provider}}.box" } found := false for _, k := range md.Keys { if k == "compression_level" { found = true break } } if !found { config.CompressionLevel = flate.DefaultCompression } // Accumulate any errors errs := common.CheckUnusedConfig(md) validates := map[string]*string{ "output": &config.OutputPath, "vagrantfile_template": &config.VagrantfileTemplate, "provider": &config.Provider, } for n, ptr := range validates { if err := config.tpl.Validate(*ptr); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error parsing %s: %s", n, err)) } } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func (p *OVFPostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.cfg, raws...) if err != nil { return err } p.cfg.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.cfg.tpl.UserVars = p.cfg.PackerUserVars if p.cfg.TargetType == "" { p.cfg.TargetType = "ovf" } if p.cfg.TargetPath == "" { p.cfg.TargetPath = "packer_{{ .BuildName }}_{{.Provider}}" if p.cfg.TargetType == "ova" { p.cfg.TargetPath += ".ova" } } errs := new(packer.MultiError) _, err = exec.LookPath(executable) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error: Could not find ovftool executable: %s", err)) } if err = p.cfg.tpl.Validate(p.cfg.TargetPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error parsing target template: %s", err)) } if !(p.cfg.TargetType == "ovf" || p.cfg.TargetType == "ova") { errs = packer.MultiErrorAppend( errs, errors.New("Invalid target type. Only 'ovf' or 'ova' are allowed.")) } if !(p.cfg.Compression >= 0 && p.cfg.Compression <= 9) { errs = packer.MultiErrorAppend( errs, errors.New("Invalid compression level. Must be between 1 and 9, or 0 for no compression.")) } if len(errs.Errors) > 0 { return errs } return nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Default configuration if p.config.VagrantCloudUrl == "" { p.config.VagrantCloudUrl = VAGRANT_CLOUD_URL } // Accumulate any errors errs := new(packer.MultiError) // required configuration templates := map[string]*string{ "box_tag": &p.config.Tag, "version": &p.config.Version, "access_token": &p.config.AccessToken, } for key, ptr := range templates { if *ptr == "" { errs = packer.MultiErrorAppend( errs, fmt.Errorf("%s must be set", key)) } } // Template process for key, ptr := range templates { *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", key, err)) } } if len(errs.Errors) > 0 { return errs } return nil }
func NewConfig(raws ...interface{}) (*Config, []string, error) { c := new(Config) md, err := common.DecodeConfig(c, raws...) if err != nil { return nil, nil, err } c.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, nil, err } c.tpl.UserVars = c.PackerUserVars // Defaults if c.Port == 0 { c.Port = 22 } // (none so far) errs := common.CheckUnusedConfig(md) if c.Host == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("host must be specified")) } if c.SSHUsername == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("ssh_username must be specified")) } if c.SSHPassword == "" && c.SSHPrivateKeyFile == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("one of ssh_password and ssh_private_key_file must be specified")) } if c.SSHPassword != "" && c.SSHPrivateKeyFile != "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("only one of ssh_password and ssh_private_key_file must be specified")) } if errs != nil && len(errs.Errors) > 0 { return nil, nil, errs } return c, nil, nil }
func (b *Builder) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } b.config.tpl.UserVars = b.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) // Accumulate any errors newTags := make(map[string]string) for k, v := range b.config.Tags { k, err = b.config.tpl.Process(k, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing tag key %s: %s", k, err)) continue } v, err = b.config.tpl.Process(v, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing tag value '%s': %s", v, err)) continue } newTags[k] = v } b.config.Tags = newTags if errs != nil && len(errs.Errors) > 0 { return errs } log.Printf("Config: %+v", b.config) return nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } tpl, err := packer.NewConfigTemplate() if err != nil { return err } tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := new(packer.MultiError) if _, err := exec.LookPath("ovftool"); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("ovftool not found: %s", err)) } validates := map[string]*string{ "datacenter": &p.config.Datacenter, "datastore": &p.config.Datastore, "host": &p.config.Host, "vm_network": &p.config.VMNetwork, "password": &p.config.Password, "path_to_resource_pool": &p.config.PathToResourcePool, "username": &p.config.Username, "vm_folder": &p.config.VMFolder, "vm_name": &p.config.VMName, } for n := range validates { if *validates[n] == "" { errs = packer.MultiErrorAppend( errs, fmt.Errorf("%s must be set", n)) } } if len(errs.Errors) > 0 { return errs } return nil }
func (p *Provisioner) Prepare(raws ...interface{}) error { md, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) templates := map[string]*string{ "source": &p.config.Source, "destination": &p.config.Destination, } for n, ptr := range templates { var err error *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if _, err := os.Stat(p.config.Source); err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Bad source '%s': %s", p.config.Source, err)) } if p.config.Destination == "" { errs = packer.MultiErrorAppend(errs, errors.New("Destination must be specified.")) } if errs != nil && len(errs.Errors) > 0 { return errs } return nil }
func NewUserConfig(raws ...interface{}) (UserConfig, error) { c := UserConfig{ AgentInfrastructure: "warden", AgentPlatform: "ubuntu", // Set exlicitly to nil instead of map[string]interface{}{} // for bosh-provisioner to use reasonable default AgentConfiguration: nil, } metadata, err := common.DecodeConfig(&c, raws...) if err != nil { return c, err } c.metadata = metadata return c, nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := new(packer.MultiError) if len(errs.Errors) > 0 { return errs } return nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := new(packer.MultiError) templates := map[string]*string{ "repository": &p.config.Repository, "tag": &p.config.Tag, } for key, ptr := range templates { if *ptr == "" { errs = packer.MultiErrorAppend( errs, fmt.Errorf("%s must be set", key)) } *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", key, err)) } } if len(errs.Errors) > 0 { return errs } return nil }
func (p *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&p.config, raws...) if err != nil { return err } p.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } p.config.tpl.UserVars = p.config.PackerUserVars // Accumulate any errors errs := new(packer.MultiError) // Process templates templates := map[string]*string{ "login_email": &p.config.LoginEmail, "login_username": &p.config.LoginUsername, "login_password": &p.config.LoginPassword, "login_server": &p.config.LoginServer, } for n, ptr := range templates { var err error *ptr, err = p.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if len(errs.Errors) > 0 { return errs } return nil }
func (self *PostProcessor) Configure(raws ...interface{}) error { _, err := common.DecodeConfig(&self.config, raws...) if err != nil { return err } self.config.tpl, err = packer.NewConfigTemplate() if err != nil { return err } self.config.tpl.UserVars = self.config.PackerUserVars templates := map[string]*string{ "output": &self.config.OutputPath, } errs := new(packer.MultiError) for key, ptr := range templates { if *ptr == "" { errs = packer.MultiErrorAppend( errs, fmt.Errorf("%s must be set", key)) } *ptr, err = self.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", key, err)) } } if len(errs.Errors) > 0 { return errs } return nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars b.config.tpl.Funcs(awscommon.TemplateFuncs) if b.config.BundleDestination == "" { b.config.BundleDestination = "/tmp" } if b.config.BundlePrefix == "" { b.config.BundlePrefix = "image-{{timestamp}}" } if b.config.BundleUploadCommand == "" { b.config.BundleUploadCommand = "sudo -n ec2-upload-bundle " + "-b {{.BucketName}} " + "-m {{.ManifestPath}} " + "-a {{.AccessKey}} " + "-s {{.SecretKey}} " + "-d {{.BundleDirectory}} " + "--batch " + "--url {{.S3Endpoint}} " + "--retry" } if b.config.BundleVolCommand == "" { b.config.BundleVolCommand = "sudo -n ec2-bundle-vol " + "-k {{.KeyPath}} " + "-u {{.AccountId}} " + "-c {{.CertPath}} " + "-r {{.Architecture}} " + "-e {{.PrivatePath}}/* " + "-d {{.Destination}} " + "-p {{.Prefix}} " + "--batch" } if b.config.X509UploadPath == "" { b.config.X509UploadPath = "/tmp" } // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) validates := map[string]*string{ "bundle_upload_command": &b.config.BundleUploadCommand, "bundle_vol_command": &b.config.BundleVolCommand, } for n, ptr := range validates { if err := b.config.tpl.Validate(*ptr); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error parsing %s: %s", n, err)) } } templates := map[string]*string{ "account_id": &b.config.AccountId, "ami_name": &b.config.AMIName, "bundle_destination": &b.config.BundleDestination, "bundle_prefix": &b.config.BundlePrefix, "s3_bucket": &b.config.S3Bucket, "x509_cert_path": &b.config.X509CertPath, "x509_key_path": &b.config.X509KeyPath, "x509_upload_path": &b.config.X509UploadPath, } for n, ptr := range templates { var err error *ptr, err = b.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } if b.config.AccountId == "" { errs = packer.MultiErrorAppend(errs, errors.New("account_id is required")) } else { b.config.AccountId = strings.Replace(b.config.AccountId, "-", "", -1) } if b.config.S3Bucket == "" { errs = packer.MultiErrorAppend(errs, errors.New("s3_bucket is required")) } if b.config.X509CertPath == "" { errs = packer.MultiErrorAppend(errs, errors.New("x509_cert_path is required")) } else if _, err := os.Stat(b.config.X509CertPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("x509_cert_path points to bad file: %s", err)) } if b.config.X509KeyPath == "" { errs = packer.MultiErrorAppend(errs, errors.New("x509_key_path is required")) } else if _, err := os.Stat(b.config.X509KeyPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("x509_key_path points to bad file: %s", err)) } if errs != nil && len(errs.Errors) > 0 { return nil, errs } log.Println(common.ScrubConfig(b.config, b.config.AccessKey, b.config.SecretKey)) return nil, nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) warnings := make([]string, 0) if b.config.DiskName == "" { b.config.DiskName = "disk" } if b.config.DiskSize == 0 { b.config.DiskSize = 40000 } if b.config.DiskTypeId == "" { // Default is growable virtual disk split in 2GB files. b.config.DiskTypeId = "1" if b.config.RemoteType == "esx5" { b.config.DiskTypeId = "zeroedthick" } } if b.config.FloppyFiles == nil { b.config.FloppyFiles = make([]string, 0) } if b.config.GuestOSType == "" { b.config.GuestOSType = "other" } if b.config.VMName == "" { b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName) } if b.config.HTTPPortMin == 0 { b.config.HTTPPortMin = 8000 } if b.config.HTTPPortMax == 0 { b.config.HTTPPortMax = 9000 } if b.config.RawBootWait == "" { b.config.RawBootWait = "10s" } if b.config.VNCPortMin == 0 { b.config.VNCPortMin = 5900 } if b.config.VNCPortMax == 0 { b.config.VNCPortMax = 6000 } if b.config.OutputDir == "" { b.config.OutputDir = fmt.Sprintf("output-%s", b.config.PackerBuildName) } if b.config.RemoteUser == "" { b.config.RemoteUser = "******" } if b.config.RemoteDatastore == "" { b.config.RemoteDatastore = "datastore1" } if b.config.RemotePort == 0 { b.config.RemotePort = 22 } if b.config.SSHPort == 0 { b.config.SSHPort = 22 } if b.config.ToolsUploadPath == "" { b.config.ToolsUploadPath = "{{ .Flavor }}.iso" } // Errors templates := map[string]*string{ "disk_name": &b.config.DiskName, "guest_os_type": &b.config.GuestOSType, "http_directory": &b.config.HTTPDir, "iso_checksum": &b.config.ISOChecksum, "iso_checksum_type": &b.config.ISOChecksumType, "iso_url": &b.config.RawSingleISOUrl, "output_directory": &b.config.OutputDir, "shutdown_command": &b.config.ShutdownCommand, "ssh_key_path": &b.config.SSHKeyPath, "ssh_password": &b.config.SSHPassword, "ssh_username": &b.config.SSHUser, "tools_upload_flavor": &b.config.ToolsUploadFlavor, "vm_name": &b.config.VMName, "boot_wait": &b.config.RawBootWait, "shutdown_timeout": &b.config.RawShutdownTimeout, "ssh_wait_timeout": &b.config.RawSSHWaitTimeout, "vmx_template_path": &b.config.VMXTemplatePath, "remote_type": &b.config.RemoteType, "remote_host": &b.config.RemoteHost, "remote_datastore": &b.config.RemoteDatastore, "remote_user": &b.config.RemoteUser, "remote_password": &b.config.RemotePassword, } for n, ptr := range templates { var err error *ptr, err = b.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } for i, url := range b.config.ISOUrls { var err error b.config.ISOUrls[i], err = b.config.tpl.Process(url, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing iso_urls[%d]: %s", i, err)) } } for i, command := range b.config.BootCommand { if err := b.config.tpl.Validate(command); err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing boot_command[%d]: %s", i, err)) } } for i, file := range b.config.FloppyFiles { var err error b.config.FloppyFiles[i], err = b.config.tpl.Process(file, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing floppy_files[%d]: %s", i, err)) } } newVMXData := make(map[string]string) for k, v := range b.config.VMXData { k, err = b.config.tpl.Process(k, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing VMX data key %s: %s", k, err)) continue } v, err = b.config.tpl.Process(v, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing VMX data value '%s': %s", v, err)) continue } newVMXData[k] = v } b.config.VMXData = newVMXData if b.config.HTTPPortMin > b.config.HTTPPortMax { errs = packer.MultiErrorAppend( errs, errors.New("http_port_min must be less than http_port_max")) } if b.config.ISOChecksum == "" { errs = packer.MultiErrorAppend( errs, errors.New("Due to large file sizes, an iso_checksum is required")) } else { b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum) } if b.config.ISOChecksumType == "" { errs = packer.MultiErrorAppend( errs, errors.New("The iso_checksum_type must be specified.")) } else { b.config.ISOChecksumType = strings.ToLower(b.config.ISOChecksumType) if h := common.HashForType(b.config.ISOChecksumType); h == nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Unsupported checksum type: %s", b.config.ISOChecksumType)) } } if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 { errs = packer.MultiErrorAppend( errs, errors.New("One of iso_url or iso_urls must be specified.")) } else if b.config.RawSingleISOUrl != "" && len(b.config.ISOUrls) > 0 { errs = packer.MultiErrorAppend( errs, errors.New("Only one of iso_url or iso_urls may be specified.")) } else if b.config.RawSingleISOUrl != "" { b.config.ISOUrls = []string{b.config.RawSingleISOUrl} } for i, url := range b.config.ISOUrls { b.config.ISOUrls[i], err = common.DownloadableURL(url) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err)) } } if !b.config.PackerForce { if _, err := os.Stat(b.config.OutputDir); err == nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Output directory '%s' already exists. It must not exist.", b.config.OutputDir)) } } if b.config.SSHKeyPath != "" { if _, err := os.Stat(b.config.SSHKeyPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("ssh_key_path is invalid: %s", err)) } else if _, err := sshKeyToKeyring(b.config.SSHKeyPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("ssh_key_path is invalid: %s", err)) } } if b.config.SSHUser == "" { errs = packer.MultiErrorAppend( errs, errors.New("An ssh_username must be specified.")) } if b.config.RawBootWait != "" { b.config.bootWait, err = time.ParseDuration(b.config.RawBootWait) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed parsing boot_wait: %s", err)) } } if b.config.RawShutdownTimeout == "" { b.config.RawShutdownTimeout = "5m" } b.config.shutdownTimeout, err = time.ParseDuration(b.config.RawShutdownTimeout) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err)) } if b.config.RawSSHWaitTimeout == "" { b.config.RawSSHWaitTimeout = "20m" } b.config.sshWaitTimeout, err = time.ParseDuration(b.config.RawSSHWaitTimeout) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed parsing ssh_wait_timeout: %s", err)) } if _, err := template.New("path").Parse(b.config.ToolsUploadPath); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("tools_upload_path invalid: %s", err)) } if b.config.VMXTemplatePath != "" { if err := b.validateVMXTemplatePath(); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("vmx_template_path is invalid: %s", err)) } } if b.config.VNCPortMin > b.config.VNCPortMax { errs = packer.MultiErrorAppend( errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max")) } // Remote configuration validation if b.config.RemoteType != "" { if b.config.RemoteHost == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("remote_host must be specified")) } } // Warnings if b.config.ShutdownCommand == "" { warnings = append(warnings, "A shutdown_command was not specified. Without a shutdown command, Packer\n"+ "will forcibly halt the virtual machine, which may result in data loss.") } if errs != nil && len(errs.Errors) > 0 { return warnings, errs } return warnings, nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars // Accumulate any errors and warnings errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.FloppyConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend( errs, b.config.OutputConfig.Prepare(b.config.tpl, &b.config.PackerConfig)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.SSHConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.PrlctlConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.PrlctlVersionConfig.Prepare(b.config.tpl)...) warnings := make([]string, 0) if b.config.DiskSize == 0 { b.config.DiskSize = 40000 } if b.config.ParallelsToolsMode == "" { b.config.ParallelsToolsMode = "upload" } if b.config.ParallelsToolsGuestPath == "" { b.config.ParallelsToolsGuestPath = "prl-tools.iso" } if b.config.ParallelsToolsHostPath == "" { b.config.ParallelsToolsHostPath = "/Applications/Parallels Desktop.app/Contents/Resources/Tools/prl-tools-other.iso" } if b.config.HardDriveInterface == "" { b.config.HardDriveInterface = "sata" } if b.config.GuestOSType == "" { b.config.GuestOSType = "other" } if b.config.GuestOSDistribution == "" { b.config.GuestOSDistribution = "other" } if b.config.HTTPPortMin == 0 { b.config.HTTPPortMin = 8000 } if b.config.HTTPPortMax == 0 { b.config.HTTPPortMax = 9000 } if len(b.config.HostInterfaces) == 0 { b.config.HostInterfaces = []string{"en0", "en1", "en2", "en3", "en4", "en5", "en6", "en7", "en8", "en9", "ppp0", "ppp1", "ppp2"} } if b.config.VMName == "" { b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName) } // Errors templates := map[string]*string{ "parallels_tools_mode": &b.config.ParallelsToolsMode, "parallels_tools_host_path": &b.config.ParallelsToolsHostPath, "parallels_tools_guest_path": &b.config.ParallelsToolsGuestPath, "guest_os_type": &b.config.GuestOSType, "guest_os_distribution": &b.config.GuestOSDistribution, "hard_drive_interface": &b.config.HardDriveInterface, "http_directory": &b.config.HTTPDir, "iso_checksum": &b.config.ISOChecksum, "iso_checksum_type": &b.config.ISOChecksumType, "iso_url": &b.config.RawSingleISOUrl, "vm_name": &b.config.VMName, } for n, ptr := range templates { var err error *ptr, err = b.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } for i, url := range b.config.ISOUrls { var err error b.config.ISOUrls[i], err = b.config.tpl.Process(url, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing iso_urls[%d]: %s", i, err)) } } validates := map[string]*string{ "parallels_tools_guest_path": &b.config.ParallelsToolsGuestPath, } for n, ptr := range validates { if err := b.config.tpl.Validate(*ptr); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error parsing %s: %s", n, err)) } } for i, command := range b.config.BootCommand { if err := b.config.tpl.Validate(command); err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing boot_command[%d]: %s", i, err)) } } if b.config.HardDriveInterface != "ide" && b.config.HardDriveInterface != "sata" && b.config.HardDriveInterface != "scsi" { errs = packer.MultiErrorAppend( errs, errors.New("hard_drive_interface can only be ide, sata, or scsi")) } if b.config.HTTPPortMin > b.config.HTTPPortMax { errs = packer.MultiErrorAppend( errs, errors.New("http_port_min must be less than http_port_max")) } if b.config.ISOChecksumType == "" { errs = packer.MultiErrorAppend( errs, errors.New("The iso_checksum_type must be specified.")) } else { b.config.ISOChecksumType = strings.ToLower(b.config.ISOChecksumType) if b.config.ISOChecksumType != "none" { if b.config.ISOChecksum == "" { errs = packer.MultiErrorAppend( errs, errors.New("Due to large file sizes, an iso_checksum is required")) } else { b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum) } if h := common.HashForType(b.config.ISOChecksumType); h == nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Unsupported checksum type: %s", b.config.ISOChecksumType)) } } } if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 { errs = packer.MultiErrorAppend( errs, errors.New("One of iso_url or iso_urls must be specified.")) } else if b.config.RawSingleISOUrl != "" && len(b.config.ISOUrls) > 0 { errs = packer.MultiErrorAppend( errs, errors.New("Only one of iso_url or iso_urls may be specified.")) } else if b.config.RawSingleISOUrl != "" { b.config.ISOUrls = []string{b.config.RawSingleISOUrl} } for i, url := range b.config.ISOUrls { b.config.ISOUrls[i], err = common.DownloadableURL(url) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err)) } } validMode := false validModes := []string{ parallelscommon.ParallelsToolsModeDisable, parallelscommon.ParallelsToolsModeAttach, parallelscommon.ParallelsToolsModeUpload, } for _, mode := range validModes { if b.config.ParallelsToolsMode == mode { validMode = true break } } if !validMode { errs = packer.MultiErrorAppend(errs, fmt.Errorf("parallels_tools_mode is invalid. Must be one of: %v", validModes)) } // Warnings if b.config.ISOChecksumType == "none" { warnings = append(warnings, "A checksum type of 'none' was specified. Since ISO files are so big,\n"+ "a checksum is highly recommended.") } if b.config.ShutdownCommand == "" { warnings = append(warnings, "A shutdown_command was not specified. Without a shutdown command, Packer\n"+ "will forcibly halt the virtual machine, which may result in data loss.") } if errs != nil && len(errs.Errors) > 0 { return warnings, errs } return warnings, nil }
func (b *Builder) Prepare(raws ...interface{}) ([]string, error) { md, err := common.DecodeConfig(&b.config, raws...) if err != nil { return nil, err } b.config.tpl, err = packer.NewConfigTemplate() if err != nil { return nil, err } b.config.tpl.UserVars = b.config.PackerUserVars // Accumulate any errors errs := common.CheckUnusedConfig(md) errs = packer.MultiErrorAppend(errs, b.config.DriverConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.OutputConfig.Prepare(b.config.tpl, &b.config.PackerConfig)...) errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.SSHConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.ToolsConfig.Prepare(b.config.tpl)...) errs = packer.MultiErrorAppend(errs, b.config.VMXConfig.Prepare(b.config.tpl)...) warnings := make([]string, 0) if b.config.DiskName == "" { b.config.DiskName = "disk" } if b.config.DiskSize == 0 { b.config.DiskSize = 40000 } if b.config.DiskTypeId == "" { // Default is growable virtual disk split in 2GB files. b.config.DiskTypeId = "1" if b.config.RemoteType == "esx5" { b.config.DiskTypeId = "zeroedthick" } } if b.config.FloppyFiles == nil { b.config.FloppyFiles = make([]string, 0) } if b.config.GuestOSType == "" { b.config.GuestOSType = "other" } if b.config.VMName == "" { b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName) } if b.config.HTTPPortMin == 0 { b.config.HTTPPortMin = 8000 } if b.config.HTTPPortMax == 0 { b.config.HTTPPortMax = 9000 } if b.config.VNCPortMin == 0 { b.config.VNCPortMin = 5900 } if b.config.VNCPortMax == 0 { b.config.VNCPortMax = 6000 } if b.config.RemoteUser == "" { b.config.RemoteUser = "******" } if b.config.RemoteDatastore == "" { b.config.RemoteDatastore = "datastore1" } if b.config.RemotePort == 0 { b.config.RemotePort = 22 } // Errors templates := map[string]*string{ "disk_name": &b.config.DiskName, "guest_os_type": &b.config.GuestOSType, "http_directory": &b.config.HTTPDir, "iso_checksum": &b.config.ISOChecksum, "iso_checksum_type": &b.config.ISOChecksumType, "iso_url": &b.config.RawSingleISOUrl, "vm_name": &b.config.VMName, "vmx_template_path": &b.config.VMXTemplatePath, "remote_type": &b.config.RemoteType, "remote_host": &b.config.RemoteHost, "remote_datastore": &b.config.RemoteDatastore, "remote_user": &b.config.RemoteUser, "remote_password": &b.config.RemotePassword, } for n, ptr := range templates { var err error *ptr, err = b.config.tpl.Process(*ptr, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing %s: %s", n, err)) } } for i, url := range b.config.ISOUrls { var err error b.config.ISOUrls[i], err = b.config.tpl.Process(url, nil) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Error processing iso_urls[%d]: %s", i, err)) } } for i, command := range b.config.BootCommand { if err := b.config.tpl.Validate(command); err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing boot_command[%d]: %s", i, err)) } } for i, file := range b.config.FloppyFiles { var err error b.config.FloppyFiles[i], err = b.config.tpl.Process(file, nil) if err != nil { errs = packer.MultiErrorAppend(errs, fmt.Errorf("Error processing floppy_files[%d]: %s", i, err)) } } if b.config.HTTPPortMin > b.config.HTTPPortMax { errs = packer.MultiErrorAppend( errs, errors.New("http_port_min must be less than http_port_max")) } if b.config.ISOChecksumType == "" { errs = packer.MultiErrorAppend( errs, errors.New("The iso_checksum_type must be specified.")) } else { b.config.ISOChecksumType = strings.ToLower(b.config.ISOChecksumType) if b.config.ISOChecksumType != "none" { if b.config.ISOChecksum == "" { errs = packer.MultiErrorAppend( errs, errors.New("Due to large file sizes, an iso_checksum is required")) } else { b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum) } if h := common.HashForType(b.config.ISOChecksumType); h == nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Unsupported checksum type: %s", b.config.ISOChecksumType)) } } } if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 { errs = packer.MultiErrorAppend( errs, errors.New("One of iso_url or iso_urls must be specified.")) } else if b.config.RawSingleISOUrl != "" && len(b.config.ISOUrls) > 0 { errs = packer.MultiErrorAppend( errs, errors.New("Only one of iso_url or iso_urls may be specified.")) } else if b.config.RawSingleISOUrl != "" { b.config.ISOUrls = []string{b.config.RawSingleISOUrl} } for i, url := range b.config.ISOUrls { b.config.ISOUrls[i], err = common.DownloadableURL(url) if err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err)) } } if b.config.VMXTemplatePath != "" { if err := b.validateVMXTemplatePath(); err != nil { errs = packer.MultiErrorAppend( errs, fmt.Errorf("vmx_template_path is invalid: %s", err)) } } if b.config.VNCPortMin > b.config.VNCPortMax { errs = packer.MultiErrorAppend( errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max")) } // Remote configuration validation if b.config.RemoteType != "" { if b.config.RemoteHost == "" { errs = packer.MultiErrorAppend(errs, fmt.Errorf("remote_host must be specified")) } } // Warnings if b.config.ISOChecksumType == "none" { warnings = append(warnings, "A checksum type of 'none' was specified. Since ISO files are so big,\n"+ "a checksum is highly recommended.") } if b.config.ShutdownCommand == "" { warnings = append(warnings, "A shutdown_command was not specified. Without a shutdown command, Packer\n"+ "will forcibly halt the virtual machine, which may result in data loss.") } if errs != nil && len(errs.Errors) > 0 { return warnings, errs } return warnings, nil }