# Copyright 2014 # The Cloudscaling Group, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Cloud Controller: Implementation of EC2 REST API calls, which are dispatched to other nodes via AMQP RPC. State is via distributed datastore. """ import collections from oslo_config import cfg from oslo_log import log as logging import six import six.moves from ec2api.api import address from ec2api.api import availability_zone from ec2api.api import customer_gateway from ec2api.api import dhcp_options from ec2api.api import image from ec2api.api import instance from ec2api.api import internet_gateway from ec2api.api import key_pair from ec2api.api import network_interface from ec2api.api import route_table from ec2api.api import security_group from ec2api.api import snapshot from ec2api.api import subnet from ec2api.api import tag from ec2api.api import volume from ec2api.api import vpc from ec2api.api import vpn_connection from ec2api.api import vpn_gateway from ec2api import exception CONF = cfg.CONF LOG = logging.getLogger(__name__) def module_and_param_types(module, *args, **kwargs): """Decorator to check types and call function.""" param_types = args def wrapped(func): def func_wrapped(*args, **kwargs): impl_func = getattr(module, func.__name__) context = args[1] params = collections.OrderedDict(six.moves.zip( func.__code__.co_varnames[2:], param_types)) param_num = 0 mandatory_params_num = (func.__code__.co_argcount - 2 - len(func.__defaults__ or [])) for param_name, param_type in params.items(): param_value = kwargs.get(param_name) if param_value is not None: validator = module.Validator(param_name, func.__name__, params) validation_func = getattr(validator, param_type) validation_func(param_value) param_num += 1 elif param_num < mandatory_params_num: raise exception.MissingParameter(param=param_name) return impl_func(context, **kwargs) return func_wrapped return wrapped class CloudController(object): """Cloud Controller Provides the critical dispatch between inbound API calls through the endpoint and messages sent to the other nodes. """ def __init__(self): pass def __str__(self): return 'CloudController' @module_and_param_types(address, 'str255') def allocate_address(self, context, domain=None): """Acquires an Elastic IP address. Args: context (RequestContext): The request context. domain (str): Set to vpc to allocate the address for use with instances in a VPC. Default: The address is for use in EC2-Classic. Valid values: vpc Returns: The Elastic IP address information. An Elastic IP address is for use either in the EC2-Classic platform or in a VPC. """ @module_and_param_types(address, 'ip', 'i_id', 'eipalloc_id', 'eni_id', 'ip', 'bool') def associate_address(self, context, public_ip=None, instance_id=None, allocation_id=None, network_interface_id=None, private_ip_address=None, allow_reassociation=False): """Associates an Elastic IP with an instance or a network interface. Args: context (RequestContext): The request context. public_ip (str): The Elastic IP address. Required for Elastic IP addresses for use with instances in EC2-Classic. instance_id (str): The ID of the instance. The operation fails if you specify an instance ID unless exactly one network interface is attached. Required for EC2-Classic. allocation_id (str): The allocation ID. Required for EC2-VPC. network_interface_id (str): The ID of the network interface. private_ip_address (str): The primary or secondary private IP. allow_reassociation (boolean): Allows an Elastic IP address that is already associated to be re-associated. Otherwise, the operation fails. Returns: true if the request succeeds. [EC2-VPC] The ID that represents the association of the Elastic IP. For a VPC, you can specify either instance_id or network_interface_id, but not both. If the instance has more than one network interface, you must specify a network interface ID. If no private IP address is specified, the Elastic IP address is associated with the primary private IP address. [EC2-Classic, default VPC] If the Elastic IP address is already associated with a different instance, it is disassociated from that instance and associated with the specified instance. This is an idempotent operation. """ @module_and_param_types(address, 'ip', 'eipassoc_id') def disassociate_address(self, context, public_ip=None, association_id=None): """Disassociates an Elastic IP address. Args: context (RequestContext): The request context. public_ip (str): The Elastic IP address. Required for EC2-Classic. assossiation_id (str): The association ID. Required for EC2-VPC Returns: true if the request succeeds. Disassociates an Elastic IP address from the instance or network interface it's associated with. This is an idempotent action. """ @module_and_param_types(address, 'ip', 'eipalloc_id') def release_address(self, context, public_ip=None, allocation_id=None): """Releases the specified Elastic IP address. Args: context (RequestContext): The request context. public_ip (str): The Elastic IP address. allocation_id (str): The allocation ID. Returns: true if the requests succeeds. If you attempt to release an Elastic IP address that you already released, you'll get an AuthFailure error if the address is already allocated to another AWS account. [EC2-Classic, default VPC] Releasing an Elastic IP address automatically disassociates it from any instance that it's associated with. [Nondefault VPC] You must use DisassociateAddress to disassociate the Elastic IP address before you try to release it. """ @module_and_param_types(address, 'ips', 'eipalloc_ids', 'filter') def describe_addresses(self, context, public_ip=None, allocation_id=None, filter=None): """Describes one or more of your Elastic IP addresses. Args: context (RequestContext): The request context. public_ip (list of str): One or more Elastic IP addresses. allocation_id (list of str): One or more allocation IDs. filter (list of filter dict): You can specify filters so that the response includes information for only certain Elastic IP addresses. Returns: A list of Elastic IP addresses. """ @module_and_param_types(security_group, 'security_group_strs', 'sg_ids', 'filter') def describe_security_groups(self, context, group_name=None, group_id=None, filter=None): """Describes one or more of your security groups. Args: context (RequestContext): The request context. group_name (list of str): One or more security group names. group_id (list of str): One or more security group IDs. filter (list of filter dict): You can specify filters so that the response includes information for only certain security groups. Returns: A list of security groups. """ @module_and_param_types(security_group, 'security_group_str', 'security_group_str', 'vpc_id') def create_security_group(self, context, group_name, group_description, vpc_id=None): """Creates a security group. Args: context (RequestContext): The request context. group_name (str): The name of the security group. group_description (str): A description for the security group. vpc_id (str): [EC2-VPC] The ID of the VPC. Returns: true if the requests succeeds. The ID of the security group. You can have a security group for use in EC2-Classic with the same name as a security group for use in a VPC. However, you can't have two security groups for use in EC2-Classic with the same name or two security groups for use in a VPC with the same name. You have a default security group for use in EC2-Classic and a default security group for use in your VPC. If you don't specify a security group when you launch an instance, the instance is launched into the appropriate default security group. A default security group includes a default rule that grants instances unrestricted network access to each other. group_name and group_description restrictions: up to 255 characters in length, EC2-Classic: ASCII characters, EC2-VPC: a-z, A-Z, 0-9, spaces, and ._-:/()#,@[]+=&;{}!$* """ @module_and_param_types(security_group, 'security_group_str', 'sg_id') def delete_security_group(self, context, group_name=None, group_id=None): """Deletes a security group. Args: context (RequestContext): The request context. group_name (str): The name of the security group. group_id (str): The ID of the security group. Returns: true if the requests succeeds. [EC2-Classic, default VPC] You can specify either GroupName or GroupId If you attempt to delete a security group that is associated with an instance, or is referenced by another security group, the operation fails. """ @module_and_param_types(security_group, 'sg_id', 'security_group_str', 'dummy') def authorize_security_group_ingress(self, context, group_id=None, group_name=None, ip_permissions=None): """Adds one or more ingress rules to a security group. Args: context (RequestContext): The request context. group_id (str): The ID of the security group. group_name (str): [EC2-Classic, default VPC] The name of the security group. ip_permissions (list of dicts): Dict can contain: ip_protocol (str): The IP protocol name or number. Use -1 to specify all. For EC2-Classic, security groups can have rules only for TCP, UDP, and ICMP. from_port (str): The start of port range for the TCP and UDP protocols, or an ICMP type number. For the ICMP type number, you can use -1 to specify all ICMP types. to_port (str): The end of port range for the TCP and UDP protocols, or an ICMP code number. For the ICMP code number, you can use -1 to specify all ICMP codes for the ICMP type. groups (list of dicts): Dict can contain: group_id (str): The ID of the source security group. You can't specify a source security group and a CIDR IP address range. user_id (str): [EC2-Classic] The ID of the AWS account that owns the source security group, if it's not the current AWS account. cidr_ip (str): The CIDR IP address range. You can't specify this parameter when specifying a source security group. Returns: true if the requests succeeds. """ @module_and_param_types(security_group, 'sg_id', 'security_group_str', 'dummy') def revoke_security_group_ingress(self, context, group_id=None, group_name=None, ip_permissions=None): """Removes one or more ingress rules from a security group. Args: context (RequestContext): The request context. group_id (str): The ID of the security group. group_name (str): [EC2-Classic, default VPC] The name of the security group. ip_permissions (list of dicts): See authorize_security_group_ingress Returns: true if the requests succeeds. The values that you specify in the revoke request (for example, ports) must match the existing rule's values for the rule to be removed. """ @module_and_param_types(security_group, 'sg_id', 'dummy') def authorize_security_group_egress(self, context, group_id, ip_permissions=None): """Adds one or more egress rules to a security group for use with a VPC. Args: context (RequestContext): The request context. group_id (str): The ID of the security group. ip_permissions (list of dicts): See authorize_security_group_ingress Returns: true if the requests succeeds. This action doesn't apply to security groups for use in EC2-Classic. """ @module_and_param_types(security_group, 'sg_id', 'dummy') def revoke_security_group_egress(self, context, group_id, ip_permissions=None): """Removes one or more egress rules from a security group for EC2-VPC. Args: context (RequestContext): The request context. group_id (str): The ID of the security group. ip_permissions (list of dicts): See authorize_security_group_ingress Returns: true if the requests succeeds. The values that you specify in the revoke request (for example, ports) must match the existing rule's values for the rule to be revoked. This action doesn't apply to security groups for use in EC2-Classic. """ @module_and_param_types(instance, 'ami_id', 'int', 'int', 'str255', 'sg_ids', 'security_group_strs', 'str', 'str', 'dummy', 'aki_id', 'ari_id', 'dummy', 'dummy', 'subnet_id', 'bool', 'str', 'ip', 'str64', 'dummy', 'dummy', 'bool') def run_instances(self, context, image_id, min_count, max_count, key_name=None, security_group_id=None, security_group=None, user_data=None, instance_type=None, placement=None, kernel_id=None, ramdisk_id=None, block_device_mapping=None, monitoring=None, subnet_id=None, disable_api_termination=None, instance_initiated_shutdown_behavior=None, private_ip_address=None, client_token=None, network_interface=None, iam_instance_profile=None, ebs_optimized=None): """Launches the specified number of instances using an AMI. Args: context (RequestContext): The request context. image_id (str): The ID of the AMI. min_count (int): The minimum number of instances to launch. If you specify a minimum that is more instances than EC2 can launch in the target Availability Zone, EC2 launches no instances. max_count (int): The maximum number of instances to launch. If you specify more instances than EC2 can launch in the target Availability Zone, EC2 launches the largest possible number of instances above max_count. key_name (str): The name of the key pair. security_group_id (list of str): One or more security group IDs. security_group (list of str): One or more security group names. For VPC mode, you must use security_group_id. user_data (str): Base64-encoded MIME user data for the instances. instance_type (str): The instance type. placement (dict): Dict can contain: availability_zone (str): Availability Zone for the instance. group_name (str): The name of an existing placement group. Not used now. tenancy (str): The tenancy of the instance. Not used now. kernel_id (str): The ID of the kernel. ramdisk_id (str): The ID of the RAM disk. block_device_mapping (list of dict): Dict can contain: device_name (str): The device name exposed to the instance (for example, /dev/sdh or xvdh). virtual_name (str): The virtual device name (ephemeral[0..3]). ebs (dict): Dict can contain: volume_id (str): The ID of the volume (Nova extension). snapshot_id (str): The ID of the snapshot. volume_size (str): The size of the volume, in GiBs. volume_type (str): The volume type. Not used now. delete_on_termination (bool): Indicates whether to delete the volume on instance termination. iops (int): he number of IOPS to provision for the volume. Not used now. encrypted (boolean): Whether the volume is encrypted. Not used now. no_device (str): Suppresses the device mapping. monitoring (dict): Dict can contains: enabled (boolean): Enables monitoring for the instance. Not used now. subnet_id (str): The ID of the subnet to launch the instance into. disable_api_termination (boolean): If you set this parameter to true, you can't terminate the instance using the GUI console, CLI, or API. Not used now. instance_initiated_shutdown_behavior (str): Indicates whether an instance stops or terminates when you initiate shutdown from the instance. Not used now. private_ip_address (str): The primary IP address. You must specify a value from the IP address range of the subnet. client_token (str): Unique, case-sensitive identifier you provide to ensure idempotency of the request. network_interface (list of dicts): Dict can contain: network_interface_id (str): An existing interface to attach to a single instance. Requires n=1 instances. device_index (int): The device index. If you are specifying a network interface in the request, you must provide the device index. subnet_id (str): The subnet ID. Applies only when creating a network interface. description (str): A description. Applies only when creating a network interface. private_ip_address (str): The primary private IP address. Applies only when creating a network interface. Requires n=1 network interfaces in launch. security_group_id (str): The ID of the security group. Applies only when creating a network interface. delete_on_termination (str): Indicates whether to delete the network interface on instance termination. private_ip_addresses (list of dicts): Dict can contain: private_ip_address (str): The private IP address. primary (boolean): Indicates whether the private IP address is the primary private IP address. secondary_private_ip_address_count (int): The number of private IP addresses to assign to the network interface. For a single network interface, you can't specify this option and specify more than one private IP address using private_ip_address. associate_public_ip_address (boolean): Indicates whether to assign a public IP address to an instance in a VPC. iam_instance_profile (dict): Dict can contains: arn (str): ARN to associate with the instances. Not used now. name (str): Name of the IIP to associate with the instances. Not used now. ebs_optimized (boolean): Whether the instance is optimized for EBS. Not used now. Returns: The instance reservation that was created. If you don't specify a security group when launching an instance, EC2 uses the default security group. """ @module_and_param_types(instance, 'i_ids') def terminate_instances(self, context, instance_id): """Shuts down one or more instances. Args: context (RequestContext): The request context. instance_id (list of str): One or more instance IDs. Returns: A list of instance state changes. This operation is idempotent; if you terminate an instance more than once, each call succeeds. """ @module_and_param_types(instance, 'i_ids', 'filter', 'int', 'str') def describe_instances(self, context, instance_id=None, filter=None, max_results=None, next_token=None): """Describes one or more of your instances. Args: context (RequestContext): The request context. instance_id (list of str): One or more instance IDs. filter (list of filter dict): You can specify filters so that the response includes information for only certain instances. max_results (int): The maximum number of items to return. next_token (str): The token for the next set of items to return. Returns: A list of reservations. If you specify one or more instance IDs, Amazon EC2 returns information for those instances. If you do not specify instance IDs, you receive information for all relevant instances. If you specify an invalid instance ID, you receive an error. If you specify an instance that you don't own, we don't include it in the results. """ @module_and_param_types(instance, 'i_ids') def reboot_instances(self, context, instance_id): """Requests a reboot of one or more instances. Args: context (RequestContext): The request context. instance_id (list of str): One or more instance IDs. Returns: true if the request succeeds. """ @module_and_param_types(instance, 'i_ids', 'bool') def stop_instances(self, context, instance_id, force=False): """Stops one or more instances. Args: context (RequestContext): The request context. instance_id (list of str): One or more instance IDs. force (boolean): Forces the instances to stop. The instances do not have an opportunity to flush file system caches or file system metadata. Not used now. Equivalent value is True. Returns: true if the request succeeds. """ @module_and_param_types(instance, 'i_ids') def start_instances(self, context, instance_id): """Starts one or more instances. Args: context (RequestContext): The request context. instance_id (list of str): One or more instance IDs. Returns: true if the request succeeds. """ @module_and_param_types(instance, 'i_id', 'str255') def describe_instance_attribute(self, context, instance_id, attribute): """Describes the specified attribute of the specified instance. Args: context (RequestContext): The request context. instance_id (str): The ID of the instance. attribute (str): The instance attribute. Valid values: blockDeviceMapping | disableApiTermination | ebsOptimized (unsupported now) | groupSet | instanceInitiatedShutdownBehavior | instanceType | kernel | productCodes (unsupported now) | ramdisk | rootDeviceName | sourceDestCheck (unsupported now) | sriovNetSupport (unsupported now) | userData Returns: Specified attribute. """ @module_and_param_types(instance, 'i_id', 'str', 'dummy', 'bool', 'dummy', 'bool', 'bool', 'sg_ids', 'str', 'str', 'str', 'str', 'str', 'str') def modify_instance_attribute(self, context, instance_id, attribute=None, value=None, source_dest_check=None, block_device_mapping=None, disable_api_termination=None, ebs_optimized=None, group_id=None, instance_initiated_shutdown_behavior=None, instance_type=None, kernel=None, ramdisk=None, sriov_net_support=None, user_data=None): """Modifies the specified attribute of the specified instance. Args: context (RequestContext): The request context. instance_id (str): The ID of the instance. attribute (str): The name of the attribute. value: The value of the attribute being modified. source_dest_check: Indicates whether source/destination checking is enabled. A value of true means checking is enabled, and false means checking is disabled. This value must be false for a NAT instance to perform NAT. Unsupported now. block_device_mapping (list of dict): Modifies the DeleteOnTermination attribute for volumes that are currently attached. The volume must be owned by the caller. If no value is specified for DeleteOnTermination, the default is true and the volume is deleted when the instance is terminated. Dict can contain: device_name (str): The device name exposed to the instance (for example, /dev/sdh or xvdh). virtual_name (str): The virtual device name (ephemeral[0..3]). ebs (dict): Dict can contain: volume_id (str): The ID of the volume (Nova extension). delete_on_termination (bool): Indicates whether to delete the volume on instance termination. no_device (str): Suppresses the device mapping. Unsupported now. disable_api_termination (boolean): If the value is true, you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can. ebs_optimized (boolean): Whether the instance is optimized for EBS. Unsupported now. group_id (list of str): [EC2-VPC] Changes the security groups of the instance. You must specify at least one security group, even if it's just the default security group for the VPC. You must specify the security group ID, not the security group name. Unsupported now. instance_initiated_shutdown_behavior (str): Indicates whether an instance stops or terminates when you initiate shutdown from the instance. Unsupported now. instance_type (str): Changes the instance type to the specified value. For more information, see Instance Types. If the instance type is not valid, the error returned is InvalidInstanceAttributeValue. Unsupported now. kernel (str): Changes the instance's kernel to the specified value. Unsupported now. ramdisk (str): Changes the instance's RAM disk. Unsupported now. sriov_net_support (str): SR-IOV mode for networking. Unsupported now. user_data (str): Changes the instance's user data. Unsupported now. Returns: true if the request succeeds. """ @module_and_param_types(instance, 'i_id', 'str') def reset_instance_attribute(self, context, instance_id, attribute): """Resets an attribute of an instance to its default value. To reset the kernel or ramdisk, the instance must be in a stopped state. To reset the SourceDestCheck, the instance can be either running or stopped. Args: context (RequestContext): The request context. instance_id (str): The ID of the instance. attribute (str): The attribute to reset. Returns: true if the request succeeds. """ @module_and_param_types(key_pair, 'str255s', 'filter') def describe_key_pairs(self, context, key_name=None, filter=None): """Describes one or more of your key pairs. Args: context (RequestContext): The request context. key_name (list of str): On or more keypair names. filter (list of filter dict): On or more filters. Returns: Specified keypairs. """ @module_and_param_types(key_pair, 'str255') def create_key_pair(self, context, key_name): """Creates a 2048-bit RSA key pair with the specified name. Args: context (RequestContext): The request context. key_name (str): A unique name for the key pair. Returns: Created keypair. """ @module_and_param_types(key_pair, 'str255') def delete_key_pair(self, context, key_name): """Deletes the specified key pair. Args: context (RequestContext): The request context. key_name (str): Name of the keypair. Returns: Returns true if the request succeeds. """ @module_and_param_types(key_pair, 'str255', 'str') def import_key_pair(self, context, key_name, public_key_material): """Imports the public key from an existing RSA key pair. Args: context (RequestContext): The request context. key_name (str): A unique name for the key pair. public_key_material (str): The public key. You must base64 encode the public key material before sending it. Returns: Imported keypair. """ @module_and_param_types(availability_zone, 'strs', 'filter') def describe_availability_zones(self, context, zone_name=None, filter=None): """Describes one or more of the available Availability Zones. Args: context (RequestContext): The request context. zone_name (list of str): On or more zone names. filter (list of filter dict): On or more filters. Returns: Specified availability zones. """ @module_and_param_types(availability_zone, 'strs', 'filter') def describe_regions(self, context, region_name=None, filter=None): """Describes one or more regions that are currently available to you. Args: context (RequestContext): The request context. region_name (list of str): On or more region names. filter (list of filter dict): On or more filters. Returns: Specified regions. """ @module_and_param_types(availability_zone, 'strs') def describe_account_attributes(self, context, attribute_name=None): """Describes attributes of your EC2 account. Args: context (RequestContext): The request context. attribute_name (list of str): One or more account attribute names. The following are the supported account attributes: supported-platforms | default-vpc | max-instances | vpc-max-security-groups-per-interface (unsupported now) | max-elastic-ips (unsupported now) | vpc-max-elastic-ips (unsupported now) Returns: Information about one or more account attributes. """ @module_and_param_types(instance, 'i_id_or_ids') def get_password_data(self, context, instance_id): """Retrieves the encrypted administrator password for Windows instance. Args: context (RequestContext): The request context. instance_id (str): ID of the Windows instance Returns: The password of the instance, timestamp and instance id. The password is encrypted using the key pair that you specified when you launched the instance. """ @module_and_param_types(instance, 'i_id_or_ids') def get_console_output(self, context, instance_id): """Gets the console output for the specified instance. Args: context (RequestContext): The request context. instance_id (str): ID of the instance Returns: The console output of the instance, timestamp and instance id. """ @module_and_param_types(volume, 'str', 'int', 'snap_id', 'str', 'int', 'bool', 'str', 'str') def create_volume(self, context, availability_zone=None, size=None, snapshot_id=None, volume_type=None, iops=None, encrypted=None, kms_key_id=None, client_token=None): """Creates an EBS volume. Args: context (RequestContext): The request context. availability_zone (str): The Availability Zone in which to create the volume. It's required by AWS but optional for legacy Nova EC2 API. instance_id (str): The size of the volume, in GiBs. Valid values: 1-1024 If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size. snapshot_id (str): The snapshot from which to create the volume. Required if you are creating a volume from a snapshot. volume_type (str): The volume type. One of volume types created in used Block Storage. iops (int): The number of IOPS to provision for the volume. Valid values: Range is 100 to 4,000. Not used now. encrypted (boolean): Whether the volume should be encrypted. Not used now. kms_key_id (str): The full ARN of AWS KMS master key to use when creating the encrypted volume. Not used now. client_token (str): Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Returns: Information about the volume. You can create a new empty volume or restore a volume from an EBS snapshot. """ @module_and_param_types(volume, 'vol_id', 'i_id', 'str') def attach_volume(self, context, volume_id, instance_id, device): """Attaches an EBS volume to a running or stopped instance. Args: context (RequestContext): The request context. volume_id (str): The ID of the volume. instance_id (str): The ID of the instance. device_name (str): The device name to expose to the instance. Returns: Information about the attachment. The instance and volume must be in the same Availability Zone. """ @module_and_param_types(volume, 'vol_id', 'i_id', 'str') def detach_volume(self, context, volume_id, instance_id=None, device=None, force=None): """Detaches an EBS volume from an instance. Args: context (RequestContext): The request context. volume_id (str): The ID of the volume. instance_id (str): The ID of the instance. Not used now. device (str): The device name. Not used now. force (boolean): Forces detachment. Not used now. Returns: Information about the detachment. """ @module_and_param_types(volume, 'vol_id') def delete_volume(self, context, volume_id): """Deletes the specified EBS volume. Args: context (RequestContext): The request context. volume_id (str): The ID of the volume. Returns: Returns true if the request succeeds. The volume must be in the available state. """ @module_and_param_types(volume, 'vol_ids', 'filter', 'int', 'str') def describe_volumes(self, context, volume_id=None, filter=None, max_results=None, next_token=None): """Describes the specified EBS volumes. Args: context (RequestContext): The request context. volume_id (list of str): One or more volume IDs. filter (list of filter dict): You can specify filters so that the response includes information for only certain volumes. max_results (int): The maximum number of items to return. next_token (str): The token for the next set of items to return. Returns: A list of volumes. """ @module_and_param_types(snapshot, 'vol_id', 'str') def create_snapshot(self, context, volume_id, description=None): """Creates a snapshot of an EBS volume. Args: context (RequestContext): The request context. volume_id (str): The ID of the volume. description (str): A description for the snapshot. Returns: Information about the snapshot. """ @module_and_param_types(snapshot, 'snap_id') def delete_snapshot(self, context, snapshot_id): """Deletes the specified snapshot. Args: context (RequestContext): The request context. snapshot_id (str): The ID of the snapshot. Returns: Returns true if the request succeeds. """ @module_and_param_types(snapshot, 'snap_ids', 'strs', 'strs', 'filter', 'int', 'str') def describe_snapshots(self, context, snapshot_id=None, owner=None, restorable_by=None, filter=None, max_results=None, next_token=None): """Describes one or more of the snapshots available to you. Args: context (RequestContext): The request context. snapshot_id (list of str): One or more snapshot IDs. owner (list of str): Returns the snapshots owned by the specified owner. Not used now. restorable_by (list of str): One or more accounts IDs that can create volumes from the snapshot. Not used now. filter (list of filter dict): You can specify filters so that the response includes information for only certain snapshots. max_results (int): The maximum number of items to return. next_token (str): The token for the next set of items to return. Returns: A list of snapshots. """ @module_and_param_types(image, 'i_id', 'str', 'str', 'bool', 'dummy') def create_image(self, context, instance_id, name=None, description=None, no_reboot=False, block_device_mapping=None): """Creates an EBS-backed AMI from an EBS-backed instance. Args: context (RequestContext): The request context. instance_id (str): The ID of the instance. name (str): A name for the new image. It's required by AWS but optional for legacy Nova EC2 API. description (str): A description for the new image. Not used now. no_reboot (boolean): When the parameter is set to false, EC2 attempts to shut down the instance cleanly before image creation and then reboots the instance. block_device_mapping (list of dict): Dict can contain: device_name (str): The device name exposed to the instance (for example, /dev/sdh or xvdh). virtual_name (str): The virtual device name (ephemeral[0..3]). ebs (dict): Dict can contain: volume_id (str): The ID of the volume (Nova extension). snapshot_id (str): The ID of the snapshot. volume_size (str): The size of the volume, in GiBs. volume_type (str): The volume type. Not used now. delete_on_termination (bool): Indicates whether to delete the volume on instance termination. iops (int): he number of IOPS to provision for the volume. Not used now. encrypted (boolean): Whether the volume is encrypted. Not used now. no_device (str): Suppresses the device mapping. Returns: The ID of the new AMI. """ return image.create_image(context, instance_id, name, description, no_reboot, block_device_mapping) @module_and_param_types(image, 'str', 'str', 'str', 'str', 'str', 'dummy', 'str', 'aki_id', 'ari_id', 'str') def register_image(self, context, name=None, image_location=None, description=None, architecture=None, root_device_name=None, block_device_mapping=None, virtualization_type=None, kernel_id=None, ramdisk_id=None, sriov_net_support=None): """Registers an AMI. Args: context (RequestContext): The request context. name (str): A name for your AMI. It's required by AWS but optional for legacy Nova EC2 API. image_location (str): The full path to AMI manifest in S3 storage. description (str): A description for your AMI. Not used now. architecture (str): The architecture of the AMI. Not used now. root_device_name (str): The name of the root device block_device_mapping (list of dict): Dict can contain: device_name (str): The device name exposed to the instance (for example, /dev/sdh or xvdh). virtual_name (str): The virtual device name (ephemeral[0..3]). ebs (dict): Dict can contain: volume_id (str): The ID of the volume (Nova extension). snapshot_id (str): The ID of the snapshot. volume_size (str): The size of the volume, in GiBs. volume_type (str): The volume type. Not used now. delete_on_termination (bool): Indicates whether to delete the volume on instance termination. iops (int): he number of IOPS to provision for the volume. Not used now. encrypted (boolean): Whether the volume is encrypted. Not used now. no_device (str): Suppresses the device mapping. virtualization_type (str): The type of virtualization. Not used now. kernel_id (str): The ID of the kernel. Not used now. ramdisk_id (str): The ID of the RAM disk. Not used now. sriov_net_support (str): SR-IOV mode for networking. Not used now. Returns: The ID of the new AMI. """ @module_and_param_types(image, 'amiariaki_id') def deregister_image(self, context, image_id): """Deregisters the specified AMI. Args: context (RequestContext): The request context. image_id (str): The ID of the AMI. Returns: true if the request succeeds. """ @module_and_param_types(image, 'strs', 'amiariaki_ids', 'strs', 'filter') def describe_images(self, context, executable_by=None, image_id=None, owner=None, filter=None): """Describes one or more of the images available to you. Args: context (RequestContext): The request context. executable_by (list of str): Filters the images by users with explicit launch permissions. Not used now. image_id (list of str): One or more image IDs. owner (list of str): Filters the images by the owner. Not used now. filter (list of filter dict): You can specify filters so that the response includes information for only certain images. Returns: A list of images. """ @module_and_param_types(image, 'amiariaki_id', 'str') def describe_image_attribute(self, context, image_id, attribute): """Describes the specified attribute of the specified AMI. Args: context (RequestContext): The request context. image_id (str): The ID of the image. attribute (str): The attribute of the network interface. Valid values: description (unsupported now)| kernel | ramdisk | launchPermission | productCodes (unsupported now)| blockDeviceMapping | rootDeviceName (Nova EC2 extension) Returns: Specified attribute. """ return image.describe_image_attribute(context, image_id, attribute) @module_and_param_types(image, 'amiariaki_id', 'str', 'strs', 'str', 'str', 'dummy', 'dummy', 'dummy', 'str') def modify_image_attribute(self, context, image_id, attribute=None, user_group=None, operation_type=None, description=None, launch_permission=None, product_code=None, user_id=None, value=None): """Modifies the specified attribute of the specified AMI. Args: context (RequestContext): The request context. image_id (str): The ID of the image. attribute (str): The name of the attribute to modify. user_group (list of str): One or more user groups. Only 'all' group is supported now. operation_type (str): The operation type. Only 'add' and 'remove' operation types are supported now. description: A description for the AMI. launch_permission: : A launch permission modification. product_code: : Not supported now. user_id: : Not supported now. value: : The value of the attribute being modified. This is only valid when modifying the description attribute. Returns: true if the request succeeds. """ @module_and_param_types(image, 'amiariaki_id', 'str') def reset_image_attribute(self, context, image_id, attribute): """Resets an attribute of an AMI to its default value. Args: context (RequestContext): The request context. image_id (str): The ID of the image. attribute (str): The attribute to reset (currently you can only reset the launch permission attribute). Returns: true if the request succeeds. """ @module_and_param_types(tag, 'ec2_ids', 'key_value_dict_list') def create_tags(self, context, resource_id, tag): """Adds or overwrites one or more tags for the specified resources. Args: context (RequestContext): The request context. resource_id (list of str): The IDs of one or more resources to tag. tag (list of dict): Dict can contain: key (str): The key of the tag. value (str): The value of the tag. Returns: true if the request succeeds. """ @module_and_param_types(tag, 'ec2_ids', 'dummy') def delete_tags(self, context, resource_id, tag=None): """Deletes the specified tags from the specified resources. Args: context (RequestContext): The request context. resource_id (list of str): The IDs of one or more resources to tag. tag (list of dict): One or more tags to delete. Dict can contain: key (str): The key of the tag. value (str): The value of the tag. Returns: true if the request succeeds. If you omit the value in tag parameter, we delete the tag regardless of its value. If you specify this parameter with an empty string as the value, we delete the key only if its value is an empty string. """ @module_and_param_types(tag, 'filter', 'int', 'str') def describe_tags(self, context, filter=None, max_results=None, next_token=None): """Describes one or more of the tags for your EC2 resources. Args: context (RequestContext): The request context. filter (list of filter dict): You can specify filters so that the response includes information for only certain tags. max_results (int): The maximum number of items to return. next_token (str): The token for the next set of items to return. Returns: A list of tags. """ class VpcCloudController(CloudController): """VPC Cloud Controller Adds full VPC functionality which requires Neutron to work. """ @module_and_param_types(vpc, 'vpc_cidr', 'str255') def create_vpc(self, context, cidr_block, instance_tenancy='default'): """Creates a VPC with the specified CIDR block. Args: context (RequestContext): The request context. cidr_block (str): The CIDR block for the VPC (for example, 10.0.0.0/16). instance_tenancy (str): The supported tenancy options for instances launched into the VPC. Valid values: default | dedicated Not used now. Returns: Information about the VPC. The smallest VPC you can create uses a /28 netmask (16 IP addresses), and the largest uses a /16 netmask. """ @module_and_param_types(vpc, 'vpc_id') def delete_vpc(self, context, vpc_id): """Deletes the specified VPC. Args: context (RequestContext): The request context. vpc_id (str): The ID of the VPC. Returns: true if the request succeeds. You must detach or delete all gateways and resources that are associated with the VPC before you can delete it. For example, you must terminate all instances running in the VPC, delete all security groups associated with the VPC (except the default one), delete all route tables associated with the VPC (except the default one), and so on. """ return vpc.delete_vpc(context, vpc_id) @module_and_param_types(vpc, 'vpc_ids', 'filter') def describe_vpcs(self, context, vpc_id=None, filter=None): """Describes one or more of your VPCs. Args: context (RequestContext): The request context. vpc_id (list of str): One or more VPC IDs. Default: Describes all your VPCs. filter (list of filter dict): You can specify filters so that the response includes information for only certain VPCs. Returns: A list of VPCs. """ return vpc.describe_vpcs(context, vpc_id, filter) @module_and_param_types(internet_gateway) def create_internet_gateway(self, context): """Creates an Internet gateway for use with a VPC. Args: context (RequestContext): The request context. Returns: Information about the Internet gateway. """ @module_and_param_types(internet_gateway, 'igw_id', 'vpc_id') def attach_internet_gateway(self, context, internet_gateway_id, vpc_id): """Attaches an Internet gateway to a VPC. Args: context (RequestContext): The request context. internet_gateway_id (str): The ID of the Internet gateway. vpc_id (str): The ID of the VPC. Returns: Returns true if the request succeeds. Attaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC. """ @module_and_param_types(internet_gateway, 'igw_id', 'vpc_id') def detach_internet_gateway(self, context, internet_gateway_id, vpc_id): """Detaches an Internet gateway from a VPC. Args: context (RequestContext): The request context. internet_gateway_id (str): The ID of the Internet gateway. vpc_id (str): The ID of the VPC. Returns: Returns true if the request succeeds. Detaches an Internet gateway from a VPC, disabling connectivity between the Internet and the VPC. The VPC must not contain any running instances with Elastic IP addresses. """ @module_and_param_types(internet_gateway, 'igw_id') def delete_internet_gateway(self, context, internet_gateway_id): """Deletes the specified Internet gateway. Args: context (RequestContext): The request context. internet_gateway_id (str): The ID of the Internet gateway. Returns: Returns true if the request succeeds. You must detach the Internet gateway from the VPC before you can delete it. """ @module_and_param_types(internet_gateway, 'igw_ids', 'filter') def describe_internet_gateways(self, context, internet_gateway_id=None, filter=None): """Describes one or more of your Internet gateways. Args: context (RequestContext): The request context. internet_gateway_id (list of str): One or more Internet gateway IDs. Default: Describes all your Internet gateways. filter (list of filter dict): You can specify filters so that the response includes information for only certain Internet gateways. Returns: A list of Internet gateways. """ @module_and_param_types(subnet, 'vpc_id', 'subnet_cidr', 'str255') def create_subnet(self, context, vpc_id, cidr_block, availability_zone=None): """Creates a subnet in an existing VPC. Args: context (RequestContext): The request context. vpc_id (str): The ID of the VPC. cidr_block (str): The CIDR block for the subnet. For example, 10.0.0.0/24. availability_zone (str): The Availability Zone for the subnet. If None or empty EC2 selects one for you. Returns: Information about the subnet. The subnet's CIDR block can be the same as the VPC's CIDR block, or a subset of the VPC's CIDR block. If you create more than one subnet in a VPC, the subnets' CIDR blocks must not overlap. The smallest subnet you can create uses a /28 netmask (16 IP addresses), and the largest uses a /16 netmask. EC2 reserves both the first four and the last IP address in each subnet's CIDR block. They're not available for use. If you add more than one subnet to a VPC, they're set up in a star topology with a logical router in the middle. """ @module_and_param_types(subnet, 'subnet_id') def delete_subnet(self, context, subnet_id): """Deletes the specified subnet. Args: context (RequestContext): The request context. subnet_id (str): The ID of the subnet. Returns: true if the request succeeds. You must terminate all running instances in the subnet before you can delete the subnet. """ @module_and_param_types(subnet, 'subnet_ids', 'filter') def describe_subnets(self, context, subnet_id=None, filter=None): """Describes one or more of your subnets. Args: context (RequestContext): The request context. subnet_id (list of str): One or more subnet IDs. Default: Describes all your subnets. filter (list of filter dict): You can specify filters so that the response includes information for only certain subnets. Returns: A list of subnets. """ @module_and_param_types(route_table, 'vpc_id') def create_route_table(self, context, vpc_id): """Creates a route table for the specified VPC. Args: context (RequestContext): The request context. vpc_id (str): The ID of the VPC. Returns: Information about the route table. After you create a route table, you can add routes and associate the table with a subnet. """ @module_and_param_types(route_table, 'rtb_id', 'cidr', 'igw_or_vgw_id', 'i_id', 'eni_id', 'dummy') def create_route(self, context, route_table_id, destination_cidr_block, gateway_id=None, instance_id=None, network_interface_id=None, vpc_peering_connection_id=None): """Creates a route in a route table within a VPC. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table for the route. destination_cidr_block (str): The CIDR address block used for the destination match. Routing decisions are based on the most specific match. gateway_id (str): The ID of an Internet gateway or virtual private gateway attached to your VPC. instance_id (str): The ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached. network_interface_id (str): The ID of a network interface. vpc_peering_connection_id (str): The ID of a VPC peering connection. Returns: true if the requests succeeds. The route's target can be an Internet gateway or virtual private gateway attached to the VPC, a VPC peering connection, or a NAT instance in the VPC. """ @module_and_param_types(route_table, 'rtb_id', 'cidr', 'igw_or_vgw_id', 'i_id', 'eni_id', 'dummy') def replace_route(self, context, route_table_id, destination_cidr_block, gateway_id=None, instance_id=None, network_interface_id=None, vpc_peering_connection_id=None): """Replaces an existing route within a route table in a VPC. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table for the route. destination_cidr_block (str): The CIDR address block used for the destination match. Routing decisions are based on the most specific match. gateway_id (str): The ID of an Internet gateway or virtual private gateway attached to your VPC. instance_id (str): The ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached. network_interface_id (str): The ID of a network interface. vpc_peering_connection_id (str): The ID of a VPC peering connection. Returns: true if the requests succeeds. """ @module_and_param_types(route_table, 'rtb_id', 'cidr') def delete_route(self, context, route_table_id, destination_cidr_block): """Deletes the specified route from the specified route table. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table. destination_cidr_block (str): The CIDR range for the route. The value you specify must match the CIDR for the route exactly. Returns: true if the requests succeeds. """ @module_and_param_types(route_table, 'rtb_id', 'vgw_id') def enable_vgw_route_propagation(self, context, route_table_id, gateway_id): """Enables a VGW to propagate routes to the specified route table. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table. gateway_id (str): The ID of the virtual private gateway. Returns: true if the requests succeeds. """ @module_and_param_types(route_table, 'rtb_id', 'vgw_id') def disable_vgw_route_propagation(self, context, route_table_id, gateway_id): """Disables a (VGW) from propagating routes to a specified route table. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table. gateway_id (str): The ID of the virtual private gateway. Returns: true if the requests succeeds. """ @module_and_param_types(route_table, 'rtb_id', 'subnet_id') def associate_route_table(self, context, route_table_id, subnet_id): """Associates a subnet with a route table. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table. subnet_id (str): The ID of the subnet. Returns: The route table association ID The subnet and route table must be in the same VPC. This association causes traffic originating from the subnet to be routed according to the routes in the route table. The action returns an association ID, which you need in order to disassociate the route table from the subnet later. A route table can be associated with multiple subnets. """ @module_and_param_types(route_table, 'rtbassoc_id', 'rtb_id') def replace_route_table_association(self, context, association_id, route_table_id): """Changes the route table associated with a given subnet in a VPC. Args: context (RequestContext): The request context. association_id (str): The association ID. route_table_id (str): The ID of the new route table to associate with the subnet. Returns: The ID of the new association. After the operation completes, the subnet uses the routes in the new route table it's associated with. You can also use this action to change which table is the main route table in the VPC. """ @module_and_param_types(route_table, 'rtbassoc_id') def disassociate_route_table(self, context, association_id): """Disassociates a subnet from a route table. Args: context (RequestContext): The request context. association_id (str): The association ID. Returns: true if the requests succeeds. After you perform this action, the subnet no longer uses the routes in the route table. Instead, it uses the routes in the VPC's main route table. """ @module_and_param_types(route_table, 'rtb_id') def delete_route_table(self, context, route_table_id): """Deletes the specified route table. Args: context (RequestContext): The request context. route_table_id (str): The ID of the route table. You must disassociate the route table from any subnets before you can delete it. You can't delete the main route table. Returns: true if the requests succeeds. """ @module_and_param_types(route_table, 'rtb_ids', 'filter') def describe_route_tables(self, context, route_table_id=None, filter=None): """Describes one or more of your route tables. Args: context (RequestContext): The request context. route_table_id (str): One or more route table IDs. filter (list of filter dict): You can specify filters so that the response includes information for only certain tables. Returns: A list of route tables """ @module_and_param_types(dhcp_options, 'key_value_dict_list') def create_dhcp_options(self, context, dhcp_configuration): """Creates a set of DHCP options for your VPC. Args: context (RequestContext): The request context. dhcp_configuration (list of dict): Dict can contain 'key' (str) and 'value' (str) for each option. You can specify the following options: - domain-name-servers: up to 4 DNS servers, IPs are in value separated by commas - domain-name: domain name - ntp-servers: up to 4 NTP servers - netbios-name-servers: up to 4 NetBIOS name servers - netbios-node-type: the NetBIOS node type (1,2,4 or 8) Returns: A set of DHCP options """ @module_and_param_types(dhcp_options, 'dopt_ids', 'filter') def describe_dhcp_options(self, context, dhcp_options_id=None, filter=None): """Describes the specified DHCP options. Args: context (RequestContext): The request context. dhcp_options_id (list of str): DHCP options id. filter (list of filter dict): You can specify filters so that the response includes information for only certain DHCP options. Returns: DHCP options. """ @module_and_param_types(dhcp_options, 'dopt_id') def delete_dhcp_options(self, context, dhcp_options_id): """Deletes the specified set of DHCP options Args: context (RequestContext): The request context. dhcp_options_id (str): DHCP options id Returns: true if the request succeeds You must disassociate the set of DHCP options before you can delete it. You can disassociate the set of DHCP options by associating either a new set of options or the default set of options with the VPC. """ @module_and_param_types(dhcp_options, 'dopt_id_or_default', 'vpc_id') def associate_dhcp_options(self, context, dhcp_options_id, vpc_id): """Associates a set of DHCP options with the specified VPC. Args: context (RequestContext): The request context. dhcp_options_id (str): DHCP options id or "default" to associate no DHCP options with the VPC Returns: true if the request succeeds """ @module_and_param_types(network_interface, 'subnet_id', 'ip', 'dummy', 'int', 'str', 'sg_ids', 'str') def create_network_interface(self, context, subnet_id, private_ip_address=None, private_ip_addresses=None, secondary_private_ip_address_count=None, description=None, security_group_id=None, client_token=None): """Creates a network interface in the specified subnet. Args: subnet_id (str): The ID of the subnet to associate with the network interface. private_ip_address (str): The primary private IP address of the network interface. If you don't specify an IP address, EC2 selects one for you from the subnet range. private_ip_addresses (list of dict): Dict can contain 'private_ip_address' (str) and 'primary' (boolean) for each address. The private IP addresses of the specified network interface and indicators which one is primary. Only one private IP address can be designated as primary. You can't specify this parameter when private_ip_addresses['primary'] is true if you specify private_ip_address. secondary_private_ip_address_count (integer): The number of secondary private IP addresses to assign to a network interface. EC2 selects these IP addresses within the subnet range. For a single network interface, you can't specify this option and specify more than one private IP address using private_ip_address and/or private_ip_addresses. description (str): A description for the network interface. security_group_id (list of str): The list of security group IDs for the network interface. client_token (str): Unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Returns: The network interface that was created. """ @module_and_param_types(network_interface, 'eni_id') def delete_network_interface(self, context, network_interface_id): """Deletes the specified network interface. Args: context (RequestContext): The request context. network_interface_id (str): The ID of the network interface. Returns: true if the request succeeds. You must detach the network interface before you can delete it. """ @module_and_param_types(network_interface, 'eni_ids', 'filter') def describe_network_interfaces(self, context, network_interface_id=None, filter=None): """Describes one or more of your network interfaces. Args: context (RequestContext): The request context. network_interface_id (list of str): One or more network interface IDs. Default: Describes all your network interfaces. filter (list of filter dict): You can specify filters so that the response includes information for only certain interfaces. Returns: A list of network interfaces. """ return network_interface.describe_network_interfaces( context, network_interface_id, filter) @module_and_param_types(network_interface, 'eni_id', 'str') def describe_network_interface_attribute(self, context, network_interface_id, attribute=None): """Describes the specified attribute of the specified network interface. Args: context (RequestContext): The request context. network_interface_id: Network interface ID. attribute: The attribute of the network interface. Returns: Specified attribute. You can specify only one attribute at a time. """ return network_interface.describe_network_interface_attribute( context, network_interface_id, attribute) @module_and_param_types(network_interface, 'eni_id', 'str', 'bool', 'sg_ids', 'dummy') def modify_network_interface_attribute(self, context, network_interface_id, description=None, source_dest_check=None, security_group_id=None, attachment=None): """Modifies the specified attribute of the specified network interface. Args: context (RequestContext): The request context. network_interface_id: Network interface ID. description: New description. source_dest_check: Indicates whether source/destination checking is enabled. A value of true means checking is enabled, and false means checking is disabled. This value must be false for a NAT instance to perform NAT. security_group_id [list of str]: List of secuirity groups to attach attachment: Information about the interface attachment. If modifying the 'delete on termination' attribute, you must specify the ID of the interface attachment. Returns: true if the request succeeds. You can specify only one attribute at a time. """ @module_and_param_types(network_interface, 'eni_id', 'str') def reset_network_interface_attribute(self, context, network_interface_id, attribute): """Resets the specified attribute of the specified network interface. Args: context (RequestContext): The request context. network_interface_id: Network interface ID. attribute: The attribute to reset. Valid values "SourceDestCheck" (reset to True) Returns: true if the request succeeds. """ @module_and_param_types(network_interface, 'eni_id', 'i_id', 'int') def attach_network_interface(self, context, network_interface_id, instance_id, device_index): """Attach a network interface to an instance. Args: context (RequestContext): The request context. network_interface_id (str): The ID of the network interface. instance_id (str): The ID of the instance. device_index (int): The index of the device for the network interface attachment. Returns: Attachment Id """ @module_and_param_types(network_interface, 'eni_attach_id', 'bool') def detach_network_interface(self, context, attachment_id, force=None): """Detach a network interface from an instance. Args: context (RequestContext): The request context. attachment_id (str): The ID of the attachment. force (boolean): Specifies whether to force a detachment Returns: true if the request succeeds. """ @module_and_param_types(network_interface, 'eni_id', 'ips', 'int', 'bool') def assign_private_ip_addresses(self, context, network_interface_id, private_ip_address=None, secondary_private_ip_address_count=None, allow_reassignment=False): """Assigns secondary private IP addresses to the network interface. Args: network_interface_id (str): The ID of the network interface. private_ip_address (list of str): List of IP addresses to assign. secondary_private_ip_address_count (integer): The number of secondary private IP addresses to assign. EC2 selects these IP addresses within the subnet range. Returns: true if the request succeeds. """ @module_and_param_types(network_interface, 'eni_id', 'ips') def unassign_private_ip_addresses(self, context, network_interface_id, private_ip_address=None): """Unassigns secondary IP addresses from the network interface. Args: network_interface_id (str): The ID of the network interface. private_ip_address (list of str): List of secondary private IP addresses to unassign. Returns: true if the request succeeds. """ @module_and_param_types(vpn_gateway, 'vpn_connection_type', 'str') def create_vpn_gateway(self, context, type, availability_zone=None): """Creates a virtual private gateway. Args: context (RequestContext): The request context. type (str): The type of VPN connection this virtual private gateway supports (ipsec.1). availability_zone (str): The Availability Zone for the virtual private gateway. Returns: Information about the virtual private gateway. """ @module_and_param_types(vpn_gateway, 'vpc_id', 'vgw_id') def attach_vpn_gateway(self, context, vpc_id, vpn_gateway_id): """Attaches a virtual private gateway to a VPC. Args: context (RequestContext): The request context. vpc_id (str): The ID of the VPC. vpn_gateway_id (str): he ID of the virtual private gateway. Returns: Information about the attachment. """ @module_and_param_types(vpn_gateway, 'vpc_id', 'vgw_id') def detach_vpn_gateway(self, context, vpc_id, vpn_gateway_id): """Detaches a virtual private gateway from a VPC. Args: context (RequestContext): The request context. vpc_id (str): The ID of the VPC. vpn_gateway_id (str): he ID of the virtual private gateway. Returns: true if the request succeeds. """ @module_and_param_types(vpn_gateway, 'vgw_id') def delete_vpn_gateway(self, context, vpn_gateway_id): """Deletes the specified virtual private gateway. Args: context (RequestContext): The request context. vpn_gateway_id (str): The ID of the virtual private gateway. Returns: true if the request succeeds. """ @module_and_param_types(vpn_gateway, 'vgw_ids', 'filter') def describe_vpn_gateways(self, context, vpn_gateway_id=None, filter=None): """Describes one or more of your virtual private gateways. Args: context (RequestContext): The request context. vpn_gateway_id (list of str): One or more virtual private gateway IDs. filter (list of filter dict): One or more filters. Returns: Information about one or more virtual private gateways. """ @module_and_param_types(customer_gateway, 'ip', 'vpn_connection_type', 'int') def create_customer_gateway(self, context, ip_address, type, bgp_asn=None): """Provides information to EC2 API about VPN customer gateway device. Args: context (RequestContext): The request context. ip_address (str): The Internet-routable IP address for the customer gateway's outside interface. type (str): The type of VPN connection that this customer gateway supports (ipsec.1). bgp_asn (int): For devices that support BGP, the customer gateway's BGP ASN (65000 otherwise). Returns: Information about the customer gateway. You cannot create more than one customer gateway with the same VPN type, IP address, and BGP ASN parameter values. If you run an identical request more than one time, subsequent requests return information about the existing customer gateway. """ @module_and_param_types(customer_gateway, 'cgw_id') def delete_customer_gateway(self, context, customer_gateway_id): """Deletes the specified customer gateway. Args: context (RequestContext): The request context. customer_gateway_id (str): The ID of the customer gateway. Returns: true if the request succeeds. You must delete the VPN connection before you can delete the customer gateway. """ @module_and_param_types(customer_gateway, 'cgw_ids', 'filter') def describe_customer_gateways(self, context, customer_gateway_id=None, filter=None): """Describes one or more of your VPN customer gateways. Args: context (RequestContext): The request context. customer_gateway_id (list of str): One or more customer gateway IDs. filter (list of filter dict): One or more filters. Returns: Information about one or more customer gateways. """ @module_and_param_types(vpn_connection, 'cgw_id', 'vgw_id', 'vpn_connection_type', 'dummy') def create_vpn_connection(self, context, customer_gateway_id, vpn_gateway_id, type, options=None): """Creates a VPN connection. Args: context (RequestContext): The request context. customer_gateway_id (str): The ID of the customer gateway. vpn_gateway_id (str): The ID of the virtual private gateway. type (str): The type of VPN connection (ipsec.1). options (dict of options): Indicates whether the VPN connection requires static routes. Returns: Information about the VPN connection. Creates a VPN connection between an existing virtual private gateway and a VPN customer gateway. """ @module_and_param_types(vpn_connection, 'vpn_id', 'cidr') def create_vpn_connection_route(self, context, vpn_connection_id, destination_cidr_block): """Creates a static route associated with a VPN connection. Args: context (RequestContext): The request context. vpn_connection_id (str): The ID of the VPN connection. destination_cidr_block (str): The CIDR block associated with the local subnet of the customer network. Returns: true if the request succeeds. The static route allows traffic to be routed from the virtual private gateway to the VPN customer gateway. """ @module_and_param_types(vpn_connection, 'vpn_id', 'cidr') def delete_vpn_connection_route(self, context, vpn_connection_id, destination_cidr_block): """Deletes the specified static route associated with a VPN connection. Args: context (RequestContext): The request context. vpn_connection_id (str): The ID of the VPN connection. destination_cidr_block (str): The CIDR block associated with the local subnet of the customer network. Returns: true if the request succeeds. """ @module_and_param_types(vpn_connection, 'vpn_id') def delete_vpn_connection(self, context, vpn_connection_id): """Deletes the specified VPN connection. Args: context (RequestContext): The request context. vpn_connection_id (str): The ID of the VPN connection. Returns: true if the request succeeds. """ @module_and_param_types(vpn_connection, 'vpn_ids', 'filter') def describe_vpn_connections(self, context, vpn_connection_id=None, filter=None): """Describes one or more of your VPN connections. Args: context (RequestContext): The request context. vpn_connection_id (list of str): One or more VPN connection IDs. filter (list of filter dict): One or more filters. Returns: Information about one or more VPN connections. """