gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/aws/requests/elb/create_app_cookie_stickiness_policy.rb

@@ -35,8 +35,6 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
-
             create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
 
             response.body = {

data/lib/fog/aws/requests/elb/create_lb_cookie_stickiness_policy.rb

@@ -37,8 +37,6 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'CookieExpirationPeriod' => cookie_expiration_period, 'PolicyName' => policy_name }
-
             create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
 
             response.body = {

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -74,6 +74,7 @@ module Fog
 
           dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
 
+
           Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups]['amazon-elb-sg'] ||= {
             'groupDescription'   => 'amazon-elb-sg',
             'groupName'          => 'amazon-elb-sg',
@@ -85,6 +86,11 @@ module Fog
 
           self.data[:load_balancers][lb_name] = {
             'AvailabilityZones' => availability_zones,
+            'BackendServerDescriptions' => [],
+            # Hack to facilitate not updating the local data structure
+            # (BackendServerDescriptions) until we do a subsequent
+            # describe as that is how AWS behaves.
+            'BackendServerDescriptionsRemote' => [],
             'Subnets' => options[:subnet_ids] || [],
             'Scheme' => options[:scheme].nil? ? 'internet-facing' : options[:scheme],
             'SecurityGroups' => options[:security_groups].nil? ? [] : options[:security_groups],
@@ -105,6 +111,7 @@ module Fog
             'Policies' => {
               'AppCookieStickinessPolicies' => [],
               'LBCookieStickinessPolicies' => [],
+              'OtherPolicies' => [],
               'Proper' => []
             },
             'SourceSecurityGroup' => {

data/lib/fog/aws/requests/elb/create_load_balancer_policy.rb

@@ -33,12 +33,12 @@ module Fog
           params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeValue', attribute_value))
 
           request({
-            'Action'           => 'CreateLoadBalancerPolicy',
-            'LoadBalancerName' => lb_name,
-            'PolicyName'       => name,
-            'PolicyTypeName'   => type_name,
-            :parser            => Fog::Parsers::AWS::ELB::Empty.new
-          }.merge!(params))
+                    'Action'           => 'CreateLoadBalancerPolicy',
+                    'LoadBalancerName' => lb_name,
+                    'PolicyName'       => name,
+                    'PolicyTypeName'   => type_name,
+                    :parser            => Fog::Parsers::AWS::ELB::Empty.new
+                  }.merge!(params))
         end
 
       end
@@ -46,12 +46,15 @@ module Fog
       class Mock
         def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
           if load_balancer = self.data[:load_balancers][lb_name]
-            raise Fog::AWS::IAM::DuplicatePolicyName if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
-            raise Fog::AWS::IAM::PolicyTypeNotFound unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
+            raise Fog::AWS::ELB::DuplicatePolicyName, name if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
+            raise Fog::AWS::ELB::PolicyTypeNotFound, type_name unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
 
             response = Excon::Response.new
 
             attributes = attributes.map do |key, value|
+              if key == "CookieExpirationPeriod" && !value
+                value = 0
+              end
               {"AttributeName" => key, "AttributeValue" => value.to_s}
             end
 

data/lib/fog/aws/requests/elb/describe_load_balancers.rb

@@ -20,6 +20,9 @@ module Fog
         #     * 'DescribeLoadBalancersResult'<~Hash>:
         #       * 'LoadBalancerDescriptions'<~Array>
         #         * 'AvailabilityZones'<~Array> - list of availability zones covered by this load balancer
+        #         * 'BackendServerDescriptions'<~Array>:
+        #           * 'InstancePort'<~Integer> - the port on which the back-end server is listening
+        #           * 'PolicyNames'<~Array> - list of policy names enabled for the back-end server
         #         * 'CanonicalHostedZoneName'<~String> - name of the Route 53 hosted zone associated with the load balancer
         #         * 'CanonicalHostedZoneNameID'<~String> - ID of the Route 53 hosted zone associated with the load balancer
         #         * 'CreatedTime'<~Time> - time load balancer was created
@@ -41,6 +44,7 @@ module Fog
         #         * 'Policies'<~Hash>:
         #           * 'LBCookieStickinessPolicies'<~Array> - list of Load Balancer Generated Cookie Stickiness policies for the LoadBalancer
         #           * 'AppCookieStickinessPolicies'<~Array> - list of Application Generated Cookie Stickiness policies for the LoadBalancer
+        #           * 'OtherPolicies'<~Array> - list of policy names other than the stickiness policies
         #         * 'SourceSecurityGroup'<~Hash>:
         #           * 'GroupName'<~String> - Name of the source security group to use with inbound security group rules
         #           * 'OwnerAlias'<~String> - Owner of the source security group
@@ -101,7 +105,23 @@ module Fog
             'DescribeLoadBalancersResult' => {
               'LoadBalancerDescriptions' => load_balancers.map do |lb|
                 lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }
-                lb['Policies'] = lb['Policies'].reject { |name, policies| name == 'Proper' }
+                lb['Policies'] = lb['Policies']['Proper'].inject({'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => [], 'OtherPolicies' => []}) { |m, policy|
+                  case policy['PolicyTypeName']
+                  when 'AppCookieStickinessPolicyType'
+                    cookie_name = policy['PolicyAttributeDescriptions'].detect{|h| h['AttributeName'] == 'CookieName'}['AttributeValue']
+                    m['AppCookieStickinessPolicies'] << { 'PolicyName' => policy['PolicyName'], 'CookieName' => cookie_name }
+                  when 'LBCookieStickinessPolicyType'
+                    cookie_expiration_period = policy['PolicyAttributeDescriptions'].detect{|h| h['AttributeName'] == 'CookieExpirationPeriod'}['AttributeValue'].to_i
+                    lb_policy = { 'PolicyName' => policy['PolicyName'] }
+                    lb_policy['CookieExpirationPeriod'] = cookie_expiration_period if cookie_expiration_period > 0
+                    m['LBCookieStickinessPolicies'] << lb_policy
+                  else
+                    m['OtherPolicies'] << policy['PolicyName']
+                  end
+                  m
+                }
+
+                lb['BackendServerDescriptions'] = lb.delete('BackendServerDescriptionsRemote')
                 lb
               end
             }

data/lib/fog/aws/requests/elb/set_load_balancer_policies_for_backend_server.rb

@@ -0,0 +1,67 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+        # Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies.
+        # After the policies have been created using CreateLoadBalancerPolicy, they can be applied here as a list.
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * instance_port<~Integer> - The port on the instance that the ELB will forward traffic to
+        # * policy_names<~Array> - Array of Strings listing the policies to set for the backend port
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def set_load_balancer_policies_for_backend_server(lb_name, instance_port, policy_names)
+          params = {'InstancePort' => instance_port}
+          if policy_names.any?
+            params.merge!(Fog::AWS.indexed_param('PolicyNames.member', policy_names))
+          else
+            params['PolicyNames'] = ''
+          end
+
+          request({ 'Action' => 'SetLoadBalancerPoliciesForBackendServer',
+                    'LoadBalancerName' => lb_name,
+                    :parser => Fog::Parsers::AWS::ELB::Empty.new
+                  }.merge!(params))
+        end
+      end
+
+      class Mock
+        def set_load_balancer_policies_for_backend_server(lb_name, instance_port, policy_names)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            # Ensure policies exist
+            policy_names.each do |policy_name|
+              unless load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == policy_name }
+                raise Fog::AWS::ELB::PolicyNotFound, "There is no policy with name #{policy_name} for load balancer #{lb_name}"
+              end
+            end
+
+            # Update backend policies:
+            description = load_balancer['BackendServerDescriptionsRemote'].find{|d| d["InstancePort"] == instance_port } || {}
+            description["InstancePort"] = instance_port
+            description["PolicyNames"] = policy_names
+            load_balancer['BackendServerDescriptionsRemote'].delete_if{|d| d["InstancePort"] == instance_port }
+            load_balancer['BackendServerDescriptionsRemote'] << description
+
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.body = {
+                'ResponseMetadata' => {
+                  'RequestId' => Fog::AWS::Mock.request_id
+                }
+              }
+            end
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/describe_db_log_files.rb

@@ -0,0 +1,67 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_db_log_files'
+
+        # Describe log files for a DB instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :file_last_written <~Long> - Filter available log files for those written after this time. Optional.
+        #   * :file_size <~Long> - Filters the available log files for files larger than the specified size. Optional.
+        #   * :filename_contains <~String> - Filters the available log files for log file names that contain the specified string. Optional.
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_db_log_files(rds_id=nil, opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = rds_id if rds_id
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['FilenameContains'] = opts[:filename_contains] if opts[:filename_contains]
+          params['FileSize'] = opts[:file_size] if opts[:file_size]
+          params['FileLastWritten'] = opts[:file_last_written] if opts[:file_last_written]
+
+          request({
+            'Action'  => 'DescribeDBLogFiles',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeDBLogFiles.new(rds_id)
+          }.merge(params))
+        end
+      end
+
+      class Mock
+
+        def describe_db_log_files(rds_id=nil, opts={})
+          response = Excon::Response.new
+          log_file_set = []
+
+          if rds_id
+            if server = self.data[:servers][rds_id]
+              log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:00:00 -0700'), "LogFileName" => "error/mysql-error.log", "Size" => 0}
+              log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:10:00 -0700'), "LogFileName" => "error/mysql-error-running.log", "Size" => 0}
+              log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:20:00 -0700'), "LogFileName" => "error/mysql-error-running.log.0", "Size" => 8220}
+              log_file_set << {"LastWritten" => Time.parse('2013-07-05 17:30:00 -0700'), "LogFileName" => "error/mysql-error-running.log.1", "Size" => 0}
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new('An identifier for an RDS instance must be provided')
+          end
+
+          response.status = 200
+          response.body = {
+              "ResponseMetadata" => { "RequestId" => Fog::AWS::Mock.request_id },
+              "DescribeDBLogFilesResult" => { "DBLogFiles" => log_file_set }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_orderable_db_instance_options'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * Engine <~String> - The name of the engine to retrieve DB Instance options for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :db_instance_class <~String> - Filter available offerings matching the specified DB Instance class. Optional.
+        #   * :engine_version <~String> - Filters available offerings matching the specified engine version. Optional.
+        #   * :license_model <~String> - Filters available offerings matching the specified license model. Optional.
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        #   * :vpc <~Boolean> - Filter to show only the available VPC or non-VPC offerings. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          params = {}
+          params['Engine'] = engine if engine
+          params['DBInstanceClass'] = opts[:db_instance_class] if opts[:db_instance_class]
+          params['EngineVersion'] = opts[:engine_version] if opts[:engine_version]
+          params['LicenseModel'] = opts[:license_model] if opts[:license_model]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['Vpc'] = opts[:vpc] if opts[:vpc]
+
+          request({
+            'Action'  => 'DescribeOrderableDBInstanceOptions',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeOrderableDBInstanceOptions.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          instance_options = []
+          response = Excon::Response.new
+          if engine
+            (opts[:db_instance_class] || %w(db.m2.xlarge db.m1.large)).each do |size|
+              instance_options << {'MultiAZCapable' => true,
+                                   'Engine' => engine,
+                                   'LicenseModel' => opts[:license_model] || 'general-public-license',
+                                   'ReadReplicaCapable' => true,
+                                   'EngineVersion' => opts[:engine_version] || '5.6.12',
+                                   'AvailabilityZones' => [
+                                      {'Name' => 'us-east-1b', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
+                                      {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
+                                   'DBInstanceClass' => size,
+                                   'Vpc' => opts[:vpc].nil? ? true : opts[:vpc]}
+
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new('An engine must be specified to retrieve orderable instance options')
+          end
+
+          response.status = 200
+          response.body = {
+              'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id },
+              'DescribeOrderableDBInstanceOptionsResult' => { 'OrderableDBInstanceOptions' => instance_options }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/rds/download_db_logfile_portion.rb

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/download_db_logfile_portion'
+
+        # Retrieve a portion of a log file of a db instance
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html
+        # ==== Parameters
+        # * DBInstanceIdentifier <~String> - ID of instance to retrieve information for. Required.
+        # * LogFileName <~String> - The name of the log file to be downloaded. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        #   * :number_of_lines <~Integer> - The number of lines to download. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def download_db_logfile_portion(identifier=nil, filename=nil, opts={})
+          params = {}
+          params['DBInstanceIdentifier'] = identifier if identifier
+          params['LogFileName'] = filename if filename
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['NumberOfLines'] = opts[:number_of_lines] if opts[:number_of_lines]
+
+          request({
+            'Action'  => 'DownloadDBLogFilePortion',
+            :parser   => Fog::Parsers::AWS::RDS::DownloadDBLogFilePortion.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def download_db_logfile_portion(identifier=nil, filename=nil, opts={})
+          response = Excon::Response.new
+          server_set = []
+          if identifier
+            if server = self.data[:servers][identifier]
+              server_set << server
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
+            end
+          else
+            server_set = self.data[:servers].values
+          end
+
+          response.status = 200
+          response.body = {
+              "ResponseMetadata" => { "RequestId"=> Fog::AWS::Mock.request_id },
+              "DescribeDBInstancesResult" => { "DBInstances" => server_set }
+          }
+          response
+        end
+
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ses/send_raw_email.rb

@@ -30,7 +30,7 @@ module Fog
 
           request({
             'Action'          => 'SendRawEmail',
-            'RawMessage.Data' => Base64.encode64(raw_message).chomp!,
+            'RawMessage.Data' => Base64.encode64(raw_message.to_s).chomp!,
             :parser           => Fog::Parsers::AWS::SES::SendRawEmail.new
           }.merge(params))
         end

data/lib/fog/aws/requests/ses/verify_domain_identity.rb

@@ -16,7 +16,7 @@ module Fog
         #     * 'ResponseMetadata'<~Hash>:
         #       * 'VerificationToken'<~String> - Verification token
         #       * 'RequestId'<~String> - Id of request
-        def verify_domain(domain)
+        def verify_domain_identity(domain)
           request({
             'Action'           => 'VerifyDomainIdentity',
             'Domain'           => domain,

data/lib/fog/aws/requests/storage/complete_multipart_upload.rb

@@ -13,12 +13,16 @@ module Fog
         # @param [Array<String>] parts Array of etags as Strings for parts
         #
         # @return [Excon::Response]
-        #   * headers [Hash]:
+        #   * body [Hash]: (success)
         #     * Bucket [String] - bucket of new object
-        #     * ETag [String] - etag of new object (will be needed to complete upload)
+        #     * ETag [String] - etag of new object
         #     * Key [String] - key of new object
         #     * Location [String] - location of new object
+        #   * body [Hash]: (failure)
+        #     * Code [String] - Error status code
+        #     * Message [String] - Error description
         #
+        # @note This request could fail and still return +200 OK+, so it's important that you check the response.
         # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadComplete.html
         #
         def complete_multipart_upload(bucket_name, object_name, upload_id, parts)

data/lib/fog/aws/requests/storage/get_object.rb

@@ -87,7 +87,7 @@ module Fog
             if (object && !object[:delete_marker])
               if options['If-Match'] && options['If-Match'] != object['ETag']
                 response.status = 412
-              elsif options['If-Modified-Since'] && options['If-Modified-Since'] > Time.parse(object['Last-Modified'])
+              elsif options['If-Modified-Since'] && options['If-Modified-Since'] >= Time.parse(object['Last-Modified'])
                 response.status = 304
               elsif options['If-None-Match'] && options['If-None-Match'] == object['ETag']
                 response.status = 304