// setTags is a helper to set the tags for a resource. It expects the // tags field to be named "tags" func setTags(conn *ec2.EC2, d *schema.ResourceData) error { if d.HasChange("tags") { oraw, nraw := d.GetChange("tags") o := oraw.(map[string]interface{}) n := nraw.(map[string]interface{}) create, remove := diffTags(tagsFromMap(o), tagsFromMap(n)) // Set tags if len(remove) > 0 { log.Printf("[DEBUG] Removing tags: %#v from %s", remove, d.Id()) _, err := conn.DeleteTags(&ec2.DeleteTagsInput{ Resources: []*string{aws.String(d.Id())}, Tags: remove, }) if err != nil { return err } } if len(create) > 0 { log.Printf("[DEBUG] Creating tags: %s for %s", awsutil.StringValue(create), d.Id()) _, err := conn.CreateTags(&ec2.CreateTagsInput{ Resources: []*string{aws.String(d.Id())}, Tags: create, }) if err != nil { return err } } } return nil }
// TagVolumesForInstance tags the volumes attached to a given instance with a // specified string and the device name func TagVolumesForInstance(c *ec2.EC2, i *ec2.Instance, n *string) error { for _, m := range i.BlockDeviceMappings { dn := m.DeviceName e := m.Ebs.VolumeId fmt.Printf("Tag volume %s: %s - %s\n", *e, *n, *dn) p := &ec2.CreateTagsInput{ Resources: []*string{ aws.String(*e), }, Tags: []*ec2.Tag{ { Key: aws.String("Name"), Value: aws.String(fmt.Sprintf("%s - %s", *n, *dn)), }, }, DryRun: aws.Bool(*DryRun), } resp, err := c.CreateTags(p) if err != nil { // Don't return because apparently when `DryRun` is set to true, // the API object also comes with an error. fmt.Println(err) } fmt.Println(resp) } return nil }
func addDockerTagToResource(ec2Client *ec2.EC2, resource string, tagValue string, nameValue string) (taggedResource string, err error) { tags := []*ec2.Tag{} tags = append(tags, createTag(dockerEnvTag, tagValue)) tags = append(tags, createTag(nameTag, nameValue)) resourceArray := []*string{} resourceArray = append(resourceArray, &resource) tagCreateOutput, callErr := ec2Client.CreateTags(&ec2.CreateTagsInput{ Resources: resourceArray, Tags: tags, }) if err != nil { err = callErr log.WithFields(log.Fields{ "AWS Error": err.Error(), "Resource": resource, }).Error("Error adding tags to VPC") taggedResource = "" } else { taggedResource = resource } log.WithFields(log.Fields{ "Tags created": tagCreateOutput.SDKShapeTraits, }).Debug("Tags created") return taggedResource, err }
func updateTags(ctx context.Context, svc ec2.EC2, resourceIds []*string) { if len(ctx.Tags) <= 0 { return } _, err := svc.CreateTags(&ec2.CreateTagsInput{ Resources: resourceIds, Tags: tagArgsToEc2Tags(ctx.Tags), }) kingpin.FatalIfError(err, "Could not update tags for EC2 resources %s", resourceIds) }
// setTags is a helper to set the tags for a resource. It expects the // tags field to be named "tags" func setTags(conn *ec2.EC2, d *schema.ResourceData) error { if d.HasChange("tags") { oraw, nraw := d.GetChange("tags") o := oraw.(map[string]interface{}) n := nraw.(map[string]interface{}) create, remove := diffTags(tagsFromMap(o), tagsFromMap(n)) // Set tags if len(remove) > 0 { err := resource.Retry(2*time.Minute, func() *resource.RetryError { log.Printf("[DEBUG] Removing tags: %#v from %s", remove, d.Id()) _, err := conn.DeleteTags(&ec2.DeleteTagsInput{ Resources: []*string{aws.String(d.Id())}, Tags: remove, }) if err != nil { ec2err, ok := err.(awserr.Error) if ok && strings.Contains(ec2err.Code(), ".NotFound") { return resource.RetryableError(err) // retry } return resource.NonRetryableError(err) } return nil }) if err != nil { return err } } if len(create) > 0 { err := resource.Retry(2*time.Minute, func() *resource.RetryError { log.Printf("[DEBUG] Creating tags: %s for %s", create, d.Id()) _, err := conn.CreateTags(&ec2.CreateTagsInput{ Resources: []*string{aws.String(d.Id())}, Tags: create, }) if err != nil { ec2err, ok := err.(awserr.Error) if ok && strings.Contains(ec2err.Code(), ".NotFound") { return resource.RetryableError(err) // retry } return resource.NonRetryableError(err) } return nil }) if err != nil { return err } } } return nil }
func CreateSnapshotTags(svc *ec2.EC2, resourceID, volumeName, volumeID string) error { var nKey, nVal string var tags []*ec2.Tag nKey = "Name" if volumeName == "" { nVal = fmt.Sprintf("%s: %s, %s", *tagPrefix, volumeID, time.Now().Format("2006-01-02")) } else { nVal = fmt.Sprintf("%s: %s, %s", *tagPrefix, volumeName, time.Now().Format("2006-01-02")) } tags = append(tags, &ec2.Tag{Key: &nKey, Value: &nVal}) if *purgeAfterDays > 0 { var paKey, paVal string var pKey, pVal string paKey = PurgeAfterKey paVal = time.Now().Add(time.Duration(*purgeAfterDays*24) * time.Hour).Format(PurgeAfterFormat) tags = append(tags, &ec2.Tag{Key: &paKey, Value: &paVal}) pKey = PurgeAllowKey pVal = "true" tags = append(tags, &ec2.Tag{Key: &pKey, Value: &pVal}) } cti := ec2.CreateTagsInput{Tags: tags} cti.Resources = append(cti.Resources, &resourceID) _, err := svc.CreateTags(&cti) if err != nil { return err } return nil }
func createInstance(svc *ec2.EC2, config *Config, ec2config EC2, userdata string, doneChan chan string) int { var min int64 var max int64 min = 1 max = 1 remainingSteps := 0 var subnet string if ec2config.HasExternalIP { subnet = config.PublicSubnetId } else { subnet = config.PrivateSubnetId } //fmt.Println("Public: ", config.PublicSubnetId) //fmt.Println("Private: ", config.PrivateSubnetId) //fmt.Println("Using: ", subnet) //if isEc2PartofLb(config, ec2config) { // subnet = config.PrivateSubnetId //} ec2config.SecurityGroupIds = getSecurityGroupIds(svc, config, ec2config.SecurityGroups) keyname := ec2config.KeyName if keyname == "" { keyname = config.KeyPair } params := &ec2.RunInstancesInput{ ImageId: &ec2config.AMI, InstanceType: &ec2config.InstanceType, MaxCount: &max, MinCount: &min, KeyName: &keyname, UserData: &userdata, SubnetId: &subnet, SecurityGroupIds: ec2config.SecurityGroupIds, } //fmt.Println("Create instance params:", params) rres, err := svc.RunInstances(params) if err != nil { fmt.Println("Failed to create instance", err) fmt.Println(rres) } else { fmt.Printf("Created instance %s: %s\n", ec2config.Name, *rres.Instances[0].InstanceId) ec2config.InstanceId = *rres.Instances[0].InstanceId //fmt.Println(rres) //fmt.Println("Sleeping for a sec to give AWS some time ...") time.Sleep(1 * time.Second) keyname := "Name" _, err := svc.CreateTags(&ec2.CreateTagsInput{ Resources: []*string{rres.Instances[0].InstanceId}, Tags: []*ec2.Tag{ &ec2.Tag{ Key: &keyname, Value: &ec2config.Name, }, }, }) //fmt.Println(tres) if err != nil { fmt.Println("Could not create tags for instance ", rres.Instances[0].InstanceId) fmt.Println(err) } //else { //fmt.Println("Created tag Name with value", ec2config.Name) //fmt.Println("isnat", ec2config.IsNat) if ec2config.IsNat { remainingSteps++ go func() { err = waitForNonPendingState(svc, rres.Instances[0].InstanceId) if err != nil { fmt.Println(err) doneChan <- "Gave up waiting on ec2 to leave pending state." return } bv := false abv := &ec2.AttributeBooleanValue{Value: &bv} miai := &ec2.ModifyInstanceAttributeInput{InstanceId: rres.Instances[0].InstanceId, SourceDestCheck: abv} _, err := svc.ModifyInstanceAttribute(miai) if err != nil { fmt.Println("Failed to change sourcedestcheck", err) } routeid, err := getPrivateRouteTable(svc, &config.PrivateSubnetId, config.VpcId) if err != nil { routeid, err = createPrivateRouteTable(svc, config) } else { _ = deleteDefaultRoute(svc, routeid) /*if err != nil { fmt.Println("Error deleting default route or default route existed", err) }*/ } defr := "0.0.0.0/0" cri := &ec2.CreateRouteInput{DestinationCidrBlock: &defr, InstanceId: rres.Instances[0].InstanceId, RouteTableId: routeid} _, err = svc.CreateRoute(cri) if err != nil { fmt.Println("Error adding new default route to NAT node", err) } doneChan <- fmt.Sprintf("Configured for NAT: %s", ec2config.Name) }() } //} //fmt.Println("hasexternalip ", ec2config.HasExternalIP) if ec2config.HasExternalIP { remainingSteps++ go func() { vpcs := "vpc" aao, err := svc.AllocateAddress(&ec2.AllocateAddressInput{Domain: &vpcs}) if err != nil { fmt.Println("Could not allocate addr:", err) } err = waitForNonPendingState(svc, rres.Instances[0].InstanceId) if err != nil { fmt.Println(err) } else { //aai,err := svc.AssociateAddress(&ec2.AssociateAddressInput{ PublicIp: aao.PublicIp, InstanceId: rres.Instances[0].InstanceId }) _, err := svc.AssociateAddress(&ec2.AssociateAddressInput{AllocationId: aao.AllocationId, InstanceId: rres.Instances[0].InstanceId}) if err != nil { fmt.Println("Could not assign addr:", err) } } //fmt.Println("External IP: ", *aao.PublicIp) doneChan <- fmt.Sprintf("External IP for %s assigned: %s", ec2config.Name, *aao.PublicIp) }() } } return remainingSteps }