aws-sdk-core 2.0.0.rc1

data/lib/aws/plugins/s3_get_bucket_location_fix.rb

@@ -0,0 +1,21 @@
+module Aws
+  module Plugins
+    class S3GetBucketLocationFix < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          @handler.call(context).on_success do |response|
+            xml = MultiXml.parse(response.http_response.body_contents)
+            if constraint = xml['LocationConstraint']
+              response.data[:location_constraint] = constraint['__content__'].to_s
+            end
+          end
+        end
+      end
+
+      handler(Handler, priority: 60, operations: [:get_bucket_location])
+
+    end
+  end
+end

data/lib/aws/plugins/s3_md5s.rb

@@ -0,0 +1,61 @@
+require 'digest/md5'
+require 'base64'
+
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :compute_optional_md5s (true)
+    #   When `true` a MD5 checksum will be computed for all requests that
+    #   accept the optional `Content-MD5` header.  Checksum errors returned
+    #   by Amazon S3 are automatically retried up to `:retry_limit` times.
+    class S3Md5s < Seahorse::Client::Plugin
+
+      # Amazon S3 requires these operations to have an MD5 checksum
+      REQUIRED_OPERATIONS = [
+        :delete_objects,
+        :put_bucket_cors,
+        :put_bucket_lifecycle,
+        :put_bucket_policy,
+        :put_bucket_tagging,
+      ]
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        OneMB = 1024 * 1024
+
+        def call(context)
+          context.http_request.headers['Content-Md5'] = md5(context)
+          @handler.call(context)
+        end
+
+        def md5(context)
+          md5 = Digest::MD5.new
+          body = context.http_request.body
+          while chunk = body.read(OneMB)
+            md5.update(chunk)
+          end
+          body.rewind
+          Base64.encode64(md5.digest).strip
+        end
+
+      end
+
+      option(:compute_optional_md5s, true)
+
+      def add_handlers(handlers, config)
+        options = {
+          priority: 10, # set intentially low so the md5 is computed after
+          step: :build, # the request is built but before it is signed
+        }
+
+        if !config.compute_optional_md5s
+          options[:operations] = REQUIRED_OPERATIONS
+        end
+
+        handlers.add(Handler, options)
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/s3_redirects.rb

@@ -0,0 +1,38 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [Boolean] :follow_redirects (true)
+    #   When `true`, this client will follow 307 redirects returned
+    #   by Amazon S3.
+    class S3Redirects < Seahorse::Client::Plugin
+
+      option(:follow_redirects, true)
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          response = @handler.call(context)
+          if response.http_response.status_code == 307
+            endpoint = response.http_response.headers['location']
+            endpoint = Seahorse::Client::Http::Endpoint.new(endpoint)
+            context.http_request.endpoint = endpoint
+            context.http_response.body.truncate(0)
+            @handler.call(context)
+          else
+            response
+          end
+        end
+
+      end
+
+      def add_handlers(handlers, config)
+        if config.follow_redirects
+          # we want to re-trigger request signing
+          handlers.add(Handler, step: :sign, priority: 90)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/s3_regional_endpoint.rb

@@ -0,0 +1,19 @@
+
+module Aws
+  module Plugins
+    class S3RegionalEndpoint < RegionalEndpoint
+
+      option(:region) { ENV['AWS_REGION'] || ENV['AMAZON_REGION'] }
+
+      option(:endpoint) do |config|
+        raise ArgumentError, MISSING_REGION unless config.region
+        if config.region == 'us-east-1'
+          's3.amazonaws.com'
+        else
+          's3-%s.amazonaws.com' % config.region
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/s3_signer.rb

@@ -0,0 +1,9 @@
+module Aws
+  module Plugins
+    class S3Signer < Seahorse::Client::Plugin
+
+      handler(Signers::Handler.new(Signers::S3), step: :sign)
+
+    end
+  end
+end

data/lib/aws/plugins/signature_v2.rb

@@ -0,0 +1,9 @@
+module Aws
+  module Plugins
+    class SignatureV2 < Seahorse::Client::Plugin
+
+      handler(Signers::Handler.new(Signers::V2), step: :sign)
+
+    end
+  end
+end

data/lib/aws/plugins/signature_v3.rb

@@ -0,0 +1,9 @@
+module Aws
+  module Plugins
+    class SignatureV3 < Seahorse::Client::Plugin
+
+      handler(Signers::Handler.new(Signers::V3), step: :sign)
+
+    end
+  end
+end

data/lib/aws/plugins/signature_v4.rb

@@ -0,0 +1,29 @@
+module Aws
+  module Plugins
+
+    # @seahorse.client.option [String] :sigv4_name
+    #   Override the default service name used for signing sigv4 requests.
+    # @seahorse.client.option [String] :sigv4_region
+    #   Override the default region name used for signing sigv4 requests.
+    class SignatureV4 < Seahorse::Client::Plugin
+
+      option(:sigv4_name) do |config|
+        config.api.metadata['endpoint_prefix']
+      end
+
+      option(:sigv4_region) do |config|
+        prefix = config.api.metadata['endpoint_prefix']
+        if matches = config.endpoint.match(/#{prefix}[.-](.+)\.amazonaws\.com/)
+          matches[1]
+        elsif config.endpoint.match(/#{prefix}\.amazonaws\.com/)
+          'us-east-1'
+        else
+          config.region
+        end
+      end
+
+      handler(Signers::Handler.new(Signers::V4), step: :sign)
+
+    end
+  end
+end

data/lib/aws/plugins/sqs_queue_urls.rb

@@ -0,0 +1,33 @@
+module Aws
+  module Plugins
+    # @api private
+    class SQSQueueUrls < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          if url = context.params[:queue_url]
+            update_endpoint(context, url)
+            update_region(context, url)
+          end
+          @handler.call(context)
+        end
+
+        def update_endpoint(context, url)
+          context.http_request.endpoint = url
+        end
+
+        def update_region(context, url)
+          region = url.split('.')[1]
+          context.config = context.config.dup
+          context.config.region = region
+          context.config.sigv4_region = region
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws/plugins/swf_read_timeouts.rb

@@ -0,0 +1,23 @@
+module Aws
+  module Plugins
+    # Extends the default read-timeout value 
+    class SWFReadTimeouts < Seahorse::Client::Plugin
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          context.config = context.config.dup
+          context.config.http_read_timeout = 90
+          @handler.call(context)
+        end
+
+      end
+
+      handler(Handler, operations: [
+        :poll_for_activity_task,
+        :poll_for_decision_task,
+      ])
+
+    end
+  end
+end

data/lib/aws/plugins/user_agent.rb

@@ -0,0 +1,32 @@
+module Aws
+  module Plugins
+    class UserAgent < Seahorse::Client::Plugin
+
+      option(:user_agent_prefix)
+
+      # @api private
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          set_user_agent(context)
+          @handler.call(context)
+        end
+
+        def set_user_agent(context)
+          ua = "%s aws-sdk-ruby/#{VERSION} %s/%s %s Seahorse/%s" % [
+            context.config.user_agent_prefix,
+            (RUBY_ENGINE rescue nil or "ruby"),
+            RUBY_VERSION,
+            RUBY_PLATFORM,
+            Seahorse::VERSION,
+          ]
+          context.http_request.headers['User-Agent'] = ua.strip
+        end
+
+      end
+
+      handler(Handler)
+
+    end
+  end
+end

data/lib/aws/plugins/xml_protocol.rb

@@ -0,0 +1,11 @@
+module Aws
+  module Plugins
+    class XmlProtocol < Seahorse::Client::Plugin
+
+      handler(RequestHandler.new(Xml::Serializer.new))
+      handler(ResponseHandler.new(Xml::Parser.new))
+      handler(ErrorHandler.new(Xml::ErrorParser.new), step: :sign)
+
+    end
+  end
+end

data/lib/aws/query/builder.rb

@@ -0,0 +1,102 @@
+require 'base64'
+
+module Aws
+  module Query
+    class Builder
+
+      include Seahorse::Model::Shapes
+
+      # @param [Seahorse::Model::Shapes::Shape] rules
+      def initialize(rules)
+        @rules = rules
+      end
+
+      # @param [Hash] params
+      # @return [ParamList]
+      def to_query_params(params)
+        param_list = ParamList.new
+        structure(param_list, @rules, nil, params)
+        param_list
+      end
+
+      # @param [Seahorse::Model::Shapes::Shape] rules
+      # @param [Hash] params
+      # @return [ParamList]
+      def self.to_query_params(rules, params)
+        new(rules).to_query_params(params)
+      end
+
+      private
+
+      def structure(param_list, shape, prefix, values)
+        values.each do |name, value|
+          member_shape = shape.members[name]
+          param_name = member_shape.serialized_name
+          param_name = "#{prefix}.#{param_name}" if prefix
+          member(param_list, member_shape, param_name, value)
+        end
+      end
+
+      def list(param_list, shape, prefix, values)
+        member_shape = shape.members
+        if flat?(shape)
+          if member_shape.serialized_name
+            parts = prefix.split('.')
+            parts.pop
+            parts.push(member_shape.serialized_name)
+            prefix = parts.join('.')
+          end
+        else
+          prefix += '.member'
+        end
+        values.each_with_index do |value, n|
+          member(param_list, member_shape, "#{prefix}.#{n+1}", value)
+        end
+      end
+
+      def map(param_list, shape, prefix, values)
+        key_shape = shape.keys
+        value_shape = shape.members
+        prefix += '.entry' unless flat?(shape)
+        key_name = "%s.%d.#{key_shape.serialized_name || 'key'}"
+        value_name  = "%s.%d.#{value_shape.serialized_name || 'value'}"
+        n = 1
+        values.each_pair do |key, value|
+          member(param_list, key_shape, key_name % [prefix, n], key)
+          member(param_list, value_shape, value_name % [prefix, n], value)
+          n += 1
+        end
+      end
+
+      def member(param_list, shape, prefix, value)
+        case shape
+        when StructureShape then structure(param_list, shape, prefix, value)
+        when ListShape then list(param_list, shape, prefix, value)
+        when MapShape then map(param_list, shape, prefix, value)
+        when TimestampShape then timestamp(param_list, shape, prefix, value.utc)
+        when BlobShape then blob(param_list, shape, prefix, value)
+        else param_list.set(prefix, value.to_s)
+        end
+      end
+
+      def timestamp(param_list, shape, prefix, value)
+        value = case shape
+          when Iso8601TimestampShape then value.iso8601
+          when Rfc822TimestampShape then value.rfc822
+          when UnixTimestampShape then value.to_i.to_s
+          else raise "invalid timestamp format `#{shape.class.name}'"
+        end
+        param_list.set(prefix, value)
+      end
+
+      def blob(param_list, shape, prefix, value)
+        param_list.set(prefix, Base64.strict_encode64(value))
+      end
+
+      def flat?(shape)
+        FlatListShape === shape || FlatMapShape === shape
+      end
+
+    end
+  end
+end

data/lib/aws/query/param.rb

@@ -0,0 +1,43 @@
+module Aws
+  module Query
+    class Param
+
+      # @param [String] name
+      # @param [String, nil] value (nil)
+      def initialize(name, value = nil)
+        @name = name.to_s
+        @value = value
+      end
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String, nil]
+      attr_reader :value
+
+      # @return [String]
+      def to_s
+        value ? "#{escape(name)}=#{escape(value)}" : escape(name)
+      end
+
+      # @api private
+      def ==(other)
+        other.kind_of?(Param) &&
+        other.name == name &&
+        other.value == value
+      end
+
+      # @api private
+      def <=> other
+        name <=> other.name
+      end
+
+      private
+
+      def escape(str)
+        Util.uri_escape(str)
+      end
+
+    end
+  end
+end