fog-aws 1.4.1 → 2.0.0

data/lib/fog/aws/models/compute/subnet.rb

@@ -10,6 +10,7 @@ module Fog
         attribute :availability_zone,           :aliases => 'availabilityZone'
         attribute :tag_set,                     :aliases => 'tagSet'
         attribute :map_public_ip_on_launch,     :aliases => 'mapPublicIpOnLaunch'
+        attribute :default_for_az,              :aliases => 'defaultForAz'
 
         def ready?
           requires :state

data/lib/fog/aws/models/compute/vpc.rb

@@ -10,8 +10,17 @@ module Fog
         attribute :tags,             :aliases => 'tagSet'
         attribute :tenancy,          :aliases => 'instanceTenancy'
         attribute :is_default,       :aliases => 'isDefault'
-        attribute :ipv_6_cidr_block_association_set,  :aliases => 'ipv6CidrBlockAssociationSet'
-        attribute :amazon_provided_ipv_6_cidr_block,  :aliases => 'amazonProvidedIpv6CidrBlock'
+
+        attribute :cidr_block_association_set, :aliases => 'cidrBlockAssociationSet'
+
+        attribute :ipv6_cidr_block_association_set, :aliases => 'ipv6CidrBlockAssociationSet'
+        attribute :amazon_provided_ipv6_cidr_block, :aliases => 'amazonProvidedIpv6CidrBlock'
+
+        # Backward compatibility. Please use ipv6_cidr_block_association_set
+        alias_method :ipv_6_cidr_block_association_set,  :ipv6_cidr_block_association_set
+        alias_method :ipv_6_cidr_block_association_set=, :ipv6_cidr_block_association_set=
+        alias_method :amazon_provided_ipv_6_cidr_block,  :amazon_provided_ipv6_cidr_block
+        alias_method :amazon_provided_ipv_6_cidr_block=, :amazon_provided_ipv6_cidr_block=
 
         def subnets
           service.subnets(:filters => {'vpcId' => self.identity}).all

data/lib/fog/aws/models/iam/access_keys.rb

@@ -13,8 +13,6 @@ module Fog
 
         def all
           data = service.list_access_keys('UserName'=> @username).body['AccessKeys']
-          # AWS response doesn't contain the UserName, this injects it
-          data.each {|access_key| access_key['UserName'] = @username }
           load(data)
         end
 

data/lib/fog/aws/models/rds/instance_option.rb

@@ -10,6 +10,12 @@ module Fog
         attribute :availability_zones, :aliases => 'AvailabilityZones', :type => :array
         attribute :db_instance_class, :aliases => 'DBInstanceClass'
         attribute :vpc, :aliases => 'Vpc', :type => :boolean
+        attribute :supports_iops, :aliases => 'SupportsIops', :type => :boolean
+        attribute :supports_enhanced_monitoring, :aliases => 'SupportsEnhancedMonitoring', :type => :boolean
+        attribute :supports_iam_database_authentication, :aliases => 'SupportsIAMDatabaseAuthentication', :type => :boolean
+        attribute :supports_performance_insights, :aliases => 'SupportsPerformanceInsights', :type => :boolean
+        attribute :supports_storage_encryption, :aliases => 'SupportsStorageEncryption', :type => :boolean
+        attribute :storage_type, :aliases => 'StorageType'
       end
     end
   end

data/lib/fog/aws/parsers/compute/create_subnet.rb

@@ -32,6 +32,8 @@ module Fog
               case name
               when 'subnetId', 'state', 'vpcId', 'cidrBlock', 'availableIpAddressCount', 'availabilityZone'
                 @subnet[name] = value
+              when 'mapPublicIpOnLaunch', 'defaultForAz'
+                @subnet[name] = value == 'true' ? true : false
               when 'subnet'
                 @response['subnet'] = @subnet
               when 'requestId'

data/lib/fog/aws/parsers/compute/describe_subnets.rb

@@ -32,7 +32,7 @@ module Fog
               case name
               when 'subnetId', 'state', 'vpcId', 'cidrBlock', 'availableIpAddressCount', 'availabilityZone'
                 @subnet[name] = value
-              when 'mapPublicIpOnLaunch'
+              when 'mapPublicIpOnLaunch', 'defaultForAz'
                 @subnet[name] = value == 'true' ? true : false
               when 'item'
                 @response['subnetSet'] << @subnet

data/lib/fog/aws/parsers/compute/describe_vpcs.rb

@@ -4,55 +4,89 @@ module Fog
       module AWS
         class DescribeVpcs < Fog::Parsers::Base
           def reset
-            @vpc = { 'tagSet' => {}, 'ipv6CidrBlockAssociationSet' => {} }
             @response = { 'vpcSet' => [] }
-            @tag = {}
+            @context = []
           end
 
           def start_element(name, attrs = [])
             super
-            case name
-            when 'tagSet'
-              @in_tag_set = true
-            when 'ipv6CidrBlockAssociationSet'
-              @in_ipv6_set = true
+            @context.push(name)
+
+            case @context[1 .. -1].join('.')
+              when 'vpcSet.item'
+                @current_vpc = { 'tagSet' => {}, 'cidrBlockAssociationSet' => [], 'ipv6CidrBlockAssociationSet' => [] }
+
+              when 'vpcSet.item.tagSet.item'
+                @current_tag_key = @current_tag_value = nil
+
+              when 'vpcSet.item.cidrBlockAssociationSet.item'
+                @current_cidr_block = {}
+
+              when 'vpcSet.item.ipv6CidrBlockAssociationSet.item'
+                @current_ipv6_block = {}
             end
           end
 
           def end_element(name)
-            if @in_tag_set
-              case name
-                when 'item'
-                  @vpc['tagSet'][@tag['key']] = @tag['value']
-                  @tag = {}
-                when 'key', 'value'
-                  @tag[name] = value
-                when 'tagSet'
-                  @in_tag_set = false
-              end
-            elsif @in_ipv6_set
-              case name
-              when 'ipv6CidrBlock', 'associationId'
-                @vpc['ipv6CidrBlockAssociationSet'][name] = value
-              when 'ipv6CidrBlockState'
-                @vpc['ipv6CidrBlockAssociationSet'][name] = {'State' => value.squish}
-              when 'ipv6CidrBlockAssociationSet'
-                @vpc['amazonProvidedIpv6CidrBlock'] = !value.blank?
-                @in_ipv6_set = false
-              end
-            else
-              case name
-              when 'vpcId', 'state', 'cidrBlock', 'dhcpOptionsId', 'instanceTenancy'
-                @vpc[name] = value
-              when 'isDefault'
-                @vpc['isDefault'] = value == 'true'        
-              when 'item'
-                @response['vpcSet'] << @vpc
-                @vpc = { 'tagSet' => {}, 'ipv6CidrBlockAssociationSet' => {} }
+            case @context[1 .. -1].join('.')
+              # tagSet
+
+              when 'vpcSet.item.tagSet.item'
+                @current_vpc['tagSet'][@current_tag_key] = @current_tag_value
+                @current_tag_key = @current_tag_value = nil
+
+              when 'vpcSet.item.tagSet.item.key'
+                @current_tag_key = value
+
+              when 'vpcSet.item.tagSet.item.value'
+                @current_tag_value = value
+
+              # cidrBlockAssociationSet
+
+              when 'vpcSet.item.cidrBlockAssociationSet.item.cidrBlock',
+                   'vpcSet.item.cidrBlockAssociationSet.item.associationId'
+                @current_cidr_block[name] = value
+
+              when 'vpcSet.item.cidrBlockAssociationSet.item.cidrBlockState'
+                @current_cidr_block['state'] = value.strip
+
+              when 'vpcSet.item.cidrBlockAssociationSet.item'
+                @current_vpc['cidrBlockAssociationSet'] << @current_cidr_block
+
+              # ipv6CidrBlockAssociationSet
+
+              when 'vpcSet.item.ipv6CidrBlockAssociationSet.item.ipv6CidrBlock',
+                   'vpcSet.item.ipv6CidrBlockAssociationSet.item.associationId'
+                @current_ipv6_block[name] = value
+
+              when 'vpcSet.item.ipv6CidrBlockAssociationSet.item.ipv6CidrBlockState'
+                @current_ipv6_block['state'] = value.strip
+
+              when 'vpcSet.item.ipv6CidrBlockAssociationSet.item'
+                @current_vpc['ipv6CidrBlockAssociationSet'] << @current_ipv6_block
+
+              # vpc
+
+              when 'vpcSet.item.vpcId',
+                   'vpcSet.item.state',
+                   'vpcSet.item.cidrBlock',
+                   'vpcSet.item.dhcpOptionsId',
+                   'vpcSet.item.instanceTenancy'
+                @current_vpc[name] = value
+
+              when 'vpcSet.item.isDefault'
+                @current_vpc['isDefault'] = value == 'true'
+
+              when 'vpcSet.item'
+                @response['vpcSet'] << @current_vpc
+
+              # root
+
               when 'requestId'
                 @response[name] = value
-              end
             end
+
+            @context.pop
           end
         end
       end

data/lib/fog/aws/parsers/iam/list_access_keys.rb

@@ -10,7 +10,7 @@ module Fog
 
           def end_element(name)
             case name
-            when 'AccessKeyId', 'Status', 'Username'
+            when 'AccessKeyId', 'Status', 'UserName'
               @access_key[name] = value
             when 'member'
               @response['AccessKeys'] << @access_key

data/lib/fog/aws/parsers/rds/describe_orderable_db_instance_options.rb

@@ -19,12 +19,13 @@ module Fog
 
           def end_element(name)
             case name
-            when 'MultiAZCapable', 'ReadReplicaCapable', 'Vpc' then @db_instance_option[name] = to_boolean(value)
-            when 'Engine', 'LicenseModel', 'EngineVersion', 'DBInstanceClass' then @db_instance_option[name] = value
+            when 'MultiAZCapable', 'ReadReplicaCapable', 'Vpc', 'SupportsIops',
+                 'SupportsEnhancedMonitoring', 'SupportsIAMDatabaseAuthentication',
+                 'SupportsPerformanceInsights', 'SupportsStorageEncryption' then @db_instance_option[name] = to_boolean(value)
+            when 'Engine', 'LicenseModel', 'EngineVersion', 'DBInstanceClass', 'StorageType' then @db_instance_option[name] = value
             when 'AvailabilityZones' then @db_instance_option[name] = @availability_zones
             when 'AvailabilityZone' then @availability_zones << @availability_zone unless @availability_zone.empty?
             when 'Name' then @availability_zone[name] = value
-            when 'ProvisionedIopsCapable' then @availability_zone[name] = to_boolean(value)
             when 'OrderableDBInstanceOption'
               @db_instance_options << @db_instance_option
               @db_instance_option = {}

data/lib/fog/aws/requests/auto_scaling/detach_instances.rb

@@ -13,9 +13,7 @@ module Fog
         #
         #   * AutoScalingGroupName<~String> - The name of the Auto Scaling group``
         #   * 'InstanceIds'<~Array> - The list of Auto Scaling instances to detach.
-        #
-        # * options<~Hash>:
-        # 'shouldDecrementDesiredCapacity'<~Boolean> - decrement the asg capacity or not (it will boot another if an instance id detached)
+        #   * ShouldDecrementDesiredCapacity<~Boolean> - decrement the asg capacity or not (it will boot another if an instance id detached)
         #
         # ==== See Also
         #
@@ -23,6 +21,7 @@ module Fog
 
         ExpectedOptions[:asg_name] = %w[AutoScalingGroupName]
         ExpectedOptions[:instance_ids] = %w[InstanceIds]
+        ExpectedOptions[:should_decrement_desired_capacity] = %w[ShouldDecrementDesiredCapacity]
 
         def detach_instances(auto_scaling_group_name, options = {})
 
@@ -46,7 +45,7 @@ module Fog
 
       class Mock
         def detach_instances(auto_scaling_group_name, options = {})
-          unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids]
+          unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids] - ExpectedOptions[:should_decrement_desired_capacity]
 
           unless unexpected_options.empty?
             raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")

data/lib/fog/aws/requests/compute/authorize_security_group_egress.rb

@@ -57,14 +57,16 @@ module Fog
       class Mock
         def authorize_security_group_egress(group_name, options = {})
           options = Fog::AWS.parse_security_group_options(group_name, options)
-          if options.key?('GroupName')
-            group_name = options['GroupName']
-          else
-            group_name = self.data[:security_groups].reject { |k,v| v['groupId'] != options['GroupId'] } .keys.first
-          end
+
+          group = if options.key?('GroupName')
+                    self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
+                  else
+                    self.data[:security_groups][options.fetch('GroupId')]
+                  end
 
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name] || raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
+          group ||
+            raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
 
           verify_permission_options(options, group['vpcId'] != nil)
 

data/lib/fog/aws/requests/compute/authorize_security_group_ingress.rb

@@ -80,14 +80,16 @@ module Fog
       class Mock
         def authorize_security_group_ingress(group_name, options = {})
           options = Fog::AWS.parse_security_group_options(group_name, options)
-          if options.key?('GroupName')
-            group_name = options['GroupName']
-          else
-            group_name = self.data[:security_groups].reject { |k,v| v['groupId'] != options['GroupId'] } .keys.first
-          end
+
+          group = if options.key?('GroupName')
+                    self.data[:security_groups].values.find { |v| v['groupName'] == options['GroupName'] }
+                  else
+                    self.data[:security_groups][options.fetch('GroupId')]
+                  end
 
           response = Excon::Response.new
-          group = self.data[:security_groups][group_name] || raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
+          group ||
+            raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist"))
 
           verify_permission_options(options, group['vpcId'] != nil)
 
@@ -150,14 +152,15 @@ module Fog
                          else
                            options['SourceSecurityGroupName']
                          end
-            source_group_id=self.data[:security_groups][group_name]['groupId']
+            source_group_id, _ = self.data[:security_groups].find { |_,v| v['groupName'] == group_name }
+
             ['tcp', 'udp'].each do |protocol|
               normalized_permissions << {
                 'ipProtocol' => protocol,
                 'fromPort'   => 1,
                 'toPort'     => 65535,
                 'groups'     => [{
-                  'groupName' => options['SourceSecurityGroupName'],
+                  'groupName' => group_name,
                   'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
                   'groupId'   => source_group_id
                 }],
@@ -169,7 +172,7 @@ module Fog
               'fromPort'   => -1,
               'toPort'     => -1,
               'groups'     => [{
-                'groupName' => options['SourceSecurityGroupName'],
+                'groupName' => group_name,
                 'userId'    => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id],
                 'groupId'   => source_group_id
               }],
@@ -188,18 +191,19 @@ module Fog
 
               groups = (permission['Groups'] || []).map do |authorized_group|
                 security_group = if group_name = authorized_group['GroupName']
-                                   self.data[:security_groups][group_name]
+                                   self.data[:security_groups].values.find { |sg| sg['groupName'] == group_name }
                                  elsif group_id = authorized_group['GroupId']
-                                   self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id }
-                                 end ||
-                                 raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
-
-                                 {
-                                   'groupName' => authorized_group['GroupName'] || security_group["groupName"],
-                                   'userId'    => authorized_group['UserId']    || self.data[:owner_id],
-                                   'groupId'   => authorized_group["GroupId"]   || security_group['groupId']
-                                 }
-                  end
+                                   self.data[:security_groups][group_id]
+                                 end
+                security_group ||
+                  raise(Fog::Compute::AWS::NotFound.new("The security group '#{group_name || group_id}' does not exist"))
+
+                {
+                  'groupName' => authorized_group['GroupName'] || security_group['groupName'],
+                  'userId'    => authorized_group['UserId']    || self.data[:owner_id],
+                  'groupId'   => authorized_group["GroupId"]   || security_group['groupId']
+                }
+              end
 
 
               if ['tcp', 'udp', 'icmp'].include?(permission['IpProtocol'])
@@ -208,7 +212,7 @@ module Fog
                   'fromPort'   => Integer(permission['FromPort']),
                   'toPort'     => Integer(permission['ToPort']),
                   'groups'     => groups,
-                  'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
+                  'ipRanges'   => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
                 }
               else
                 normalized_permissions << {

data/lib/fog/aws/requests/compute/copy_snapshot.rb

@@ -9,6 +9,11 @@ module Fog
         # ==== Parameters
         # * source_snapshot_id<~String> - Id of snapshot
         # * source_region<~String>      - Region to move it from
+        # * options<~Hash>:
+        #   * 'Description'<~String>    - A description for the EBS snapshot
+        #   * 'Encrypted'<~Boolean>     - Specifies whether the destination snapshot should be encrypted
+        #   * 'KmsKeyId'<~String>       - The full ARN of the AWS Key Management Service (AWS KMS) CMK
+        #                                 to use when creating the snapshot copy.
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -17,14 +22,22 @@ module Fog
         #     * 'snapshotId'<~String> - id of snapshot
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CopySnapshot.html]
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
-          request(
-            'Action'          => 'CopySnapshot',
-            'SourceSnapshotId'=> source_snapshot_id,
-            'SourceRegion'    => source_region,
-            'Description'     => description,
-            :parser       => Fog::Parsers::Compute::AWS::CopySnapshot.new
-          )
+        def copy_snapshot(source_snapshot_id, source_region, options = {})
+          # For backward compatibility. In previous versions third param was a description
+          if options.is_a?(String)
+            Fog::Logger.warning("copy_snapshot with description as a string in third param is deprecated, use hash instead: copy_snapshot('source-id', 'source-region', { 'Description' => 'some description' })")
+            options = { 'Description' => options }
+          end
+          params              = {
+            'Action'           => 'CopySnapshot',
+            'SourceSnapshotId' => source_snapshot_id,
+            'SourceRegion'     => source_region,
+            'Description'      => options['Description'],
+            :parser            => Fog::Parsers::Compute::AWS::CopySnapshot.new
+          }
+          params['Encrypted'] = true if options['Encrypted']
+          params['KmsKeyId']  = options['KmsKeyId'] if options['Encrypted'] && options['KmsKeyId']
+          request(params)
         end
       end
 
@@ -35,7 +48,7 @@ module Fog
         # Fog::AWS[:compute].copy_snapshot("snap-1db0a957", 'us-east-1')
         #
 
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
+        def copy_snapshot(source_snapshot_id, source_region, options = {})
           response = Excon::Response.new
           response.status = 200
           snapshot_id = Fog::AWS::Mock.snapshot_id

data/lib/fog/aws/requests/compute/create_network_interface.rb

@@ -73,11 +73,11 @@ module Fog
               groups = {}
               if options['GroupSet']
                 options['GroupSet'].each do |group_id|
-                  group_obj = self.data[:security_groups].select { |k,v| v['groupId'] == group_id }.first
+                  group_obj = self.data[:security_groups][group_id]
                   if group_obj.nil?
                     raise Fog::Compute::AWS::Error.new("Unknown security group '#{group_id}' specified")
                   end
-                  groups[group_id] = group_obj
+                  groups[group_id] = group_obj['groupName']
                 end
               end
 

data/lib/fog/aws/requests/compute/create_route_table.rb

@@ -39,7 +39,7 @@ module Fog
           unless vpc.nil?
             response.status = 200
             route_table = {
-              'routeTableId' => "rtb-#{Fog::Mock.random_hex(8)}",
+              'routeTableId' => Fog::AWS::Mock.route_table_id,
               'vpcId' => vpc["vpcId"],
               'routeSet' => [{
                 "destinationCidrBlock" => vpc["cidrBlock"],

data/lib/fog/aws/requests/compute/create_security_group.rb

@@ -33,26 +33,31 @@ module Fog
       class Mock
         def create_security_group(name, description, vpc_id=nil)
           response = Excon::Response.new
-          unless self.data[:security_groups][name]
-            data = {
-              'groupDescription'    => description,
-              'groupName'           => name,
-              'groupId'             => Fog::AWS::Mock.security_group_id,
-              'ipPermissionsEgress' => [],
-              'ipPermissions'       => [],
-              'ownerId'             => self.data[:owner_id],
-              'vpcId'               => vpc_id
-            }
-            self.data[:security_groups][name] = data
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'groupId'   => data['groupId'],
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::Error.new("InvalidGroup.Duplicate => The security group '#{name}' already exists")
+
+          vpc_id ||= Fog::AWS::Mock.default_vpc_for(region)
+          group_id = Fog::AWS::Mock.security_group_id
+
+          if self.data[:security_groups].find { |_,v| v['groupName'] == name }
+            raise Fog::Compute::AWS::Error,
+              "InvalidGroup.Duplicate => The security group '#{name}' already exists"
           end
+
+          self.data[:security_groups][group_id] = {
+            'groupDescription'    => description,
+            'groupName'           => name,
+            'groupId'             => group_id,
+            'ipPermissionsEgress' => [],
+            'ipPermissions'       => [],
+            'ownerId'             => self.data[:owner_id],
+            'vpcId'               => vpc_id
+          }
+
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'groupId'   => group_id,
+            'return'    => true
+          }
+          response
         end
       end
     end