Update checked in version of gsutil to version 4.6

third_party/boto/boto/ec2/connection.py

 # Copyright (c) 2006-2012 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 # Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
@@ skipping 40 matching lines @@
 from boto.ec2.reservedinstance import ReservedInstanceListing
 from boto.ec2.reservedinstance import ReservedInstancesConfiguration
 from boto.ec2.reservedinstance import ModifyReservedInstancesResult
 from boto.ec2.reservedinstance import ReservedInstancesModification
 from boto.ec2.spotinstancerequest import SpotInstanceRequest
 from boto.ec2.spotpricehistory import SpotPriceHistory
 from boto.ec2.spotdatafeedsubscription import SpotDatafeedSubscription
 from boto.ec2.bundleinstance import BundleInstanceTask
 from boto.ec2.placementgroup import PlacementGroup
 from boto.ec2.tag import Tag
-from boto.ec2.vmtype import VmType
+from boto.ec2.instancetype import InstanceType
 from boto.ec2.instancestatus import InstanceStatusSet
 from boto.ec2.volumestatus import VolumeStatusSet
 from boto.ec2.networkinterface import NetworkInterface
 from boto.ec2.attributes import AccountAttribute, VPCAttribute
 from boto.ec2.blockdevicemapping import BlockDeviceMapping, BlockDeviceType
 from boto.exception import EC2ResponseError
 
 #boto.set_stream_logger('ec2')
 
 
 class EC2Connection(AWSQueryConnection):
 
-    APIVersion = boto.config.get('Boto', 'ec2_version', '2013-10-15')
+    APIVersion = boto.config.get('Boto', 'ec2_version', '2014-05-01')
     DefaultRegionName = boto.config.get('Boto', 'ec2_region_name', 'us-east-1')
     DefaultRegionEndpoint = boto.config.get('Boto', 'ec2_region_endpoint',
                                             'ec2.us-east-1.amazonaws.com')
     ResponseError = EC2ResponseError
 
     def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
                  is_secure=True, host=None, port=None,
                  proxy=None, proxy_port=None,
                  proxy_user=None, proxy_pass=None, debug=0,
                  https_connection_factory=None, region=None, path='/',
                  api_version=None, security_token=None,
-                 validate_certs=True):
+                 validate_certs=True, profile_name=None):
         """
         Init method to create a new connection to EC2.
         """
         if not region:
             region = RegionInfo(self, self.DefaultRegionName,
                                 self.DefaultRegionEndpoint)
         self.region = region
         super(EC2Connection, self).__init__(aws_access_key_id,
                                     aws_secret_access_key,
                                     is_secure, port, proxy, proxy_port,
                                     proxy_user, proxy_pass,
                                     self.region.endpoint, debug,
                                     https_connection_factory, path,
                                     security_token,
-                                    validate_certs=validate_certs)
+                                    validate_certs=validate_certs,
+                                    profile_name=profile_name)
         if api_version:
             self.APIVersion = api_version
 
     @detect_potential_sigv4
     def _required_auth_capability(self):
         return ['ec2']
 
     def get_params(self):
         """
-        Returns a dictionary containing the value of of all of the keyword
+        Returns a dictionary containing the value of all of the keyword
         arguments passed when constructing this connection.
         """
         param_names = ['aws_access_key_id', 'aws_secret_access_key',
                        'is_secure', 'port', 'proxy', 'proxy_port',
                        'proxy_user', 'proxy_pass',
                        'debug', 'https_connection_factory']
         params = {}
         for name in param_names:
             params[name] = getattr(self, name)
         return params
@@ skipping 136 matching lines @@
         try:
             return self.get_all_images(image_ids=[image_id], dry_run=dry_run)[0]
         except IndexError:  # None of those images available
             return None
 
     def register_image(self, name=None, description=None, image_location=None,
                        architecture=None, kernel_id=None, ramdisk_id=None,
                        root_device_name=None, block_device_map=None,
                        dry_run=False, virtualization_type=None,
                        sriov_net_support=None,
-                       snapshot_id=None):
+                       snapshot_id=None, 
+                       delete_root_volume_on_termination=False):
         """
         Register an image.
 
         :type name: string
         :param name: The name of the AMI.  Valid only for EBS-based images.
 
         :type description: string
         :param description: The description of the AMI.
 
         :type image_location: string
@@ skipping 28 matching lines @@
         :type sriov_net_support: string
         :param sriov_net_support: Advanced networking support.
             Valid choices are:
             * simple
 
         :type snapshot_id: string
         :param snapshot_id: A snapshot ID for the snapshot to be used
             as root device for the image. Mutually exclusive with
             block_device_map, requires root_device_name
 
+        :type delete_root_volume_on_termination: bool
+        :param delete_root_volume_on_termination: Whether to delete the root
+            volume of the image after instance termination. Only applies when
+            creating image from snapshot_id. Defaults to False.  Note that 
+            leaving volumes behind after instance termination is not free.
+
         :rtype: string
         :return: The new image id
         """
         params = {}
         if name:
             params['Name'] = name
         if description:
             params['Description'] = description
         if architecture:
             params['Architecture'] = architecture
         if kernel_id:
             params['KernelId'] = kernel_id
         if ramdisk_id:
             params['RamdiskId'] = ramdisk_id
         if image_location:
             params['ImageLocation'] = image_location
         if root_device_name:
             params['RootDeviceName'] = root_device_name
         if snapshot_id:
-            root_vol = BlockDeviceType(snapshot_id=snapshot_id)
+            root_vol = BlockDeviceType(snapshot_id=snapshot_id, 
+              delete_on_termination=delete_root_volume_on_termination)
             block_device_map = BlockDeviceMapping()
             block_device_map[root_device_name] = root_vol
         if block_device_map:
             block_device_map.ec2_build_list_params(params)
         if dry_run:
             params['DryRun'] = 'true'
         if virtualization_type:
             params['VirtualizationType'] = virtualization_type
         if sriov_net_support:
             params['SriovNetSupport'] = sriov_net_support
@@ skipping 247 matching lines @@
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         :type max_results: int
         :param max_results: The maximum number of paginated instance
             items per response.
 
         :rtype: list
         :return: A list of  :class:`boto.ec2.instance.Instance`
         """
-        reservations = self.get_all_reservations(instance_ids=instance_ids,
-                                                 filters=filters,
-                                                 dry_run=dry_run,
-                                                 max_results=max_results)
-        return [instance for reservation in reservations
-                for instance in reservation.instances]
+        next_token = None
+        retval = []
+        while True:
+            reservations = self.get_all_reservations(instance_ids=instance_ids,
+                                                     filters=filters,
+                                                     dry_run=dry_run,
+                                                     max_results=max_results,
+                                                     next_token=next_token)
+            retval.extend([instance for reservation in reservations for
+                           instance in reservation.instances])
+            next_token = reservations.next_token
+            if not next_token:
+                break
+
+        return retval
 
     def get_all_reservations(self, instance_ids=None, filters=None,
-                             dry_run=False, max_results=None):
+                             dry_run=False, max_results=None, next_token=None):
         """
         Retrieve all the instance reservations associated with your account.
 
         :type instance_ids: list
         :param instance_ids: A list of strings of instance IDs
 
         :type filters: dict
         :param filters: Optional filters that can be used to limit the
             results returned.  Filters are provided in the form of a
             dictionary consisting of filter names as the key and
             filter values as the value.  The set of allowable filter
             names/values is dependent on the request being performed.
             Check the EC2 API guide for details.
 
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         :type max_results: int
         :param max_results: The maximum number of paginated instance
             items per response.
 
+        :type next_token: str
+        :param next_token: A string specifying the next paginated set
+            of results to return.
+
         :rtype: list
         :return: A list of  :class:`boto.ec2.instance.Reservation`
         """
         params = {}
         if instance_ids:
             self.build_list_params(params, instance_ids, 'InstanceId')
         if filters:
             if 'group-id' in filters:
                 gid = filters.get('group-id')
                 if not gid.startswith('sg-') or len(gid) != 11:
                     warnings.warn(
                         "The group-id filter now requires a security group "
                         "identifier (sg-*) instead of a group name. To filter "
                         "by group name use the 'group-name' filter instead.",
                         UserWarning)
             self.build_filter_params(params, filters)
         if dry_run:
             params['DryRun'] = 'true'
         if max_results is not None:
             params['MaxResults'] = max_results
+        if next_token:
+            params['NextToken'] = next_token
         return self.get_list('DescribeInstances', params,
                              [('item', Reservation)], verb='POST')
 
     def get_all_instance_status(self, instance_ids=None,
                                 max_results=None, next_token=None,
                                 filters=None, dry_run=False):
         """
         Retrieve all the instances in your account scheduled for maintenance.
 
         :type instance_ids: list
@@ skipping 63 matching lines @@
         :param min_count: The minimum number of instances to launch.
 
         :type max_count: int
         :param max_count: The maximum number of instances to launch.
 
         :type key_name: string
         :param key_name: The name of the key pair with which to
             launch instances.
 
         :type security_groups: list of strings
-        :param security_groups: The names of the security groups with which to
-            associate instances.
+        :param security_groups: The names of the EC2 classic security groups
+            with which to associate instances
 
         :type user_data: string
         :param user_data: The Base64-encoded MIME user data to be made
             available to the instance(s) in this reservation.
 
         :type instance_type: string
         :param instance_type: The type of instance to run:
 
             * t1.micro
             * m1.small
             * m1.medium
             * m1.large
             * m1.xlarge
+            * m3.medium
+            * m3.large
             * m3.xlarge
             * m3.2xlarge
             * c1.medium
             * c1.xlarge
             * m2.xlarge
             * m2.2xlarge
             * m2.4xlarge
             * cr1.8xlarge
             * hi1.4xlarge
             * hs1.8xlarge
             * cc1.4xlarge
             * cg1.4xlarge
             * cc2.8xlarge
             * g2.2xlarge
             * c3.large
             * c3.xlarge
             * c3.2xlarge
             * c3.4xlarge
             * c3.8xlarge
             * i2.xlarge
             * i2.2xlarge
             * i2.4xlarge
             * i2.8xlarge
+            * t2.micro
+            * t2.small
+            * t2.medium
 
         :type placement: string
         :param placement: The Availability Zone to launch the instance into.
 
         :type kernel_id: string
         :param kernel_id: The ID of the kernel with which to launch the
             instances.
 
         :type ramdisk_id: string
         :param ramdisk_id: The ID of the RAM disk with which to launch the
@@ skipping 650 matching lines @@
         :param user_data: The user data passed to the launched instances
 
         :type instance_type: string
         :param instance_type: The type of instance to run:
 
             * t1.micro
             * m1.small
             * m1.medium
             * m1.large
             * m1.xlarge
+            * m3.medium
+            * m3.large
             * m3.xlarge
             * m3.2xlarge
             * c1.medium
             * c1.xlarge
             * m2.xlarge
             * m2.2xlarge
             * m2.4xlarge
             * cr1.8xlarge
             * hi1.4xlarge
             * hs1.8xlarge
             * cc1.4xlarge
             * cg1.4xlarge
             * cc2.8xlarge
             * g2.2xlarge
             * c3.large
             * c3.xlarge
             * c3.2xlarge
             * c3.4xlarge
             * c3.8xlarge
             * i2.xlarge
             * i2.2xlarge
             * i2.4xlarge
             * i2.8xlarge
+            * t2.micro
+            * t2.small
+            * t2.medium
 
         :type placement: string
         :param placement: The availability zone in which to launch
             the instances
 
         :type kernel_id: string
         :param kernel_id: The ID of the kernel with which to launch the
             instances
 
         :type ramdisk_id: string
@@ skipping 357 matching lines @@
     def _associate_address(self, status, instance_id=None, public_ip=None,
                           allocation_id=None, network_interface_id=None,
                           private_ip_address=None, allow_reassociation=False,
                           dry_run=False):
         params = {}
         if instance_id is not None:
                 params['InstanceId'] = instance_id
         elif network_interface_id is not None:
                 params['NetworkInterfaceId'] = network_interface_id
 
-        if public_ip is not None:
+        # Allocation id trumps public ip in order to associate with VPCs
+        if allocation_id is not None:
+            params['AllocationId'] = allocation_id
+        elif public_ip is not None:
             params['PublicIp'] = public_ip
-        elif allocation_id is not None:
-            params['AllocationId'] = allocation_id
 
         if private_ip_address is not None:
             params['PrivateIpAddress'] = private_ip_address
 
         if allow_reassociation:
             params['AllowReassociation'] = 'true'
 
         if dry_run:
             params['DryRun'] = 'true'
 
@@ skipping 111 matching lines @@
         :param association_id: The association ID for a VPC based elastic ip.
 
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         :rtype: bool
         :return: True if successful
         """
         params = {}
 
-        if public_ip is not None:
+        # If there is an association id it trumps public ip
+        # in order to successfully dissassociate with a VPC elastic ip
+        if association_id is not None:
+            params['AssociationId'] = association_id
+        elif public_ip is not None:
             params['PublicIp'] = public_ip
-        elif association_id is not None:
-            params['AssociationId'] = association_id
 
         if dry_run:
             params['DryRun'] = 'true'
 
         return self.get_status('DisassociateAddress', params, verb='POST')
 
     def release_address(self, public_ip=None, allocation_id=None,
                         dry_run=False):
         """
         Free up an Elastic IP address.  Pass a public IP address to
@@ skipping 214 matching lines @@
         :param dry_run: Set to True if the operation should not actually run.
 
         """
         params = {'VolumeId': volume_id}
         if attribute == 'AutoEnableIO':
             params['AutoEnableIO.Value'] = new_value
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_status('ModifyVolumeAttribute', params, verb='POST')
 
-    def create_volume(self, size, zone, snapshot=None,
-                      volume_type=None, iops=None, dry_run=False):
+    def create_volume(self, size, zone, snapshot=None, volume_type=None,
+                      iops=None, encrypted=False, dry_run=False):
         """
         Create a new EBS Volume.
 
         :type size: int
         :param size: The size of the new volume, in GiB
 
         :type zone: string or :class:`boto.ec2.zone.Zone`
         :param zone: The availability zone in which the Volume will be created.
 
         :type snapshot: string or :class:`boto.ec2.snapshot.Snapshot`
         :param snapshot: The snapshot from which the new Volume will be
             created.
 
         :type volume_type: string
         :param volume_type: The type of the volume. (optional).  Valid
             values are: standard | io1.
 
         :type iops: int
         :param iops: The provisioned IOPs you want to associate with
             this volume. (optional)
 
+        :type encrypted: bool
+        :param encrypted: Specifies whether the volume should be encrypted.
+            (optional)
+
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         """
         if isinstance(zone, Zone):
             zone = zone.name
         params = {'AvailabilityZone': zone}
         if size:
             params['Size'] = size
         if snapshot:
             if isinstance(snapshot, Snapshot):
                 snapshot = snapshot.id
             params['SnapshotId'] = snapshot
         if volume_type:
             params['VolumeType'] = volume_type
         if iops:
             params['Iops'] = str(iops)
+        if encrypted:
+            params['Encrypted'] = 'true'
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_object('CreateVolume', params, Volume, verb='POST')
 
     def delete_volume(self, volume_id, dry_run=False):
         """
         Delete an EBS volume.
 
         :type volume_id: str
         :param volume_id: The ID of the volume to be delete.
@@ skipping 1901 matching lines @@
             tags = {}.fromkeys(tags, None)
         params = {}
         self.build_list_params(params, resource_ids, 'ResourceId')
         self.build_tag_param_list(params, tags)
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_status('DeleteTags', params, verb='POST')
 
     # Network Interface methods
 
-    def get_all_network_interfaces(self, filters=None, dry_run=False):
+    def get_all_network_interfaces(self, network_interface_ids=None, filters=None, dry_run=False):
         """
         Retrieve all of the Elastic Network Interfaces (ENI's)
         associated with your account.
 
+        :type network_interface_ids: list
+        :param network_interface_ids: a list of strings representing ENI IDs
+        
         :type filters: dict
         :param filters: Optional filters that can be used to limit
                         the results returned.  Filters are provided
                         in the form of a dictionary consisting of
                         filter names as the key and filter values
                         as the value.  The set of allowable filter
                         names/values is dependent on the request
                         being performed.  Check the EC2 API guide
                         for details.
 
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         :rtype: list
         :return: A list of :class:`boto.ec2.networkinterface.NetworkInterface`
         """
         params = {}
+        if network_interface_ids:
+            self.build_list_params(params, network_interface_ids, 'NetworkInterfaceId')
         if filters:
             self.build_filter_params(params, filters)
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_list('DescribeNetworkInterfaces', params,
                              [('item', NetworkInterface)], verb='POST')
 
     def create_network_interface(self, subnet_id, private_ip_address=None,
                                  description=None, groups=None, dry_run=False):
         """
@@ skipping 98 matching lines @@
 
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         """
         params = {'NetworkInterfaceId': network_interface_id}
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_status('DeleteNetworkInterface', params, verb='POST')
 
-    def get_all_vmtypes(self):
+    def get_all_instance_types(self):
         """
-        Get all vmtypes available on this cloud (eucalyptus specific)
+        Get all instance_types available on this cloud (eucalyptus specific)
 
-        :rtype: list of :class:`boto.ec2.vmtype.VmType`
-        :return: The requested VmType objects
+        :rtype: list of :class:`boto.ec2.instancetype.InstanceType`
+        :return: The requested InstanceType objects
         """
         params = {}
-        return self.get_list('DescribeVmTypes', params, [('euca:item', VmType)], verb='POST')
+        return self.get_list('DescribeInstanceTypes', params, [('item', InstanceType)], verb='POST')
 
     def copy_image(self, source_region, source_image_id, name=None,
                    description=None, client_token=None, dry_run=False):
         """
         :type dry_run: bool
         :param dry_run: Set to True if the operation should not actually run.
 
         """
         params = {
             'SourceRegion': source_region,
@@ skipping 52 matching lines @@
         }
         if enable_dns_support is not None:
             params['EnableDnsSupport.Value'] = (
                 'true' if enable_dns_support else 'false')
         if enable_dns_hostnames is not None:
             params['EnableDnsHostnames.Value'] = (
                 'true' if enable_dns_hostnames else 'false')
         if dry_run:
             params['DryRun'] = 'true'
         return self.get_status('ModifyVpcAttribute', params, verb='POST')