func (_ *DHCPOptions) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *DHCPOptions) error {
if a == nil {
glog.V(2).Infof("Creating DHCPOptions with Name:%q", *e.Name)
request := &ec2.CreateDhcpOptionsInput{}
if e.DomainNameServers != nil {
o := &ec2.NewDhcpConfiguration{
Key: aws.String("domain-name-servers"),
Values: []*string{e.DomainNameServers},
}
request.DhcpConfigurations = append(request.DhcpConfigurations, o)
}
if e.DomainName != nil {
o := &ec2.NewDhcpConfiguration{
Key: aws.String("domain-name"),
Values: []*string{e.DomainName},
}
request.DhcpConfigurations = append(request.DhcpConfigurations, o)
}
response, err := t.Cloud.EC2.CreateDhcpOptions(request)
if err != nil {
return fmt.Errorf("error creating DHCPOptions: %v", err)
}
e.ID = response.DhcpOptions.DhcpOptionsId
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *VPC) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *VPC) error {
shared := fi.BoolValue(e.Shared)
if shared {
// Verify the VPC was found and matches our required settings
if a == nil {
return fmt.Errorf("VPC with id %q not found", fi.StringValue(e.ID))
}
if changes != nil && changes.EnableDNSSupport != nil {
return fmt.Errorf("VPC with id %q was set to be shared, but did not have EnableDNSSupport=true", fi.StringValue(e.ID))
}
if changes != nil && changes.EnableDNSHostnames != nil {
return fmt.Errorf("VPC with id %q was set to be shared, but did not have EnableDNSHostnames=true", fi.StringValue(e.ID))
}
return nil
}
if a == nil {
glog.V(2).Infof("Creating VPC with CIDR: %q", *e.CIDR)
request := &ec2.CreateVpcInput{
CidrBlock: e.CIDR,
}
response, err := t.Cloud.EC2.CreateVpc(request)
if err != nil {
return fmt.Errorf("error creating VPC: %v", err)
}
e.ID = response.Vpc.VpcId
}
if changes.EnableDNSSupport != nil {
request := &ec2.ModifyVpcAttributeInput{
VpcId: e.ID,
EnableDnsSupport: &ec2.AttributeBooleanValue{Value: changes.EnableDNSSupport},
}
_, err := t.Cloud.EC2.ModifyVpcAttribute(request)
if err != nil {
return fmt.Errorf("error modifying VPC attribute: %v", err)
}
}
if changes.EnableDNSHostnames != nil {
request := &ec2.ModifyVpcAttributeInput{
VpcId: e.ID,
EnableDnsHostnames: &ec2.AttributeBooleanValue{Value: changes.EnableDNSHostnames},
}
_, err := t.Cloud.EC2.ModifyVpcAttribute(request)
if err != nil {
return fmt.Errorf("error modifying VPC attribute: %v", err)
}
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *InstanceElasticIPAttachment) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *InstanceElasticIPAttachment) error {
if changes.Instance != nil {
err := t.WaitForInstanceRunning(*e.Instance.ID)
if err != nil {
return err
}
request := &ec2.AssociateAddressInput{}
request.InstanceId = e.Instance.ID
request.AllocationId = a.ElasticIP.ID
_, err = t.Cloud.EC2.AssociateAddress(request)
if err != nil {
return fmt.Errorf("error creating InstanceElasticIPAttachment: %v", err)
}
}
return nil // no tags
}
func (_ *SecurityGroup) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *SecurityGroup) error {
if a == nil {
glog.V(2).Infof("Creating SecurityGroup with Name:%q VPC:%q", *e.Name, *e.VPC.ID)
request := &ec2.CreateSecurityGroupInput{
VpcId: e.VPC.ID,
GroupName: e.Name,
Description: e.Description,
}
response, err := t.Cloud.EC2.CreateSecurityGroup(request)
if err != nil {
return fmt.Errorf("error creating SecurityGroup: %v", err)
}
e.ID = response.GroupId
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *Subnet) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *Subnet) error {
if a == nil {
glog.V(2).Infof("Creating Subnet with CIDR: %q", *e.CIDR)
request := &ec2.CreateSubnetInput{
CidrBlock: e.CIDR,
AvailabilityZone: e.AvailabilityZone,
VpcId: e.VPC.ID,
}
response, err := t.Cloud.EC2.CreateSubnet(request)
if err != nil {
return fmt.Errorf("error creating subnet: %v", err)
}
e.ID = response.Subnet.SubnetId
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *EBSVolume) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *EBSVolume) error {
if a == nil {
glog.V(2).Infof("Creating PersistentVolume with Name:%q", *e.Name)
request := &ec2.CreateVolumeInput{
Size: e.SizeGB,
AvailabilityZone: e.AvailabilityZone,
VolumeType: e.VolumeType,
}
response, err := t.Cloud.EC2.CreateVolume(request)
if err != nil {
return fmt.Errorf("error creating PersistentVolume: %v", err)
}
e.ID = response.VolumeId
}
return t.AddAWSTags(*e.ID, e.Tags)
}
func (_ *InstanceVolumeAttachment) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *InstanceVolumeAttachment) error {
if a == nil {
err := t.WaitForInstanceRunning(*e.Instance.ID)
if err != nil {
return err
}
request := &ec2.AttachVolumeInput{
InstanceId: e.Instance.ID,
VolumeId: e.Volume.ID,
Device: e.Device,
}
_, err = t.Cloud.EC2.AttachVolume(request)
if err != nil {
return fmt.Errorf("error creating InstanceVolumeAttachment: %v", err)
}
}
return nil // no tags
}
func (_ *InternetGateway) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *InternetGateway) error {
shared := fi.BoolValue(e.Shared)
if shared {
// Verify the InternetGateway was found and matches our required settings
if a == nil {
return fmt.Errorf("InternetGateway for shared VPC was not found")
}
return nil
}
if a == nil {
glog.V(2).Infof("Creating InternetGateway")
request := &ec2.CreateInternetGatewayInput{}
response, err := t.Cloud.EC2.CreateInternetGateway(request)
if err != nil {
return fmt.Errorf("error creating InternetGateway: %v", err)
}
e.ID = response.InternetGateway.InternetGatewayId
}
if a == nil || (changes != nil && changes.VPC != nil) {
glog.V(2).Infof("Creating InternetGatewayAttachment")
attachRequest := &ec2.AttachInternetGatewayInput{
VpcId: e.VPC.ID,
InternetGatewayId: e.ID,
}
_, err := t.Cloud.EC2.AttachInternetGateway(attachRequest)
if err != nil {
return fmt.Errorf("error attaching InternetGateway to VPC: %v", err)
}
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *ElasticIP) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *ElasticIP) error {
var publicIP *string
tagOnResourceID, err := e.findTagOnResourceID(t.Cloud)
if err != nil {
return err
}
if a == nil {
if tagOnResourceID == nil || e.TagUsingKey == nil {
return fmt.Errorf("cannot create ElasticIP without TagOnResource being set (would leak)")
}
glog.V(2).Infof("Creating ElasticIP for VPC")
request := &ec2.AllocateAddressInput{}
request.Domain = aws.String(ec2.DomainTypeVpc)
response, err := t.Cloud.EC2.AllocateAddress(request)
if err != nil {
return fmt.Errorf("error creating ElasticIP: %v", err)
}
e.ID = response.AllocationId
e.PublicIP = response.PublicIp
publicIP = response.PublicIp
} else {
publicIP = a.PublicIP
}
if publicIP != nil && e.TagUsingKey != nil && tagOnResourceID != nil {
tags := map[string]string{
*e.TagUsingKey: *publicIP,
}
err := t.AddAWSTags(*tagOnResourceID, tags)
if err != nil {
return fmt.Errorf("error adding tags to resource for ElasticIP: %v", err)
}
}
return nil
}
func (_ *RouteTable) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *RouteTable) error {
if a == nil {
vpcID := e.VPC.ID
if vpcID == nil {
return fi.RequiredField("VPC.ID")
}
glog.V(2).Infof("Creating RouteTable with VPC: %q", *vpcID)
request := &ec2.CreateRouteTableInput{
VpcId: vpcID,
}
response, err := t.Cloud.EC2.CreateRouteTable(request)
if err != nil {
return fmt.Errorf("error creating RouteTable: %v", err)
}
rt := response.RouteTable
e.ID = rt.RouteTableId
}
return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name))
}
func (_ *Instance) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *Instance) error {
if a == nil {
if e.ImageID == nil {
return fi.RequiredField("ImageID")
}
image, err := t.Cloud.ResolveImage(*e.ImageID)
if err != nil {
return err
}
glog.V(2).Infof("Creating Instance with Name:%q", *e.Name)
request := &ec2.RunInstancesInput{
ImageId: image.ImageId,
InstanceType: e.InstanceType,
MinCount: aws.Int64(1),
MaxCount: aws.Int64(1),
}
if e.SSHKey != nil {
request.KeyName = e.SSHKey.Name
}
securityGroupIDs := []*string{}
for _, sg := range e.SecurityGroups {
securityGroupIDs = append(securityGroupIDs, sg.ID)
}
request.NetworkInterfaces = []*ec2.InstanceNetworkInterfaceSpecification{
{
DeviceIndex: aws.Int64(0),
AssociatePublicIpAddress: e.AssociatePublicIP,
SubnetId: e.Subnet.ID,
PrivateIpAddress: e.PrivateIPAddress,
Groups: securityGroupIDs,
},
}
if e.BlockDeviceMappings != nil {
request.BlockDeviceMappings = []*ec2.BlockDeviceMapping{}
for deviceName, bdm := range e.BlockDeviceMappings {
request.BlockDeviceMappings = append(request.BlockDeviceMappings, bdm.ToEC2(deviceName))
}
}
if e.UserData != nil {
d, err := fi.ResourceAsBytes(e.UserData)
if err != nil {
return fmt.Errorf("error rendering Instance UserData: %v", err)
}
if len(d) > MaxUserDataSize {
// TODO: Re-enable gzip?
// But it exposes some bugs in the AWS console, so if we can avoid it, we should
//d, err = fi.GzipBytes(d)
//if err != nil {
// return fmt.Errorf("error while gzipping UserData: %v", err)
//}
return fmt.Errorf("Instance UserData was too large (%d bytes)", len(d))
}
request.UserData = aws.String(base64.StdEncoding.EncodeToString(d))
}
if e.IAMInstanceProfile != nil {
request.IamInstanceProfile = &ec2.IamInstanceProfileSpecification{
Name: e.IAMInstanceProfile.Name,
}
}
response, err := t.Cloud.EC2.RunInstances(request)
if err != nil {
return fmt.Errorf("error creating Instance: %v", err)
}
e.ID = response.Instances[0].InstanceId
}
return t.AddAWSTags(*e.ID, e.Tags)
}
func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalancer) error {
elbName := e.ID
if elbName == nil {
elbName = e.Name
}
if elbName == nil {
return fi.RequiredField("ID")
}
if a == nil {
request := &elb.CreateLoadBalancerInput{}
request.LoadBalancerName = elbName
for _, subnet := range e.Subnets {
request.Subnets = append(request.Subnets, subnet.ID)
}
for _, sg := range e.SecurityGroups {
request.SecurityGroups = append(request.SecurityGroups, sg.ID)
}
request.Listeners = []*elb.Listener{}
for loadBalancerPort, listener := range e.Listeners {
loadBalancerPortInt, err := strconv.ParseInt(loadBalancerPort, 10, 64)
if err != nil {
return fmt.Errorf("error parsing load balancer listener port: %q", loadBalancerPort)
}
awsListener := listener.mapToAWS(loadBalancerPortInt)
request.Listeners = append(request.Listeners, awsListener)
}
glog.V(2).Infof("Creating ELB with Name:%q", *e.ID)
response, err := t.Cloud.ELB.CreateLoadBalancer(request)
if err != nil {
return fmt.Errorf("error creating ELB: %v", err)
}
e.DNSName = response.DNSName
e.ID = elbName
lb, err := findELB(t.Cloud, *e.ID)
if err != nil {
return err
}
if lb == nil {
// TODO: Retry? Is this async
return fmt.Errorf("Unable to find newly created ELB")
}
e.HostedZoneId = lb.CanonicalHostedZoneNameID
} else {
if changes.Subnets != nil {
return fmt.Errorf("subnet changes on LoadBalancer not yet implemented")
}
if changes.Listeners != nil {
request := &elb.CreateLoadBalancerListenersInput{}
request.LoadBalancerName = elbName
for loadBalancerPort, listener := range changes.Listeners {
loadBalancerPortInt, err := strconv.ParseInt(loadBalancerPort, 10, 64)
if err != nil {
return fmt.Errorf("error parsing load balancer listener port: %q", loadBalancerPort)
}
awsListener := listener.mapToAWS(loadBalancerPortInt)
request.Listeners = append(request.Listeners, awsListener)
}
glog.V(2).Infof("Creating LoadBalancer listeners")
_, err := t.Cloud.ELB.CreateLoadBalancerListeners(request)
if err != nil {
return fmt.Errorf("error creating LoadBalancerListeners: %v", err)
}
}
}
return t.AddELBTags(*e.ID, t.Cloud.BuildTags(e.Name))
}