fog 1.26.0 → 1.27.0

data/lib/fog/aws/requests/sqs/list_queues.rb

@@ -1,41 +0,0 @@
-module Fog
-  module AWS
-    class SQS
-      class Real
-        require 'fog/aws/parsers/sqs/list_queues'
-
-        # List queues
-        #
-        # ==== Parameters
-        # * options<~Hash>:
-        #   * QueueNamePrefix<~String> - String used to filter results to only those with matching prefixes
-        #
-        # ==== See Also
-        # http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryListQueues.html
-        #
-
-        def list_queues(options = {})
-          request({
-            'Action' => 'ListQueues',
-            :parser  => Fog::Parsers::AWS::SQS::ListQueues.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def list_queues(options = {})
-          Excon::Response.new.tap do |response|
-            response.status = 200
-
-            response.body = {
-              'ResponseMetadata' => {
-                'RequestId' => Fog::AWS::Mock.request_id
-              },
-              'QueueUrls' => data[:queues].keys
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/sqs/receive_message.rb

@@ -1,83 +0,0 @@
-module Fog
-  module AWS
-    class SQS
-      class Real
-        require 'fog/aws/parsers/sqs/receive_message'
-
-        # Get a message from a queue (marks it as unavailable temporarily, but does not remove from queue, see delete_message)
-        #
-        # ==== Parameters
-        # * queue_url<~String> - Url of queue to get message from
-        # * options<~Hash>:
-        #   * Attributes<~Array> - List of attributes to return, in ['All', 'ApproximateFirstReceiveTimestamp', 'ApproximateReceiveCount', 'SenderId', 'SentTimestamp'], defaults to 'All'
-        #   * MaxNumberOfMessages<~Integer> - Maximum number of messages to return, defaults to 1
-        #   * VisibilityTimeout<~Integer> - Duration, in seconds, to hide message from other receives. In 0..43200, defaults to visibility timeout for queue
-        #
-        # ==== See Also
-        # http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QueryReceiveMessage.html
-        #
-
-        def receive_message(queue_url, options = {})
-          request({
-            'Action'        => 'ReceiveMessage',
-            'AttributeName' => 'All',
-            :path           => path_from_queue_url(queue_url),
-            :parser         => Fog::Parsers::AWS::SQS::ReceiveMessage.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def receive_message(queue_url, options = {})
-          Excon::Response.new.tap do |response|
-            if (queue = data[:queues][queue_url])
-              max_number_of_messages = options['MaxNumberOfMessages'] || 1
-              now = Time.now
-
-              messages = []
-
-              queue[:messages].values.each do |m|
-                message_id = m['MessageId']
-
-                invisible = if (received_handles = queue[:receipt_handles][message_id])
-                  visibility_timeout = m['Attributes']['VisibilityTimeout'] || queue['Attributes']['VisibilityTimeout']
-                  received_handles.any? { |handle, time| now < time + visibility_timeout }
-                else
-                  false
-                end
-
-                unless invisible
-                  receipt_handle = Fog::Mock.random_base64(300)
-
-                  queue[:receipt_handles][message_id] ||= {}
-                  queue[:receipt_handles][message_id][receipt_handle] = now
-
-                  m['Attributes'].tap do |attrs|
-                    attrs['ApproximateFirstReceiveTimestamp'] ||= now
-                    attrs['ApproximateReceiveCount'] = (attrs['ApproximateReceiveCount'] || 0) + 1
-                  end
-
-                  messages << m.merge({
-                    'ReceiptHandle' => receipt_handle
-                  })
-                  break if messages.size >= max_number_of_messages
-                end
-              end
-
-              response.body = {
-                'ResponseMetadata' => {
-                  'RequestId' => Fog::AWS::Mock.request_id
-                },
-                'Message' => messages
-              }
-              response.status = 200
-            else
-              response.status = 404
-              raise(Excon::Errors.status_error({:expects => 200}, response))
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/sqs/send_message.rb

@@ -1,65 +0,0 @@
-module Fog
-  module AWS
-    class SQS
-      class Real
-        require 'fog/aws/parsers/sqs/send_message'
-
-        # Add a message to a queue
-        #
-        # ==== Parameters
-        # * queue_url<~String> - Url of queue to add message to
-        # * message<~String> - Message to add to queue
-        #
-        # ==== See Also
-        # http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySendMessage.html
-        #
-
-        def send_message(queue_url, message)
-          request({
-            'Action'      => 'SendMessage',
-            'MessageBody' => message,
-            :path         => path_from_queue_url(queue_url),
-            :parser       => Fog::Parsers::AWS::SQS::SendMessage.new
-          })
-        end
-      end
-
-      class Mock
-        def send_message(queue_url, message)
-          Excon::Response.new.tap do |response|
-            if (queue = data[:queues][queue_url])
-              response.status = 200
-
-              now        = Time.now
-              message_id = Fog::AWS::Mock.sqs_message_id
-              md5        = Digest::MD5.hexdigest(message)
-
-              queue[:messages][message_id] = {
-                'MessageId'  => message_id,
-                'Body'       => message,
-                'MD5OfBody'  => md5,
-                'Attributes' => {
-                  'SenderId'      => Fog::AWS::Mock.sqs_message_id,
-                  'SentTimestamp' => now
-                }
-              }
-
-              queue['Attributes']['LastModifiedTimestamp'] = now
-
-              response.body = {
-                'ResponseMetadata' => {
-                  'RequestId' => Fog::AWS::Mock.request_id
-                },
-                'MessageId'        => message_id,
-                'MD5OfMessageBody' => md5
-              }
-            else
-              response.status = 404
-              raise(Excon::Errors.status_error({:expects => 200}, response))
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/sqs/set_queue_attributes.rb

@@ -1,49 +0,0 @@
-module Fog
-  module AWS
-    class SQS
-      class Real
-        require 'fog/aws/parsers/sqs/basic'
-
-        # Get attributes of a queue
-        #
-        # ==== Parameters
-        # * queue_url<~String> - Url of queue to get attributes for
-        # * attribute_name<~String> - Name of attribute to set, keys in ['MaximumMessageSize', 'MessageRetentionPeriod', 'Policy', 'VisibilityTimeout']
-        # * attribute_value<~String> - Value to set for attribute
-        #
-        # ==== See Also
-        # http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySetQueueAttributes.html
-        #
-
-        def set_queue_attributes(queue_url, attribute_name, attribute_value)
-          request({
-            'Action'          => 'SetQueueAttributes',
-            'Attribute.Name'  => attribute_name,
-            'Attribute.Value' => attribute_value,
-            :path             => path_from_queue_url(queue_url),
-            :parser           => Fog::Parsers::AWS::SQS::Basic.new
-          })
-        end
-      end
-
-      class Mock
-        def set_queue_attributes(queue_url, attribute_name, attribute_value)
-          Excon::Response.new.tap do |response|
-            if (queue = data[:queues][queue_url])
-              response.status = 200
-              queue['Attributes'][attribute_name] = attribute_value
-              response.body = {
-                'ResponseMetadata' => {
-                  'RequestId' => Fog::AWS::Mock.request_id
-                }
-              }
-            else
-              response.status = 404
-              raise(Excon::Errors.status_error({:expects => 200}, response))
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Fog
-  module Storage
-    class AWS
-      class Real
-        #
-        # Abort a multipart upload
-        #
-        # @param [String] bucket_name Name of bucket to abort multipart upload on
-        # @param [String] object_name Name of object to abort multipart upload on
-        # @param [String] upload_id Id of upload to add part to
-        #
-        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadAbort.html
-        #
-        def abort_multipart_upload(bucket_name, object_name, upload_id)
-          request({
-            :expects    => 204,
-            :headers    => {},
-            :bucket_name => bucket_name,
-            :object_name => object_name,
-            :method     => 'DELETE',
-            :query      => {'uploadId' => upload_id}
-          })
-        end
-      end # Real
-
-      class Mock # :nodoc:all
-        require 'fog/aws/requests/storage/shared_mock_methods'
-        include Fog::Storage::AWS::SharedMockMethods
-
-        def abort_multipart_upload(bucket_name, object_name, upload_id)
-          verify_mock_bucket_exists(bucket_name)
-          upload_info = get_upload_info(bucket_name, upload_id, true)
-          response = Excon::Response.new
-          if upload_info
-            response.status = 204
-            response
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({:expects => 204}, response))
-          end
-        end
-      end # Mock
-    end # Storage
-  end # AWS
-end # Fog

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

@@ -1,60 +0,0 @@
-module Fog
-  module Storage
-    class AWS
-      require 'fog/aws/parsers/storage/access_control_list'
-
-      private
-        def self.hash_to_acl(acl)
-          data =  "<AccessControlPolicy>\n"
-
-          if acl['Owner'] && (acl['Owner']['ID'] || acl['Owner']['DisplayName'])
-            data << "  <Owner>\n"
-            data << "    <ID>#{acl['Owner']['ID']}</ID>\n" if acl['Owner']['ID']
-            data << "    <DisplayName>#{acl['Owner']['DisplayName']}</DisplayName>\n" if acl['Owner']['DisplayName']
-            data << "  </Owner>\n"
-          end
-
-          grants = [acl['AccessControlList']].flatten.compact
-
-          data << "  <AccessControlList>\n" if grants.any?
-          grants.each do |grant|
-            data << "    <Grant>\n"
-            grantee = grant['Grantee']
-            type = case
-            when grantee.key?('ID')
-              'CanonicalUser'
-            when grantee.key?('EmailAddress')
-              'AmazonCustomerByEmail'
-            when grantee.key?('URI')
-              'Group'
-            end
-
-            data << "      <Grantee xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"#{type}\">\n"
-            case type
-            when 'CanonicalUser'
-              data << "        <ID>#{grantee['ID']}</ID>\n" if grantee['ID']
-              data << "        <DisplayName>#{grantee['DisplayName']}</DisplayName>\n" if grantee['DisplayName']
-            when 'AmazonCustomerByEmail'
-              data << "        <EmailAddress>#{grantee['EmailAddress']}</EmailAddress>\n" if grantee['EmailAddress']
-            when 'Group'
-              data << "        <URI>#{grantee['URI']}</URI>\n" if grantee['URI']
-            end
-            data << "      </Grantee>\n"
-            data << "      <Permission>#{grant['Permission']}</Permission>\n"
-            data << "    </Grant>\n"
-          end
-          data << "  </AccessControlList>\n" if grants.any?
-
-          data << "</AccessControlPolicy>"
-
-          data
-        end
-
-        def self.acl_to_hash(acl_xml)
-          parser = Fog::Parsers::Storage::AWS::AccessControlList.new
-          Nokogiri::XML::SAX::Parser.new(parser).parse(acl_xml)
-          parser.response
-        end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module Fog
-  module Storage
-    class AWS
-      class Real
-        require 'fog/aws/parsers/storage/complete_multipart_upload'
-
-        # Complete a multipart upload
-        #
-        # @param [String] bucket_name Name of bucket to complete multipart upload for
-        # @param [String] object_name Name of object to complete multipart upload for
-        # @param [String] upload_id Id of upload to add part to
-        # @param [Array<String>] parts Array of etags as Strings for parts
-        #
-        # @return [Excon::Response]
-        #   * body [Hash]: (success)
-        #     * Bucket [String] - bucket of new object
-        #     * 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 = "<CompleteMultipartUpload>"
-          parts.each_with_index do |part, index|
-            data << "<Part>"
-            data << "<PartNumber>#{index + 1}</PartNumber>"
-            data << "<ETag>#{part}</ETag>"
-            data << "</Part>"
-          end
-          data << "</CompleteMultipartUpload>"
-          request({
-            :body       => data,
-            :expects    => 200,
-            :headers    => { 'Content-Length' => data.length },
-            :bucket_name => bucket_name,
-            :object_name => object_name,
-            :method     => 'POST',
-            :parser     => Fog::Parsers::Storage::AWS::CompleteMultipartUpload.new,
-            :query      => {'uploadId' => upload_id}
-          })
-        end
-      end # Real
-
-      class Mock # :nodoc:all
-        require 'fog/aws/requests/storage/shared_mock_methods'
-        include Fog::Storage::AWS::SharedMockMethods
-
-        def complete_multipart_upload(bucket_name, object_name, upload_id, parts)
-          bucket = verify_mock_bucket_exists(bucket_name)
-          upload_info = get_upload_info(bucket_name, upload_id, true)
-          body = parts.map { |pid| upload_info[:parts][pid.to_i] }.join
-          object = store_mock_object(bucket, object_name, body, upload_info[:options])
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            'Location' => "http://#{bucket_name}.s3.amazonaws.com/#{object_name}",
-            'Bucket'   => bucket_name,
-            'Key'      => object_name,
-            'ETag'     => object['ETag'],
-          }
-          response.headers['x-amz-version-id'] = object['VersionId'] if object['VersionId'] != 'null'
-          response
-        end
-      end # Mock
-    end # Storage
-  end # AWS
-end # Fog

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

@@ -1,77 +0,0 @@
-module Fog
-  module Storage
-    class AWS
-      class Real
-        require 'fog/aws/parsers/storage/copy_object'
-
-        # Copy an object from one S3 bucket to another
-        #
-        # @param source_bucket_name [String] Name of source bucket
-        # @param source_object_name [String] Name of source object
-        # @param target_bucket_name [String] Name of bucket to create copy in
-        # @param target_object_name [String] Name for new copy of object
-        #
-        # @param options [Hash]:
-        # @option options [String] x-amz-metadata-directive Specifies whether to copy metadata from source or replace with data in request.  Must be in ['COPY', 'REPLACE']
-        # @option options [String] x-amz-copy_source-if-match Copies object if its etag matches this value
-        # @option options [Time] x-amz-copy_source-if-modified_since Copies object it it has been modified since this time
-        # @option options [String] x-amz-copy_source-if-none-match Copies object if its etag does not match this value
-        # @option options [Time] x-amz-copy_source-if-unmodified-since Copies object it it has not been modified since this time
-        # @option options [String] x-amz-storage-class Default is 'STANDARD', set to 'REDUCED_REDUNDANCY' for non-critical, reproducable data
-        #
-        #
-        # @return [Excon::Response]
-        #   * body [Hash]:
-        #     * ETag [String] - etag of new object
-        #     * LastModified [Time] - date object was last modified
-        #
-        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectCOPY.html
-        #
-        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
-          headers = { 'x-amz-copy-source' => "/#{source_bucket_name}#{object_to_path(source_object_name)}" }.merge!(options)
-          request({
-            :expects  => 200,
-            :headers  => headers,
-            :bucket_name => target_bucket_name,
-            :object_name => target_object_name,
-            :method   => 'PUT',
-            :parser   => Fog::Parsers::Storage::AWS::CopyObject.new,
-          })
-        end
-      end
-
-      class Mock # :nodoc:all
-        def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
-          response = Excon::Response.new
-          source_bucket = self.data[:buckets][source_bucket_name]
-          source_object = source_bucket && source_bucket[:objects][source_object_name] && source_bucket[:objects][source_object_name].first
-          target_bucket = self.data[:buckets][target_bucket_name]
-
-          acl = options['x-amz-acl'] || 'private'
-          if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
-            raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
-          else
-            self.data[:acls][:object][target_bucket_name] ||= {}
-            self.data[:acls][:object][target_bucket_name][target_object_name] = self.class.acls(acl)
-          end
-
-          if source_object && target_bucket
-            response.status = 200
-            target_object = source_object.dup
-            target_object.merge!({'Key' => target_object_name})
-            target_bucket[:objects][target_object_name] = [target_object]
-            response.body = {
-              'ETag'          => target_object['ETag'],
-              'LastModified'  => Time.parse(target_object['Last-Modified'])
-            }
-          else
-            response.status = 404
-            raise(Excon::Errors.status_error({:expects => 200}, response))
-          end
-
-          response
-        end
-      end
-    end
-  end
-end