ec2

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 23, 2016 License: MIT Imports: 4 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var CustomerGateway = Resource{
	AwsType: "AWS::EC2::CustomerGateway",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"BgpAsn": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
		},

		"IpAddress": Schema{
			Type:     IPAddress,
			Required: constraints.Always,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"Type": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customer-gateway.html

View Source 
var DHCPOptions = Resource{
	AwsType: "AWS::EC2::DHCPOptions",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"DomainName": Schema{
			Type: ValueString,
		},

		"DomainNameServers": Schema{
			Type: Multiple(IPAddress),
			Required: constraints.All{
				constraints.PropertyNotExists("NetbiosNameServers"),
				constraints.PropertyNotExists("NtpServers"),
			},
		},

		"NetbiosNameServers": Schema{
			Type: Multiple(IPAddress),
			Required: constraints.All{
				constraints.PropertyNotExists("DomainNameServers"),
				constraints.PropertyNotExists("NtpServers"),
			},
		},

		"NetbiosNodeType": Schema{
			Type:     ValueNumber,
			Required: constraints.PropertyExists("NetBiosNameServers"),
		},

		"NtpServers": Schema{
			Type: Multiple(IPAddress),
			Required: constraints.All{
				constraints.PropertyNotExists("DomainNameServers"),
				constraints.PropertyNotExists("NetbiosNameServers"),
			},
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-dhcp-options.html

View Source 
var EIPAssociation = Resource{
	AwsType: "AWS::EC2::EIPAssociation",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"AllocationId": Schema{
			Type: AllocationID,
		},

		"EIP": Schema{
			Type: IPAddress,
		},

		"InstanceId": Schema{
			Type: InstanceID,
		},

		"NetworkInterfaceId": Schema{
			Type: NetworkInterfaceID,
		},

		"PrivateIpAddress": Schema{
			Type: IPAddress,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-eip-association.html

View Source 
var Eip = Resource{
	AwsType: "AWS::EC2::EIP",

	Attributes: map[string]Schema{
		"AllocationId": Schema{
			Type: AllocationID,
		},
	},

	ReturnValue: Schema{
		Type: IPAddress,
	},

	Properties: Properties{
		"InstanceId": Schema{
			Type: InstanceID,
		},

		"Domain": Schema{
			Type: EnumValue{
				Description: "EIP Domain",
				Options:     []string{"vpc"},
			},
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-eip.html

View Source 
var Instance = Resource{
	AwsType: "AWS::EC2::Instance",

	Attributes: map[string]Schema{
		"AvailabilityZone": Schema{
			Type: AvailabilityZone,
		},

		"PrivateDnsName": Schema{
			Type: ValueString,
		},

		"PublicDnsName": Schema{
			Type: ValueString,
		},

		"PrivateIp": Schema{
			Type: IPAddress,
		},

		"PublicIp": Schema{
			Type: IPAddress,
		},
	},

	ReturnValue: Schema{
		Type: InstanceID,
	},

	Properties: Properties{
		"AvailabilityZone": Schema{
			Type: AvailabilityZone,
		},

		"BlockDeviceMappings": Schema{
			Type: Multiple(ec2BlockDeviceMapping),
		},

		"DisableApiTermination": Schema{
			Type: ValueBool,
		},

		"EbsOptimized": Schema{
			Type:    ValueBool,
			Default: false,
		},

		"IamInstanceProfile": Schema{
			Type: ValueString,
		},

		"ImageId": Schema{
			Type:     ImageID,
			Required: constraints.Always,
		},

		"InstanceInitiatedShutdownBehavior": Schema{
			Type: EnumValue{
				Description: "Instance Shutdown Behaviour",
				Options:     []string{"stop", "terminate"},
			},
		},

		"InstanceType": Schema{
			Type: ec2InstanceType,
		},

		"KernelId": Schema{
			Type: ValueString,
		},

		"KeyName": Schema{
			Type: KeyName,
		},

		"Monitoring": Schema{
			Type: ValueBool,
		},

		"NetworkInterfaces": Schema{
			Type: Multiple(networkInterface),
			Conflicts: constraints.Any{
				constraints.PropertyExists("SecurityGroupIds"),
				constraints.PropertyExists("SubnetId"),
			},
		},

		"PlacementGroupName": Schema{
			Type: ValueString,
		},

		"PrivateIpAddress": Schema{
			Type: IPAddress,
		},

		"RamdiskId": Schema{
			Type: ValueString,
		},

		"SecurityGroupIds": Schema{
			Type:      Multiple(SecurityGroupID),
			Conflicts: constraints.PropertyExists("NetworkInterfaces"),
		},

		"SecurityGroups": Schema{
			Type: Multiple(SecurityGroupName),
		},

		"SourceDestCheck": Schema{
			Type: ValueBool,
		},

		"SsmAssociations": Schema{
			Type: Multiple(ssmAssociation),
		},

		"SubnetId": Schema{
			Type:      SubnetID,
			Conflicts: constraints.PropertyExists("NetworkInterfaces"),
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"Tenancy": Schema{
			Type: EnumValue{
				Description: "EC2 Instance Tenancy",
				Options:     []string{"default", "dedicated"},
			},
		},

		"UserData": Schema{
			Type: ValueString,
		},

		"Volumes": Schema{
			Type: Multiple(mountPoint),
		},

		"AdditionalInfo": Schema{
			Type: ValueString,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html

View Source 
var InternetGateway = Resource{
	AwsType: "AWS::EC2::InternetGateway",

	ReturnValue: Schema{
		Type: InternetGatewayID,
	},

	Properties: Properties{
		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-internet-gateway.html

View Source 
var NatGateway = Resource{
	AwsType: "AWS::EC2::NatGateway",

	ReturnValue: Schema{
		Type: NatGatewayID,
	},

	Properties: Properties{
		"AllocationId": Schema{
			Type:     AllocationID,
			Required: constraints.Always,
		},

		"SubnetId": Schema{
			Type:     SubnetID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-natgateway.html

View Source 
var NetworkACL = Resource{
	AwsType: "AWS::EC2::NetworkAcl",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-network-acl.html

View Source 
var NetworkACLEntry = Resource{
	AwsType: "AWS::EC2::NetworkAclEntry",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"CidrBlock": Schema{
			Type:     CIDR,
			Required: constraints.Always,
		},

		"Egress": Schema{
			Type:    ValueBool,
			Default: true,
		},

		"Icmp": Schema{
			Type:     icmp,
			Required: constraints.PropertyIs("Protocol", 1),
		},

		"NetworkAclId": Schema{
			Type:     NetworkAclID,
			Required: constraints.Always,
		},

		"PortRange": Schema{
			Type: portRange,
			Required: constraints.Any{
				constraints.PropertyIs("Protocol", 6),
				constraints.PropertyIs("Protocol", 17),
			},
		},

		"Protocol": Schema{
			Type:         ValueNumber,
			Required:     constraints.Always,
			ValidateFunc: IntegerRangeValidate(-1, 255),
		},

		"RuleAction": Schema{
			Type: EnumValue{
				Description: "RuleAction",
				Options:     []string{"allow", "deny"},
			},
			Required: constraints.Always,
		},

		"RuleNumber": Schema{
			Type:         ValueNumber,
			Required:     constraints.Always,
			ValidateFunc: IntegerRangeValidate(1, 32766),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-network-acl-entry.html

View Source 
var NetworkInterface = Resource{
	AwsType: "AWS::EC2::NetworkInterface",

	Attributes: map[string]Schema{
		"PrimaryPrivateIpAddress": Schema{
			Type: IPAddress,
		},

		"SecondaryPrivateIpAddresses": Schema{
			Type: Multiple(IPAddress),
		},
	},

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"Description": Schema{
			Type: ValueString,
		},

		"GroupSet": Schema{
			Type: Multiple(SecurityGroupID),
		},

		"PrivateIpAddress": Schema{
			Type: IPAddress,
		},

		"PrivateIpAddresses": Schema{
			Type: Multiple(privateIPAddressSpecification),
		},

		"SecondaryPrivateIpAddressCount": Schema{
			Type: ValueNumber,
		},

		"SourceDestCheck": Schema{
			Type: ValueBool,
		},

		"SubnetId": Schema{
			Type:     SubnetID,
			Required: constraints.Always,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-network-interface.html

View Source 
var NetworkInterfaceAttachment = Resource{
	AwsType: "AWS::EC2::NetworkInterfaceAttachment",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"DeleteOnTermination": Schema{
			Type:    ValueBool,
			Default: true,
		},

		"DeviceIndex": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"InstanceId": Schema{
			Type:     InstanceID,
			Required: constraints.Always,
		},

		"NetworkInterfaceId": Schema{
			Type:     NetworkInterfaceID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-network-interface-attachment.html

View Source 
var PlacementGroup = Resource{
	AwsType: "AWS::EC2::PlacementGroup",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"Strategy": Schema{
			Type:         ValueString,
			Default:      "cluster",
			ValidateFunc: SingleValueValidate("cluster"),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-placementgroup.html

View Source 
var Route = Resource{
	AwsType: "AWS::EC2::Route",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"DestinationCidrBlock": Schema{
			Type:     CIDR,
			Required: constraints.Always,
		},

		"GatewayId": Schema{
			Type: InternetGatewayID,
			Required: constraints.All{
				constraints.PropertyNotExists("InstanceId"),
				constraints.PropertyNotExists("NatGatewayId"),
				constraints.PropertyNotExists("NetworkInterfaceId"),
				constraints.PropertyNotExists("VpcPeeringConnectionId"),
			},
			Conflicts: constraints.Any{
				constraints.PropertyExists("InstanceId"),
				constraints.PropertyExists("NatGatewayId"),
				constraints.PropertyExists("NetworkInterfaceId"),
				constraints.PropertyExists("VpcPeeringConnectionId"),
			},
		},

		"InstanceId": Schema{
			Type: InstanceID,
			Required: constraints.All{
				constraints.PropertyNotExists("GatewayId"),
				constraints.PropertyNotExists("NatGatewayId"),
				constraints.PropertyNotExists("NetworkInterfaceId"),
				constraints.PropertyNotExists("VpcPeeringConnectionId"),
			},
			Conflicts: constraints.Any{
				constraints.PropertyExists("GatewayId"),
				constraints.PropertyExists("NatGatewayId"),
				constraints.PropertyExists("NetworkInterfaceId"),
				constraints.PropertyExists("VpcPeeringConnectionId"),
			},
		},

		"NatGatewayId": Schema{
			Type: NatGatewayID,
			Required: constraints.All{
				constraints.PropertyNotExists("GatewayId"),
				constraints.PropertyNotExists("InstanceId"),
				constraints.PropertyNotExists("NetworkInterfaceId"),
				constraints.PropertyNotExists("VpcPeeringConnectionId"),
			},
			Conflicts: constraints.Any{
				constraints.PropertyExists("GatewayId"),
				constraints.PropertyExists("InstanceId"),
				constraints.PropertyExists("NetworkInterfaceId"),
				constraints.PropertyExists("VpcPeeringConnectionId"),
			},
		},

		"NetworkInterfaceId": Schema{
			Type: NetworkInterfaceID,
			Required: constraints.All{
				constraints.PropertyNotExists("GatewayId"),
				constraints.PropertyNotExists("InstanceId"),
				constraints.PropertyNotExists("NatGatewayId"),
				constraints.PropertyNotExists("VpcPeeringConnectionId"),
			},
			Conflicts: constraints.Any{
				constraints.PropertyExists("GatewayId"),
				constraints.PropertyExists("InstanceId"),
				constraints.PropertyExists("NatGatewayId"),
				constraints.PropertyExists("VpcPeeringConnectionId"),
			},
		},

		"RouteTableId": Schema{
			Type:     RouteTableID,
			Required: constraints.Always,
		},

		"VpcPeeringConnectionId": Schema{
			Type: VpcPeeringConnectionID,
			Required: constraints.All{
				constraints.PropertyNotExists("GatewayId"),
				constraints.PropertyNotExists("InstanceId"),
				constraints.PropertyNotExists("NatGatewayId"),
				constraints.PropertyNotExists("NetworkInterfaceId"),
			},
			Conflicts: constraints.Any{
				constraints.PropertyExists("GatewayId"),
				constraints.PropertyExists("InstanceId"),
				constraints.PropertyExists("NatGatewayId"),
				constraints.PropertyExists("NetworkInterfaceId"),
			},
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html

View Source 
var RouteTable = Resource{
	AwsType: "AWS::EC2::RouteTable",

	ReturnValue: Schema{
		Type: RouteTableID,
	},

	Properties: Properties{
		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route-table.html

View Source 
var SecurityGroup = Resource{
	AwsType: "AWS::EC2::SecurityGroup",

	Attributes: map[string]Schema{
		"GroupId": Schema{
			Type: SecurityGroupID,
		},
	},

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"GroupDescription": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"SecurityGroupEgress": Schema{
			Type: Multiple(NestedResource{
				Description: "EC2 Security Group Rule Egress",
				Properties: Properties{
					"CidrIp": Schema{
						Type:      CIDR,
						Conflicts: constraints.PropertyExists("DestinationSecurityGroupId"),
					},

					"FromPort": Schema{
						Type:     ValueNumber,
						Required: constraints.Always,
					},

					"IpProtocol": Schema{
						Type:     ipProtocol,
						Required: constraints.Always,
					},

					"DestinationSecurityGroupId": Schema{
						Type:      SecurityGroupID,
						Conflicts: constraints.PropertyExists("CidrIp"),
					},

					"ToPort": Schema{
						Type:     ValueNumber,
						Required: constraints.Always,
					},
				},
			}),
		},

		"SecurityGroupIngress": Schema{
			Type: Multiple(NestedResource{
				Description: "EC2 Security Group Rule Ingress",
				Properties: Properties{
					"CidrIp": Schema{
						Type: CIDR,
						Conflicts: constraints.Any{
							constraints.PropertyExists("SourceSecurityGroupName"),
							constraints.PropertyExists("SourceSecurityGroupId"),
						},
					},

					"FromPort": Schema{
						Type:     ValueNumber,
						Required: constraints.Always,
					},

					"IpProtocol": Schema{
						Type:     ipProtocol,
						Required: constraints.Always,
					},

					"SourceSecurityGroupId": Schema{
						Type:      SecurityGroupID,
						Conflicts: constraints.PropertyExists("CidrIp"),
					},

					"SourceSecurityGroupName": Schema{
						Type:      SecurityGroupName,
						Conflicts: constraints.PropertyExists("CidrIp"),
					},

					"SourceSecurityGroupOwnerId": Schema{
						Type: ValueString,
					},

					"ToPort": Schema{
						Type:     ValueNumber,
						Required: constraints.Always,
					},
				},
			}),
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpcId": Schema{
			Type: VpcID,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html

View Source 
var SecurityGroupEgress = Resource{
	AwsType: "AWS::EC2::SecurityGroupEgress",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"CidrIp": Schema{
			Type:      CIDR,
			Required:  constraints.PropertyNotExists("DestinationSecurityGroupId"),
			Conflicts: constraints.PropertyExists("DestinationSecurityGroupId"),
		},

		"DestinationSecurityGroupId": Schema{
			Type:      SecurityGroupID,
			Required:  constraints.PropertyNotExists("CidrIp"),
			Conflicts: constraints.PropertyExists("CidrIp"),
		},

		"FromPort": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
		},

		"GroupId": Schema{
			Type:     SecurityGroupID,
			Required: constraints.Always,
		},

		"IpProtocol": Schema{
			Type:     ipProtocol,
			Required: constraints.Always,
		},

		"ToPort": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-security-group-egress.html

View Source 
var SecurityGroupIngress = Resource{
	AwsType: "AWS::EC2::SecurityGroupIngress",

	Properties: Properties{
		"CidrIp": Schema{
			Type: CIDR,
			Conflicts: constraints.Any{
				constraints.PropertyExists("SourceSecurityGroupName"),
				constraints.PropertyExists("SourceSecurityGroupId"),
			},
		},

		"FromPort": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
		},

		"GroupId": Schema{
			Type:     SecurityGroupID,
			Required: constraints.PropertyNotExists("GroupName"),
		},

		"GroupName": Schema{
			Type:     SecurityGroupName,
			Required: constraints.PropertyNotExists("GroupId"),
		},

		"IpProtocol": Schema{
			Required: constraints.Always,
			Type:     ipProtocol,
		},

		"SourceSecurityGroupId": Schema{
			Type:      SecurityGroupID,
			Conflicts: constraints.PropertyExists("CidrIp"),
		},

		"SourceSecurityGroupName": Schema{
			Type:      SecurityGroupName,
			Conflicts: constraints.PropertyExists("CidrIp"),
		},

		"SourceSecurityGroupOwnerId": Schema{
			Type: ValueString,
		},

		"ToPort": Schema{
			Type:     ValueNumber,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group-ingress.html

View Source 
var SpotFleet = Resource{
	AwsType: "AWS::EC2::SpotFleet",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"SpotFleetRequestConfigData": Schema{
			Type:     spotFleetRequestConfigData,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-spotfleet.html

View Source 
var Subnet = Resource{
	AwsType: "AWS::EC2::Subnet",

	Attributes: map[string]Schema{
		"AvailabilityZone": Schema{
			Type: AvailabilityZone,
		},
	},

	ReturnValue: Schema{
		Type: SubnetID,
	},

	Properties: Properties{
		"AvailabilityZone": Schema{
			Type: AvailabilityZone,
		},

		"CidrBlock": Schema{
			Type:     CIDR,
			Required: constraints.Always,
		},

		"MapPublicIpOnLaunch": Schema{
			Type:    ValueBool,
			Default: false,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html

View Source 
var SubnetNetworkACLAssociation = Resource{
	AwsType: "AWS::EC2::SubnetNetworkAclAssociation",

	Attributes: map[string]Schema{
		"AssociationId": Schema{
			Type: SubnetID,
		},
	},

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"SubnetId": Schema{
			Type:     SubnetID,
			Required: constraints.Always,
		},

		"NetworkAclId": Schema{
			Type:     NetworkAclID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet-network-acl-assoc.html

View Source 
var SubnetRouteTableAssociation = Resource{
	AwsType: "AWS::EC2::SubnetRouteTableAssociation",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"RouteTableId": Schema{
			Type:     RouteTableID,
			Required: constraints.Always,
		},

		"SubnetId": Schema{
			Type:     SubnetID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet-route-table-assoc.html

View Source 
var VPC = Resource{
	AwsType: "AWS::EC2::VPC",

	Attributes: map[string]Schema{
		"CidrBlock": Schema{
			Type: CIDR,
		},

		"DefaultNetworkAcl": Schema{
			Type: ValueString,
		},

		"DefaultSecurityGroup": Schema{
			Type: SecurityGroupID,
		},
	},

	ReturnValue: Schema{
		Type: VpcID,
	},

	Properties: Properties{
		"CidrBlock": Schema{
			Type:     CIDR,
			Required: constraints.Always,
		},

		"EnableDnsSupport": Schema{
			Type:    ValueBool,
			Default: true,
		},

		"EnableDnsHostnames": Schema{
			Type:    ValueBool,
			Default: false,
			ValidateFunc: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
				if enableDnsSupport, _ := ctx.CurrentResource().PropertyValueOrDefault("EnableDnsSupport"); value == true && enableDnsSupport == false {
					return reporting.ValidateOK, reporting.Reports{reporting.NewFailure(ctx, "You can only set EnableDnsHostnames to true if you also set the EnableDnsSupport attribute to true.")}
				}

				return reporting.ValidateOK, nil
			},
		},

		"InstanceTenancy": Schema{
			Type: EnumValue{
				Description: "InstanceTenancy",
				Options:     []string{"default", "dedicated"},
			},
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html

View Source 
var VPCDHCPOptionsAssociation = Resource{
	AwsType: "AWS::EC2::VPCDHCPOptionsAssociation",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"DhcpOptionsId": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc-dhcp-options-assoc.html

View Source 
var VPCEndpoint = Resource{
	AwsType: "AWS::EC2::VPCEndpoint",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"PolicyDocument": Schema{
			Type: JSON,
		},

		"RouteTableIds": Schema{
			Type: Multiple(RouteTableID),
		},

		"ServiceName": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html

View Source 
var VPCGatewayAttachment = Resource{
	AwsType: "AWS::EC2::VPCGatewayAttachment",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"InternetGatewayId": Schema{
			Type:      InternetGatewayID,
			Required:  constraints.PropertyNotExists("VpnGatewayId"),
			Conflicts: constraints.PropertyExists("VpnGatewayId"),
		},

		"VpcId": Schema{
			Required: constraints.Always,
			Type:     VpcID,
		},

		"VpnGatewayId": Schema{
			Type:      VpnGatewayID,
			Required:  constraints.PropertyNotExists("InternetGatewayId"),
			Conflicts: constraints.PropertyExists("InternetGatewayId"),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc-gateway-attachment.html

View Source 
var VPCPeeringConnection = Resource{
	AwsType: "AWS::EC2::VPCPeeringConnection",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"PeerVpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpcId": Schema{
			Type:     VpcID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html

View Source 
var VPNConnection = Resource{
	AwsType: "AWS::EC2::VPNConnection",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"Type": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"CustomerGatewayId": Schema{
			Type:     JSON,
			Required: constraints.Always,
		},

		"StaticRoutesOnly": Schema{
			Type: ValueBool,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VpnGatewayId": Schema{
			Type: VpnGatewayID,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-connection.html

View Source 
var VPNConnectionRoute = Resource{
	AwsType: "AWS::EC2::VPNConnectionRoute",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"DestinationCidrBlock": Schema{
			Type:     CIDR,
			Required: constraints.Always,
		},

		"VpnConnectionId": Schema{
			Type:     VpnConnectionID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-connection-route.html

View Source 
var VPNGateway = Resource{
	AwsType: "AWS::EC2::VPNGateway",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"Type": Schema{
			Type:         ValueString,
			Required:     constraints.Always,
			ValidateFunc: SingleValueValidate("ipsec.1"),
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gateway.html

View Source 
var VPNGatewayRoutePropagation = Resource{
	AwsType: "AWS::EC2::VPNGatewayRoutePropagation",

	ReturnValue: Schema{
		Type: ValueString,
	},

	Properties: Properties{
		"RouteTableIds": Schema{
			Type:     Multiple(RouteTableID),
			Required: constraints.Always,
		},

		"VpnGatewayId": Schema{
			Type:     VpnGatewayID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html

View Source 
var Volume = Resource{
	AwsType: "AWS::EC2::Volume",

	ReturnValue: Schema{
		Type: VolumeID,
	},

	Properties: Properties{
		"AutoEnableIO": Schema{
			Type: ValueBool,
		},

		"AvailabilityZone": Schema{
			Type:     AvailabilityZone,
			Required: constraints.Always,
		},

		"Encrypted": Schema{
			Type:     ValueBool,
			Required: constraints.PropertyExists("KmsKeyId"),
		},

		"Iops": Schema{
			Type:         ValueNumber,
			Required:     constraints.PropertyIs("VolumeType", "io1"),
			ValidateFunc: IntegerRangeValidate(1, 4000),
		},

		"KmsKeyId": Schema{
			Type: ARN,
		},

		"Size": Schema{
			Type:     ValueString,
			Required: constraints.PropertyNotExists("SnapshotId"),
		},

		"SnapshotId": Schema{
			Type: ValueString,
		},

		"Tags": Schema{
			Type: Multiple(common.ResourceTag),
		},

		"VolumeType": Schema{
			Type: common.EbsVolumeType,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ebs-volume.html

View Source 
var VolumeAttachment = Resource{
	AwsType: "AWS::EC2::VolumeAttachment",

	Properties: Properties{
		"Device": Schema{
			Type:     ValueString,
			Required: constraints.Always,
		},

		"InstanceId": Schema{
			Type:     InstanceID,
			Required: constraints.Always,
		},

		"VolumeId": Schema{
			Type:     VolumeID,
			Required: constraints.Always,
		},
	},
}

see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ebs-volumeattachment.html

Functions

This section is empty.

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.