diff --git a/builder/amazon/common/step_run_source_instance.go b/builder/amazon/common/step_run_source_instance.go index 3b2183be1..a3dca8057 100644 --- a/builder/amazon/common/step_run_source_instance.go +++ b/builder/amazon/common/step_run_source_instance.go @@ -5,14 +5,10 @@ import ( "fmt" "io/ioutil" "log" - "strconv" - "time" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/service/ec2" - retry "github.com/hashicorp/packer/common" "github.com/hashicorp/packer/packer" "github.com/hashicorp/packer/template/interpolate" "github.com/mitchellh/multistep" @@ -29,8 +25,6 @@ type StepRunSourceInstance struct { InstanceInitiatedShutdownBehavior string InstanceType string SourceAMI string - SpotPrice string - SpotPriceProduct string SubnetId string Tags map[string]string VolumeTags map[string]string @@ -38,8 +32,7 @@ type StepRunSourceInstance struct { UserDataFile string Ctx interpolate.Context - instanceId string - spotRequest *ec2.SpotInstanceRequest + instanceId string } func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction { @@ -84,57 +77,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi return multistep.ActionHalt } - spotPrice := s.SpotPrice - availabilityZone := s.AvailabilityZone - if spotPrice == "auto" { - ui.Message(fmt.Sprintf( - "Finding spot price for %s %s...", - s.SpotPriceProduct, s.InstanceType)) - - // Detect the spot price - startTime := time.Now().Add(-1 * time.Hour) - resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{ - InstanceTypes: []*string{&s.InstanceType}, - ProductDescriptions: []*string{&s.SpotPriceProduct}, - AvailabilityZone: &s.AvailabilityZone, - StartTime: &startTime, - }) - if err != nil { - err := fmt.Errorf("Error finding spot price: %s", err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - - var price float64 - for _, history := range resp.SpotPriceHistory { - log.Printf("[INFO] Candidate spot price: %s", *history.SpotPrice) - current, err := strconv.ParseFloat(*history.SpotPrice, 64) - if err != nil { - log.Printf("[ERR] Error parsing spot price: %s", err) - continue - } - if price == 0 || current < price { - price = current - if s.AvailabilityZone == "" { - availabilityZone = *history.AvailabilityZone - } - } - } - if price == 0 { - err := fmt.Errorf("No candidate spot prices found!") - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } else { - // Add 0.5 cents to minimum spot bid to ensure capacity will be available - // Avoids price-too-low error in active markets which can fluctuate - price = price + 0.005 - } - - spotPrice = strconv.FormatFloat(price, 'f', -1, 64) - } - var instanceId string ui.Say("Adding tags to source instance") @@ -142,7 +84,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi s.Tags["Name"] = "Packer Builder" } - createTagsAfterInstanceStarts := true ec2Tags, err := ConvertToEC2Tags(s.Tags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx) if err != nil { err := fmt.Errorf("Error tagging source instance: %s", err) @@ -152,7 +93,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi } ReportTags(ui, ec2Tags) - createVolTagsAfterInstanceStarts := true volTags, err := ConvertToEC2Tags(s.VolumeTags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx) if err != nil { err := fmt.Errorf("Error tagging volumes: %s", err) @@ -161,155 +101,74 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi return multistep.ActionHalt } - if spotPrice == "" || spotPrice == "0" { - - runOpts := &ec2.RunInstancesInput{ - ImageId: &s.SourceAMI, - InstanceType: &s.InstanceType, - UserData: &userData, - MaxCount: aws.Int64(1), - MinCount: aws.Int64(1), - IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile}, - BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(), - Placement: &ec2.Placement{AvailabilityZone: &s.AvailabilityZone}, - EbsOptimized: &s.EbsOptimized, - } - - var tagSpecs []*ec2.TagSpecification - - if len(ec2Tags) > 0 { - runTags := &ec2.TagSpecification{ - ResourceType: aws.String("instance"), - Tags: ec2Tags, - } - - tagSpecs = append(tagSpecs, runTags) - createTagsAfterInstanceStarts = false - } - - if len(volTags) > 0 { - runVolTags := &ec2.TagSpecification{ - ResourceType: aws.String("volume"), - Tags: volTags, - } - - tagSpecs = append(tagSpecs, runVolTags) - createVolTagsAfterInstanceStarts = false - } - - if len(tagSpecs) > 0 { - runOpts.SetTagSpecifications(tagSpecs) - } - - if keyName != "" { - runOpts.KeyName = &keyName - } - - if s.SubnetId != "" && s.AssociatePublicIpAddress { - runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{ - { - DeviceIndex: aws.Int64(0), - AssociatePublicIpAddress: &s.AssociatePublicIpAddress, - SubnetId: &s.SubnetId, - Groups: securityGroupIds, - DeleteOnTermination: aws.Bool(true), - }, - } - } else { - runOpts.SubnetId = &s.SubnetId - runOpts.SecurityGroupIds = securityGroupIds - } - - if s.ExpectedRootDevice == "ebs" { - runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior - } - - runResp, err := ec2conn.RunInstances(runOpts) - if err != nil { - err := fmt.Errorf("Error launching source instance: %s", err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - instanceId = *runResp.Instances[0].InstanceId - } else { - ui.Message(fmt.Sprintf( - "Requesting spot instance '%s' for: %s", - s.InstanceType, spotPrice)) - - runOpts := &ec2.RequestSpotLaunchSpecification{ - ImageId: &s.SourceAMI, - InstanceType: &s.InstanceType, - UserData: &userData, - IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile}, - Placement: &ec2.SpotPlacement{ - AvailabilityZone: &availabilityZone, - }, - BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(), - EbsOptimized: &s.EbsOptimized, - } - - if s.SubnetId != "" && s.AssociatePublicIpAddress { - runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{ - { - DeviceIndex: aws.Int64(0), - AssociatePublicIpAddress: &s.AssociatePublicIpAddress, - SubnetId: &s.SubnetId, - Groups: securityGroupIds, - DeleteOnTermination: aws.Bool(true), - }, - } - } else { - runOpts.SubnetId = &s.SubnetId - runOpts.SecurityGroupIds = securityGroupIds - } - - if keyName != "" { - runOpts.KeyName = &keyName - } - - runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{ - SpotPrice: &spotPrice, - LaunchSpecification: runOpts, - }) - if err != nil { - err := fmt.Errorf("Error launching source spot instance: %s", err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - - s.spotRequest = runSpotResp.SpotInstanceRequests[0] - - spotRequestId := s.spotRequest.SpotInstanceRequestId - ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", *spotRequestId)) - stateChange := StateChangeConf{ - Pending: []string{"open"}, - Target: "active", - Refresh: SpotRequestStateRefreshFunc(ec2conn, *spotRequestId), - StepState: state, - } - _, err = WaitForState(&stateChange) - if err != nil { - err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", *spotRequestId, err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - - spotResp, err := ec2conn.DescribeSpotInstanceRequests(&ec2.DescribeSpotInstanceRequestsInput{ - SpotInstanceRequestIds: []*string{spotRequestId}, - }) - if err != nil { - err := fmt.Errorf("Error finding spot request (%s): %s", *spotRequestId, err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - instanceId = *spotResp.SpotInstanceRequests[0].InstanceId - + runOpts := &ec2.RunInstancesInput{ + ImageId: &s.SourceAMI, + InstanceType: &s.InstanceType, + UserData: &userData, + MaxCount: aws.Int64(1), + MinCount: aws.Int64(1), + IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile}, + BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(), + Placement: &ec2.Placement{AvailabilityZone: &s.AvailabilityZone}, + EbsOptimized: &s.EbsOptimized, } + var tagSpecs []*ec2.TagSpecification + + if len(ec2Tags) > 0 { + runTags := &ec2.TagSpecification{ + ResourceType: aws.String("instance"), + Tags: ec2Tags, + } + + tagSpecs = append(tagSpecs, runTags) + } + + if len(volTags) > 0 { + runVolTags := &ec2.TagSpecification{ + ResourceType: aws.String("volume"), + Tags: volTags, + } + + tagSpecs = append(tagSpecs, runVolTags) + } + + if len(tagSpecs) > 0 { + runOpts.SetTagSpecifications(tagSpecs) + } + + if keyName != "" { + runOpts.KeyName = &keyName + } + + if s.SubnetId != "" && s.AssociatePublicIpAddress { + runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{ + { + DeviceIndex: aws.Int64(0), + AssociatePublicIpAddress: &s.AssociatePublicIpAddress, + SubnetId: &s.SubnetId, + Groups: securityGroupIds, + DeleteOnTermination: aws.Bool(true), + }, + } + } else { + runOpts.SubnetId = &s.SubnetId + runOpts.SecurityGroupIds = securityGroupIds + } + + if s.ExpectedRootDevice == "ebs" { + runOpts.InstanceInitiatedShutdownBehavior = &s.InstanceInitiatedShutdownBehavior + } + + runResp, err := ec2conn.RunInstances(runOpts) + if err != nil { + err := fmt.Errorf("Error launching source instance: %s", err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + instanceId = *runResp.Instances[0].InstanceId + // Set the instance ID so that the cleanup works properly s.instanceId = instanceId @@ -331,70 +190,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi instance := latestInstance.(*ec2.Instance) - if createTagsAfterInstanceStarts { - // Retry creating tags for about 2.5 minutes - err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) { - _, err := ec2conn.CreateTags(&ec2.CreateTagsInput{ - Tags: ec2Tags, - Resources: []*string{instance.InstanceId}, - }) - if err == nil { - return true, nil - } - if awsErr, ok := err.(awserr.Error); ok { - if awsErr.Code() == "InvalidInstanceID.NotFound" { - return false, nil - } - } - return true, err - }) - - if err != nil { - err := fmt.Errorf("Error tagging source instance: %s", err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - } - - if createVolTagsAfterInstanceStarts { - volumeIds := make([]*string, 0) - for _, v := range instance.BlockDeviceMappings { - if ebs := v.Ebs; ebs != nil { - volumeIds = append(volumeIds, ebs.VolumeId) - } - } - - if len(volumeIds) > 0 { - ui.Say("Adding tags to source EBS Volumes") - tags, err := ConvertToEC2Tags(s.VolumeTags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx) - if err != nil { - err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - - ReportTags(ui, tags) - - _, err = ec2conn.CreateTags(&ec2.CreateTagsInput{ - Resources: volumeIds, - Tags: tags, - }) - - if err != nil { - err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err) - state.Put("error", err) - ui.Error(err.Error()) - return multistep.ActionHalt - } - - return multistep.ActionContinue - - } - - } - if s.Debug { if instance.PublicDnsName != nil && *instance.PublicDnsName != "" { ui.Message(fmt.Sprintf("Public DNS: %s", *instance.PublicDnsName)) @@ -419,29 +214,6 @@ func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) { ec2conn := state.Get("ec2").(*ec2.EC2) ui := state.Get("ui").(packer.Ui) - // Cancel the spot request if it exists - if s.spotRequest != nil { - ui.Say("Cancelling the spot request...") - input := &ec2.CancelSpotInstanceRequestsInput{ - SpotInstanceRequestIds: []*string{s.spotRequest.SpotInstanceRequestId}, - } - if _, err := ec2conn.CancelSpotInstanceRequests(input); err != nil { - ui.Error(fmt.Sprintf("Error cancelling the spot request, may still be around: %s", err)) - return - } - stateChange := StateChangeConf{ - Pending: []string{"active", "open"}, - Refresh: SpotRequestStateRefreshFunc(ec2conn, *s.spotRequest.SpotInstanceRequestId), - Target: "cancelled", - } - - _, err := WaitForState(&stateChange) - if err != nil { - ui.Error(err.Error()) - } - - } - // Terminate the source instance if it exists if s.instanceId != "" { ui.Say("Terminating the source AWS instance...") diff --git a/builder/amazon/common/step_run_spot_instance.go b/builder/amazon/common/step_run_spot_instance.go new file mode 100644 index 000000000..45d2ebaab --- /dev/null +++ b/builder/amazon/common/step_run_spot_instance.go @@ -0,0 +1,374 @@ +package common + +import ( + "encoding/base64" + "fmt" + "io/ioutil" + "log" + "strconv" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/ec2" + + retry "github.com/hashicorp/packer/common" + "github.com/hashicorp/packer/packer" + "github.com/hashicorp/packer/template/interpolate" + "github.com/mitchellh/multistep" +) + +type StepRunSpotInstance struct { + AssociatePublicIpAddress bool + AvailabilityZone string + BlockDevices BlockDevices + Debug bool + EbsOptimized bool + ExpectedRootDevice string + IamInstanceProfile string + InstanceInitiatedShutdownBehavior string + InstanceType string + SourceAMI string + SpotPrice string + SpotPriceProduct string + SubnetId string + Tags map[string]string + VolumeTags map[string]string + UserData string + UserDataFile string + Ctx interpolate.Context + + instanceId string + spotRequest *ec2.SpotInstanceRequest +} + +func (s *StepRunSpotInstance) Run(state multistep.StateBag) multistep.StepAction { + ec2conn := state.Get("ec2").(*ec2.EC2) + var keyName string + if name, ok := state.GetOk("keyPair"); ok { + keyName = name.(string) + } + securityGroupIds := aws.StringSlice(state.Get("securityGroupIds").([]string)) + ui := state.Get("ui").(packer.Ui) + + userData := s.UserData + if s.UserDataFile != "" { + contents, err := ioutil.ReadFile(s.UserDataFile) + if err != nil { + state.Put("error", fmt.Errorf("Problem reading user data file: %s", err)) + return multistep.ActionHalt + } + + userData = string(contents) + } + + // Test if it is encoded already, and if not, encode it + if _, err := base64.StdEncoding.DecodeString(userData); err != nil { + log.Printf("[DEBUG] base64 encoding user data...") + userData = base64.StdEncoding.EncodeToString([]byte(userData)) + } + + ui.Say("Launching a source AWS instance...") + image, ok := state.Get("source_image").(*ec2.Image) + if !ok { + state.Put("error", fmt.Errorf("source_image type assertion failed")) + return multistep.ActionHalt + } + s.SourceAMI = *image.ImageId + + if s.ExpectedRootDevice != "" && *image.RootDeviceType != s.ExpectedRootDevice { + state.Put("error", fmt.Errorf( + "The provided source AMI has an invalid root device type.\n"+ + "Expected '%s', got '%s'.", + s.ExpectedRootDevice, *image.RootDeviceType)) + return multistep.ActionHalt + } + + spotPrice := s.SpotPrice + availabilityZone := s.AvailabilityZone + if spotPrice == "auto" { + ui.Message(fmt.Sprintf( + "Finding spot price for %s %s...", + s.SpotPriceProduct, s.InstanceType)) + + // Detect the spot price + startTime := time.Now().Add(-1 * time.Hour) + resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistoryInput{ + InstanceTypes: []*string{&s.InstanceType}, + ProductDescriptions: []*string{&s.SpotPriceProduct}, + AvailabilityZone: &s.AvailabilityZone, + StartTime: &startTime, + }) + if err != nil { + err := fmt.Errorf("Error finding spot price: %s", err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + var price float64 + for _, history := range resp.SpotPriceHistory { + log.Printf("[INFO] Candidate spot price: %s", *history.SpotPrice) + current, err := strconv.ParseFloat(*history.SpotPrice, 64) + if err != nil { + log.Printf("[ERR] Error parsing spot price: %s", err) + continue + } + if price == 0 || current < price { + price = current + if s.AvailabilityZone == "" { + availabilityZone = *history.AvailabilityZone + } + } + } + if price == 0 { + err := fmt.Errorf("No candidate spot prices found!") + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } else { + // Add 0.5 cents to minimum spot bid to ensure capacity will be available + // Avoids price-too-low error in active markets which can fluctuate + price = price + 0.005 + } + + spotPrice = strconv.FormatFloat(price, 'f', -1, 64) + } + + var instanceId string + + ui.Say("Adding tags to source instance") + if _, exists := s.Tags["Name"]; !exists { + s.Tags["Name"] = "Packer Builder" + } + + ec2Tags, err := ConvertToEC2Tags(s.Tags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx) + if err != nil { + err := fmt.Errorf("Error tagging source instance: %s", err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + ReportTags(ui, ec2Tags) + + ui.Message(fmt.Sprintf( + "Requesting spot instance '%s' for: %s", + s.InstanceType, spotPrice)) + + runOpts := &ec2.RequestSpotLaunchSpecification{ + ImageId: &s.SourceAMI, + InstanceType: &s.InstanceType, + UserData: &userData, + IamInstanceProfile: &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile}, + Placement: &ec2.SpotPlacement{ + AvailabilityZone: &availabilityZone, + }, + BlockDeviceMappings: s.BlockDevices.BuildLaunchDevices(), + EbsOptimized: &s.EbsOptimized, + } + + if s.SubnetId != "" && s.AssociatePublicIpAddress { + runOpts.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{ + { + DeviceIndex: aws.Int64(0), + AssociatePublicIpAddress: &s.AssociatePublicIpAddress, + SubnetId: &s.SubnetId, + Groups: securityGroupIds, + DeleteOnTermination: aws.Bool(true), + }, + } + } else { + runOpts.SubnetId = &s.SubnetId + runOpts.SecurityGroupIds = securityGroupIds + } + + if keyName != "" { + runOpts.KeyName = &keyName + } + + runSpotResp, err := ec2conn.RequestSpotInstances(&ec2.RequestSpotInstancesInput{ + SpotPrice: &spotPrice, + LaunchSpecification: runOpts, + }) + if err != nil { + err := fmt.Errorf("Error launching source spot instance: %s", err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + s.spotRequest = runSpotResp.SpotInstanceRequests[0] + + spotRequestId := s.spotRequest.SpotInstanceRequestId + ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", *spotRequestId)) + stateChange := StateChangeConf{ + Pending: []string{"open"}, + Target: "active", + Refresh: SpotRequestStateRefreshFunc(ec2conn, *spotRequestId), + StepState: state, + } + _, err = WaitForState(&stateChange) + if err != nil { + err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", *spotRequestId, err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + spotResp, err := ec2conn.DescribeSpotInstanceRequests(&ec2.DescribeSpotInstanceRequestsInput{ + SpotInstanceRequestIds: []*string{spotRequestId}, + }) + if err != nil { + err := fmt.Errorf("Error finding spot request (%s): %s", *spotRequestId, err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + instanceId = *spotResp.SpotInstanceRequests[0].InstanceId + + // Set the instance ID so that the cleanup works properly + s.instanceId = instanceId + + ui.Message(fmt.Sprintf("Instance ID: %s", instanceId)) + ui.Say(fmt.Sprintf("Waiting for instance (%v) to become ready...", instanceId)) + stateChangeSpot := StateChangeConf{ + Pending: []string{"pending"}, + Target: "running", + Refresh: InstanceStateRefreshFunc(ec2conn, instanceId), + StepState: state, + } + latestInstance, err := WaitForState(&stateChangeSpot) + if err != nil { + err := fmt.Errorf("Error waiting for instance (%s) to become ready: %s", instanceId, err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + instance := latestInstance.(*ec2.Instance) + + // Retry creating tags for about 2.5 minutes + err = retry.Retry(0.2, 30, 11, func(_ uint) (bool, error) { + _, err := ec2conn.CreateTags(&ec2.CreateTagsInput{ + Tags: ec2Tags, + Resources: []*string{instance.InstanceId}, + }) + if err == nil { + return true, nil + } + if awsErr, ok := err.(awserr.Error); ok { + if awsErr.Code() == "InvalidInstanceID.NotFound" { + return false, nil + } + } + return true, err + }) + + if err != nil { + err := fmt.Errorf("Error tagging source instance: %s", err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + volumeIds := make([]*string, 0) + for _, v := range instance.BlockDeviceMappings { + if ebs := v.Ebs; ebs != nil { + volumeIds = append(volumeIds, ebs.VolumeId) + } + } + + if len(volumeIds) > 0 { + ui.Say("Adding tags to source EBS Volumes") + tags, err := ConvertToEC2Tags(s.VolumeTags, *ec2conn.Config.Region, s.SourceAMI, s.Ctx) + if err != nil { + err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + ReportTags(ui, tags) + + _, err = ec2conn.CreateTags(&ec2.CreateTagsInput{ + Resources: volumeIds, + Tags: tags, + }) + + if err != nil { + err := fmt.Errorf("Error tagging source EBS Volumes on %s: %s", *instance.InstanceId, err) + state.Put("error", err) + ui.Error(err.Error()) + return multistep.ActionHalt + } + + return multistep.ActionContinue + + } + + if s.Debug { + if instance.PublicDnsName != nil && *instance.PublicDnsName != "" { + ui.Message(fmt.Sprintf("Public DNS: %s", *instance.PublicDnsName)) + } + + if instance.PublicIpAddress != nil && *instance.PublicIpAddress != "" { + ui.Message(fmt.Sprintf("Public IP: %s", *instance.PublicIpAddress)) + } + + if instance.PrivateIpAddress != nil && *instance.PrivateIpAddress != "" { + ui.Message(fmt.Sprintf("Private IP: %s", *instance.PrivateIpAddress)) + } + } + + state.Put("instance", instance) + + return multistep.ActionContinue +} + +func (s *StepRunSpotInstance) Cleanup(state multistep.StateBag) { + + ec2conn := state.Get("ec2").(*ec2.EC2) + ui := state.Get("ui").(packer.Ui) + + // Cancel the spot request if it exists + if s.spotRequest != nil { + ui.Say("Cancelling the spot request...") + input := &ec2.CancelSpotInstanceRequestsInput{ + SpotInstanceRequestIds: []*string{s.spotRequest.SpotInstanceRequestId}, + } + if _, err := ec2conn.CancelSpotInstanceRequests(input); err != nil { + ui.Error(fmt.Sprintf("Error cancelling the spot request, may still be around: %s", err)) + return + } + stateChange := StateChangeConf{ + Pending: []string{"active", "open"}, + Refresh: SpotRequestStateRefreshFunc(ec2conn, *s.spotRequest.SpotInstanceRequestId), + Target: "cancelled", + } + + _, err := WaitForState(&stateChange) + if err != nil { + ui.Error(err.Error()) + } + + } + + // Terminate the source instance if it exists + if s.instanceId != "" { + ui.Say("Terminating the source AWS instance...") + if _, err := ec2conn.TerminateInstances(&ec2.TerminateInstancesInput{InstanceIds: []*string{&s.instanceId}}); err != nil { + ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err)) + return + } + stateChange := StateChangeConf{ + Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"}, + Refresh: InstanceStateRefreshFunc(ec2conn, s.instanceId), + Target: "terminated", + } + + _, err := WaitForState(&stateChange) + if err != nil { + ui.Error(err.Error()) + } + } +} diff --git a/builder/amazon/ebs/builder.go b/builder/amazon/ebs/builder.go index 5c1b0128b..53d4d6692 100644 --- a/builder/amazon/ebs/builder.go +++ b/builder/amazon/ebs/builder.go @@ -108,6 +108,50 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe state.Put("hook", hook) state.Put("ui", ui) + var instanceStep multistep.Step + + if b.config.SpotPrice == "" || b.config.SpotPrice == "0" { + instanceStep = &awscommon.StepRunSpotInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + SpotPrice: b.config.SpotPrice, + SpotPriceProduct: b.config.SpotPriceAutoProduct, + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + VolumeTags: b.config.VolumeRunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } else { + instanceStep = &awscommon.StepRunSourceInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + VolumeTags: b.config.VolumeRunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } + // Build the steps steps := []multistep.Step{ &awscommon.StepPreValidate{ @@ -136,26 +180,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe &stepCleanupVolumes{ BlockDevices: b.config.BlockDevices, }, - &awscommon.StepRunSourceInstance{ - Debug: b.config.PackerDebug, - ExpectedRootDevice: "ebs", - SpotPrice: b.config.SpotPrice, - SpotPriceProduct: b.config.SpotPriceAutoProduct, - InstanceType: b.config.InstanceType, - UserData: b.config.UserData, - UserDataFile: b.config.UserDataFile, - SourceAMI: b.config.SourceAmi, - IamInstanceProfile: b.config.IamInstanceProfile, - SubnetId: b.config.SubnetId, - AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, - EbsOptimized: b.config.EbsOptimized, - AvailabilityZone: b.config.AvailabilityZone, - BlockDevices: b.config.BlockDevices, - Tags: b.config.RunTags, - VolumeTags: b.config.VolumeRunTags, - Ctx: b.config.ctx, - InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, - }, + instanceStep, &awscommon.StepGetPassword{ Debug: b.config.PackerDebug, Comm: &b.config.RunConfig.Comm, diff --git a/builder/amazon/ebssurrogate/builder.go b/builder/amazon/ebssurrogate/builder.go index 20984fee5..6c0b279e1 100644 --- a/builder/amazon/ebssurrogate/builder.go +++ b/builder/amazon/ebssurrogate/builder.go @@ -122,6 +122,50 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe state.Put("hook", hook) state.Put("ui", ui) + var instanceStep multistep.Step + + if b.config.SpotPrice == "" || b.config.SpotPrice == "0" { + instanceStep = &awscommon.StepRunSpotInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + SpotPrice: b.config.SpotPrice, + SpotPriceProduct: b.config.SpotPriceAutoProduct, + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + VolumeTags: b.config.VolumeRunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } else { + instanceStep = &awscommon.StepRunSourceInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + VolumeTags: b.config.VolumeRunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } + // Build the steps steps := []multistep.Step{ &awscommon.StepPreValidate{ @@ -147,24 +191,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe CommConfig: &b.config.RunConfig.Comm, VpcId: b.config.VpcId, }, - &awscommon.StepRunSourceInstance{ - Debug: b.config.PackerDebug, - ExpectedRootDevice: "ebs", - SpotPrice: b.config.SpotPrice, - SpotPriceProduct: b.config.SpotPriceAutoProduct, - InstanceType: b.config.InstanceType, - UserData: b.config.UserData, - UserDataFile: b.config.UserDataFile, - SourceAMI: b.config.SourceAmi, - IamInstanceProfile: b.config.IamInstanceProfile, - SubnetId: b.config.SubnetId, - AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, - EbsOptimized: b.config.EbsOptimized, - AvailabilityZone: b.config.AvailabilityZone, - BlockDevices: b.config.BlockDevices, - Tags: b.config.RunTags, - InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, - }, + instanceStep, &awscommon.StepTagEBSVolumes{ VolumeRunTags: b.config.VolumeRunTags, Ctx: b.config.ctx, diff --git a/builder/amazon/ebsvolume/builder.go b/builder/amazon/ebsvolume/builder.go index 1aad1819a..adbe3efad 100644 --- a/builder/amazon/ebsvolume/builder.go +++ b/builder/amazon/ebsvolume/builder.go @@ -101,6 +101,46 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe state.Put("hook", hook) state.Put("ui", ui) + var instanceStep multistep.Step + + if b.config.SpotPrice == "" || b.config.SpotPrice == "0" { + instanceStep = &awscommon.StepRunSpotInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + SpotPrice: b.config.SpotPrice, + SpotPriceProduct: b.config.SpotPriceAutoProduct, + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + Tags: b.config.RunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } else { + instanceStep = &awscommon.StepRunSourceInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + Tags: b.config.RunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } + // Build the steps steps := []multistep.Step{ &awscommon.StepSourceAMIInfo{ @@ -122,25 +162,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe CommConfig: &b.config.RunConfig.Comm, VpcId: b.config.VpcId, }, - &awscommon.StepRunSourceInstance{ - Debug: b.config.PackerDebug, - ExpectedRootDevice: "ebs", - SpotPrice: b.config.SpotPrice, - SpotPriceProduct: b.config.SpotPriceAutoProduct, - InstanceType: b.config.InstanceType, - UserData: b.config.UserData, - UserDataFile: b.config.UserDataFile, - SourceAMI: b.config.SourceAmi, - IamInstanceProfile: b.config.IamInstanceProfile, - SubnetId: b.config.SubnetId, - AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, - EbsOptimized: b.config.EbsOptimized, - AvailabilityZone: b.config.AvailabilityZone, - BlockDevices: b.config.launchBlockDevices, - Tags: b.config.RunTags, - Ctx: b.config.ctx, - InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, - }, + instanceStep, &stepTagEBSVolumes{ VolumeMapping: b.config.VolumeMappings, Ctx: b.config.ctx, diff --git a/builder/amazon/instance/builder.go b/builder/amazon/instance/builder.go index 6329008fe..b13d8d8a5 100644 --- a/builder/amazon/instance/builder.go +++ b/builder/amazon/instance/builder.go @@ -193,6 +193,48 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe state.Put("hook", hook) state.Put("ui", ui) + var instanceStep multistep.Step + + if b.config.SpotPrice == "" || b.config.SpotPrice == "0" { + instanceStep = &awscommon.StepRunSpotInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + SpotPrice: b.config.SpotPrice, + SpotPriceProduct: b.config.SpotPriceAutoProduct, + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } else { + instanceStep = &awscommon.StepRunSourceInstance{ + Debug: b.config.PackerDebug, + ExpectedRootDevice: "ebs", + InstanceType: b.config.InstanceType, + UserData: b.config.UserData, + UserDataFile: b.config.UserDataFile, + SourceAMI: b.config.SourceAmi, + IamInstanceProfile: b.config.IamInstanceProfile, + SubnetId: b.config.SubnetId, + AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, + EbsOptimized: b.config.EbsOptimized, + AvailabilityZone: b.config.AvailabilityZone, + BlockDevices: b.config.BlockDevices, + Tags: b.config.RunTags, + Ctx: b.config.ctx, + InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior, + } + } + // Build the steps steps := []multistep.Step{ &awscommon.StepPreValidate{ @@ -218,23 +260,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe SecurityGroupIds: b.config.SecurityGroupIds, VpcId: b.config.VpcId, }, - &awscommon.StepRunSourceInstance{ - Debug: b.config.PackerDebug, - SpotPrice: b.config.SpotPrice, - SpotPriceProduct: b.config.SpotPriceAutoProduct, - InstanceType: b.config.InstanceType, - IamInstanceProfile: b.config.IamInstanceProfile, - UserData: b.config.UserData, - UserDataFile: b.config.UserDataFile, - SourceAMI: b.config.SourceAmi, - SubnetId: b.config.SubnetId, - AssociatePublicIpAddress: b.config.AssociatePublicIpAddress, - EbsOptimized: b.config.EbsOptimized, - AvailabilityZone: b.config.AvailabilityZone, - BlockDevices: b.config.BlockDevices, - Tags: b.config.RunTags, - Ctx: b.config.ctx, - }, + instanceStep, &awscommon.StepGetPassword{ Debug: b.config.PackerDebug, Comm: &b.config.RunConfig.Comm,