// 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
}