fog-aws 3.3.0 → 3.4.0

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

@@ -23,7 +23,15 @@ module Fog
         attr_accessor :storage_encrypted #not in the response
 
         def ready?
-          state == "available"
+          # [2019.01] I don't think this is going to work, at least not with Aurora
+          # clusters. In my testing, the state reported by Fog for an Aurora cluster
+          # is "active" as soon as the cluster is retrievable from AWS, and the
+          # value doesn't change after that. Contrast that with the AWS Console UI,
+          # which reports the cluster as "Creating" while it's being created. I don't
+          # know where Fog is getting the state value from, but I don't think it's
+          # correct, at least not for the purpose of knowing if the Cluster is ready
+          # to have individual instances added to it.
+          state == 'available' || state == 'active'
         end
 
         def snapshots

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

@@ -118,14 +118,14 @@ module Fog
           else
             requires :engine
 
-            if engine == 'aurora'
+            if engine.start_with?('aurora')
               requires :cluster_id
-              self.flavor_id ||= 'db.r3.large'
+              self.flavor_id ||= 'db.r4.large'
             else
               requires :master_username
               requires :password
               requires :allocated_storage
-              self.flavor_id ||= 'db.m1.small'
+              self.flavor_id ||= 'db.m4.large'
             end
 
             data = service.create_db_instance(id, attributes_to_params)

data/lib/fog/aws/models/storage/directory.rb

@@ -30,6 +30,30 @@ module Fog
           false
         end
 
+        # @param options [Hash] (defaults to: {}) — a customizable set of options.
+        #   Consider tuning this values for big buckets.
+        # @option options timeout [Integer] — default: Fog.timeout — Maximum number of
+        #   seconds to wait for the bucket to be empty.
+        # @option options interval [Proc|Integer] — default: Fog.interval — Seconds to wait before
+        #   retrying to check if the bucket is empty.
+        def destroy!(options = {})
+          requires :key
+          options = {
+            timeout: Fog.timeout,
+            interval: Fog.interval,
+          }.merge(options)
+
+          attempts = 0
+          begin
+            clear!
+            Fog.wait_for(options[:timeout], options[:interval]) { objects_keys.size == 0 }
+            service.delete_bucket(key)
+            true
+          rescue Excon::Errors::HTTPStatusError
+            false
+          end
+        end
+
         def location
           @location ||= (bucket_location || Storage::DEFAULT_REGION)
         end
@@ -119,6 +143,17 @@ module Fog
           data = service.get_bucket_location(key)
           data.body['LocationConstraint']
         end
+
+        def objects_keys
+          requires :key
+          bucket_query = service.get_bucket(key)
+          bucket_query.body["Contents"].map {|c| c["Key"]}
+        end
+
+        def clear!
+          requires :key
+          service.delete_multiple_objects(key, objects_keys) if objects_keys.size > 0
+        end
       end
     end
   end

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

@@ -4,19 +4,40 @@ module Fog
       module Compute
         class DescribeAddresses < Fog::Parsers::Base
           def reset
-            @address = {}
             @response = { 'addressesSet' => [] }
+            @address = {'tagSet' => {}}
+            @tag = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+            if name == 'tagSet'
+              @in_tag_set = true
+            end
           end
 
           def end_element(name)
-            case name
-            when 'instanceId', 'publicIp', 'domain', 'allocationId', 'associationId', 'networkInterfaceId', 'networkInterfaceOwnerId', 'privateIpAddress'
-              @address[name] = value
-            when 'item'
-              @response['addressesSet'] << @address
-              @address = {}
-            when 'requestId'
-              @response[name] = value
+            if @in_tag_set
+              case name
+              when 'item'
+                @address['tagSet'][@tag['key']] = @tag['value']
+                @tag = {}
+              when 'key', 'value'
+                @tag[name] = value
+              when 'tagSet'
+                @in_tag_set = false
+              end
+            else
+              case name
+              when 'instanceId', 'publicIp', 'domain', 'allocationId', 'associationId', 'networkInterfaceId', 'networkInterfaceOwnerId', 'privateIpAddress'
+                @address[name] = value
+              when 'item'
+                @response['addressesSet'] << @address
+                @address = { 'tagSet' => {} }
+              when 'requestId'
+                @response[name] = value
+              end
+
             end
           end
         end

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

@@ -0,0 +1,122 @@
+module Fog
+  module Parsers
+    module AWS
+      module Compute
+        class DescribeImageAttribute < Fog::Parsers::Base
+          def reset
+            @response                             = { }
+            @in_description                       = false
+            @in_kernelId                          = false
+            @in_ramdiskId                         = false
+            @in_launchPermission                  = false
+            @in_productCodes                      = false
+            @in_blockDeviceMapping                = false
+            @in_sriovNetSupport                   = false
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'description'
+              @in_description = true
+            when 'kernel'
+              @in_kernel = true
+            when 'ramdisk'
+              @in_ramdisk = true
+            when 'launchPermission'
+              @in_launchPermission= true
+              unless @response.key?('launchPermission')
+                @response['launchPermission'] = []
+              end
+            when 'productCodes'
+              @in_productCodes = true
+              @product_codes = {}
+              unless @response.key?('productCodes')
+                @response['productCodes'] = []
+              end
+            when 'blockDeviceMapping'
+              @in_blockDeviceMapping = true
+              @block_device_mapping = {}
+              unless @response.key?('blockDeviceMapping')
+                @response['blockDeviceMapping'] = []
+              end
+            when 'sriovNetSupport'
+              unless @response.key?('sriovNetSupport')
+                @response['sriovNetSupport'] = 'false'
+              end
+              @in_sriovNetSupport = true
+            end
+          end
+
+          def end_element(name)
+            if @in_description
+              case name
+              when 'value'
+                @response['description'] = value
+              when 'description'
+                @in_description= false
+              end
+            elsif @in_kernel
+              case name
+              when 'value'
+                @response['kernelId'] = value
+              when 'kernel'
+                @in_kernelId = false
+              end
+            elsif @in_ramdisk
+              case name
+              when 'value'
+                @response['ramdiskId'] = value
+              when 'ramdisk'
+                @in_ramdiskId = false
+              end
+            elsif @in_launchPermission
+              case name
+              when 'group', 'userId'
+                @response['launchPermission'] << value
+              when 'launchPermission'
+                @in_launchPermission = false
+              end
+            elsif @in_blockDeviceMapping
+              case name
+              when 'item'
+                @response["blockDeviceMapping"] << @block_device_mapping
+                @block_device_mapping = {}
+              when 'volumeId', 'status', 'deviceName'
+                @block_device_mapping[name] = value
+              when 'attachTime'
+                @block_device_mapping['attachTime'] = Time.parse(value)
+              when 'deleteOnTermination'
+                @block_device_mapping['deleteOnTermination'] = (value == 'true')
+              when 'blockDeviceMapping'
+                @in_blockDeviceMapping = false
+              end
+            elsif @in_productCodes
+              case name
+              when 'item'
+                @response['productCodes'] << @product_codes
+                @product_codes = {}
+              when 'productCode', 'type'
+                @product_codes[name] = value
+              when 'productCodes'
+                @in_productCodes = false
+              end
+            elsif @in_sriovNetSupport
+              case name
+              when 'value'
+                @response["sriovNetSupport"] = value
+              when "sriovNetSupport"
+                @in_sriovNetSupport = false
+              end
+            else
+              case name
+              when 'requestId', 'imageId'
+                @response[name] = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -97,7 +97,7 @@ module Fog
                   @response['securityGroupInfo'] << @security_group
                   @security_group = { 'ipPermissions' => [], 'ipPermissionsEgress' => [], 'tagSet' => {} }
                 end
-              when 'requestId'
+              when 'requestId', 'nextToken'
                 @response[name] = value
               when 'userId'
                 @group[name] = value

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

@@ -0,0 +1,74 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+        require 'fog/aws/parsers/compute/describe_image_attribute'
+        # Describes an image attribute value
+        #
+        # ==== Parameters
+        # * image_id<~String>    - The ID of the image you want to describe an attribute of
+        # * attribute<~String> - The attribute to describe, must be one of the following:
+        #    -'description'
+        #    -'kernel'
+        #    -'ramdisk'
+        #    -'launchPermission'
+        #    -'productCodes'
+        #    -'blockDeviceMapping'
+        #    -'sriovNetSupport'
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String>                - Id of request
+        # * 'description'<~String>           - The description for the AMI
+        # * 'imageId'<~String>               - The ID of the image
+        # * 'kernelId'<~String>                 - The kernel ID
+        # * 'ramdiskId'<~String>                - The RAM disk ID
+        # * 'blockDeviceMapping'<~List>        - The block device mapping of the image
+        # * 'productCodes'<~List>               - A list of product codes
+        # * 'sriovNetSupport'<~String>          - The value to use for a resource attribute
+        # (Amazon API Reference)[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImageAttribute.html]
+        def describe_image_attribute(image_id, attribute)
+          request(
+            'Action'       => 'DescribeImageAttribute',
+            'ImageId'   => image_id,
+            'Attribute'    => attribute,
+            :parser        => Fog::Parsers::AWS::Compute::DescribeImageAttribute.new
+          )
+        end
+      end
+
+      class Mock
+        def describe_image_attribute(image_id, attribute)
+          response = Excon::Response.new
+          if image = self.data[:images].values.find{ |i| i['imageId'] == image_id }
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId'     => image_id
+            }
+            case attribute
+            when 'kernel'
+              response.body[attribute] = image["kernelId"]
+            when 'ramdisk'
+              response.body[attribute] = image["ramdiskId"]
+            when 'sriovNetSupport'
+              response.body[attribute] = 'simple'
+            when 'launchPermission'
+              if image_launch_permissions = self.data[:image_launch_permissions][image_id]
+                response.body[attribute] = image_launch_permissions[:users]
+              else
+                response.body[attribute] = []
+              end
+            else
+              response.body[attribute] = image[attribute]
+            end
+          response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The Image '#{image_id}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,8 @@ module Fog
         #
         # ==== Parameters
         # * filters<~Hash> - List of filters to limit results with
+        #   * 'MaxResults'<~Integer> - The maximum number of results to return for the request in a single page
+        #   * 'NextToken'<~String> - The token to retrieve the next page of results
         #
         # === Returns
         # * response<~Excon::Response>:
@@ -27,6 +29,7 @@ module Fog
         #           * 'cidrIp'<~String> - CIDR range
         #         * 'toPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
         #       * 'ownerId'<~String> - AWS Access Key Id of the owner of the security group
+        #     * 'NextToken'<~String> - The token to retrieve the next page of results
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSecurityGroups.html]
         def describe_security_groups(filters = {})
@@ -34,7 +37,15 @@ module Fog
             Fog::Logger.deprecation("describe_security_groups with #{filters.class} param is deprecated, use describe_security_groups('group-name' => []) instead [light_black](#{caller.first})[/]")
             filters = {'group-name' => [*filters]}
           end
-          params = Fog::AWS.indexed_filters(filters)
+
+          options = {}
+          for key in %w[MaxResults NextToken]
+            if filters.is_a?(Hash) && filters.key?(key)
+              options[key] = filters.delete(key)
+            end
+          end
+
+          params = Fog::AWS.indexed_filters(filters).merge!(options)
           request({
             'Action'    => 'DescribeSecurityGroups',
             :idempotent => true,

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

@@ -0,0 +1,33 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # Modify instance placement
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to modify
+        # * attributes<~Hash>:
+        #   'Affinity.Value'<~String> - The affinity setting for the instance, in ['default', 'host']
+        #   'GroupName.Value'<~String> - The name of the placement group in which to place the instance
+        #   'HostId.Value'<~String> - The ID of the Dedicated Host with which to associate the instance
+        #   'Tenancy.Value'<~String> - The tenancy for the instance, in ['dedicated', 'host']
+        #
+        # {Amazon API Reference}[https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstancePlacement.html]
+        #
+        def modify_instance_placement(instance_id, attributes)
+          params = {}
+          params.merge!(attributes)
+          request({
+            'Action'        => 'ModifyInstancePlacement',
+            'InstanceId'    => instance_id,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/dns/change_resource_record_sets.rb

@@ -194,7 +194,7 @@ module Fog
         #     change_resource_record_sets("ABCDEFGHIJKLMN", change_batch_options)
         #
         def change_resource_record_sets(zone_id, change_batch, options = {})
-          body = AWS.change_resource_record_sets_data(zone_id, change_batch, @version, options)
+          body = Fog::AWS::DNS.change_resource_record_sets_data(zone_id, change_batch, @version, options)
           request({
             :body       => body,
             :idempotent => true,

data/lib/fog/aws/requests/dynamodb/update_item.rb

@@ -7,15 +7,15 @@ module Fog
         #
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
-        # * 'key'<~Hash> - list of elements to be updated and their value
+        # * 'key'<~Hash> - list of Key attributes
         #   {
         #     "ForumName": {"S": "Amazon DynamoDB"},
         #     "Subject": {"S": "Maximum number of items?"}
         #   }
         #
         # * 'options'<~Hash>:
-        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
-        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
+        #   * 'UpdateExpression'<~String> - the expression that will update the item
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the update expression
         #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
         #
         # ==== Returns
@@ -29,13 +29,14 @@ module Fog
           if deprecated_attribute_updates
             raise DeprecatedAttributeUpdates, "The `20111205` DynamoDB API is deprecated. You need to use `ExpressionAttributeValues` instead of `AttributeUpdates`."
             attribute_updates = options
-            options = deprecated_attribute_updates
+            options = deprecated_attribute_updates.merge(
+              'AttributeUpdates'  => attribute_updates,
+            )
           end
 
           body = {
             'Key'               => key,
             'TableName'         => table_name,
-            'AttributeUpdates'  => attribute_updates,
           }.merge(options)
 
           request(