aws-sdk-core 2.0.0.rc14 → 2.0.0.rc15

data/lib/aws/api/{documentor.rb → operation_documenter.rb}

@@ -1,10 +1,10 @@
 module Aws
   module Api
-    class Documentor
+    class OperationDocumenter
 
-      def initialize(obj_name, method_name, operation)
-        @operation = operation
-        @example = DocExample.new(obj_name, method_name, operation)
+      def initialize(options)
+        @operation = options[:operation]
+        @example = OperationExample.new(options)
       end
 
       def input
@@ -50,7 +50,11 @@ module Aws
       private
 
       def params(shape, &block)
-        ['<div class="params">', api_ref(shape)] + yield + ['</div>']
+        if shape && shape.name == 'AttributeValue'
+          ['<p>An attribute value may be one of:<ul><li>`String`</li><li>`Numeric`</li><li>`IO`</li><li>`Set<String,Numeric,IO>`</li></ul></p>']
+        else
+          ['<div class="params">', api_ref(shape)] + yield + ['</div>']
+        end
       end
 
       def param(shape, key_name, value_type, required, visited, &block)

data/lib/aws/api/{doc_example.rb → operation_example.rb}

@@ -1,13 +1,13 @@
 module Aws
   module Api
-    class DocExample
+    class OperationExample
 
       include Seahorse::Model::Shapes
 
-      def initialize(obj_name, method_name, operation)
-        @obj_name = obj_name
-        @method_name = method_name
-        @operation = operation
+      def initialize(options)
+        @obj_name = options[:svc_var_name]
+        @method_name = options[:method_name]
+        @operation = options[:operation]
       end
 
       def to_str
@@ -46,7 +46,6 @@ module Aws
       def multiline_map(shape, i, visited)
         lines = ["{"]
         lines << "#{i}  #{key_name(shape)} => #{member(shape.value, i + '  ', visited)},"
-        #lines << "#{i}  # repeated ..."
         lines << "#{i}}"
         lines.join("\n")
       end
@@ -62,7 +61,6 @@ module Aws
       def multiline_list(shape, i, visited)
         lines = ["["]
         lines << "#{i}  #{member(shape.member, i + '  ', visited)},"
-        #lines << "#{i}  # repeated ... "
         lines << "#{i}]"
         lines.join("\n")
       end
@@ -73,6 +71,9 @@ module Aws
           recursive << "#{i}  # recursive #{shape.name} ..."
           recursive << "#{i}}"
           return recursive.join("\n")
+        elsif shape.name == 'AttributeValue'
+          msg='"value", #<String,Numeric,IO,Set>'
+          return msg
         else
           visited = visited + [shape.name]
         end

data/lib/aws/api/service_customizations.rb

@@ -78,12 +78,13 @@ module Aws
       end
 
       customize 'cloudsearchdomain' do
-        remove_plugin 'Aws::Plugins::RequestSigner'
         remove_plugin 'Aws::Plugins::RegionalEndpoint'
+        add_plugin 'Aws::Plugins::CSDConditionalSigning'
       end
 
       customize 'dynamodb' do
         add_plugin 'Aws::Plugins::DynamoDBExtendedRetries'
+        add_plugin 'Aws::Plugins::DynamoDBSimpleAttributes'
       end
 
       customize 'ec2' do
@@ -123,6 +124,7 @@ module Aws
         add_plugin 'Aws::Plugins::S3Md5s'
         add_plugin 'Aws::Plugins::S3Redirects'
         add_plugin 'Aws::Plugins::S3SseCpk'
+        add_plugin 'Aws::Plugins::S3UrlEncodedKeys'
       end
 
       customize 'sqs' do

data/lib/aws/client.rb

@@ -0,0 +1,38 @@
+module Aws
+
+  # Base class for all {Aws} service clients.
+  class Client < Seahorse::Client::Base
+    class << self
+
+      # @return [Symbol]
+      # @api private
+      attr_accessor :identifier
+
+      # @return [Paging::Provider]
+      # @api private
+      attr_accessor :paginators
+
+      # @api private
+      def define(svc_name, options)
+        client_class = Class.new(self)
+        client_class.identifier = svc_name.downcase.to_sym
+        client_class.set_api(load_api(options[:api]))
+        Api::ServiceCustomizations.apply(client_class)
+        client_class
+      end
+
+      private
+
+      def load_api(api)
+        case api
+        when Seahorse::Model::Api then api
+        when Hash then Seahorse::Model::Api.new(api)
+        when String then Seahorse::Model::Api.new(Aws.load_json(api))
+        else
+          raise ArgumentError, "expected :api to be an Api, Hash or String"
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/credential_provider_chain.rb

@@ -1,4 +1,5 @@
 module Aws
+  # @api private
   class CredentialProviderChain
 
     def initialize(config)

data/lib/aws/dynamodb/attribute_value.rb

@@ -0,0 +1,87 @@
+require 'bigdecimal'
+require 'stringio'
+require 'set'
+
+module Aws
+  module DynamoDB
+    # @api private
+    class AttributeValue
+
+      def initialize
+        @marshaler = Marshaler.new
+        @unmarshaler = Unmarshaler.new
+      end
+
+      def marshal(value)
+        @marshaler.format(value)
+      end
+
+      def unmarshal(value)
+        @unmarshaler.format(value)
+      end
+
+      class Marshaler
+
+        def format(obj)
+          case obj
+          when String then { s: obj }
+          when Numeric then { n: obj.to_s }
+          when StringIO, IO then { b: obj.read }
+          when Set then format_set(obj)
+          else
+            msg = "unsupported type, expected Set, String, Numeric, or "
+            msg << "IO object, got #{obj.class.name}"
+            raise ArgumentError, msg
+          end
+        end
+
+        private
+
+        def format_set(set)
+          case set.first
+          when String then { ss: set.map(&:to_s) }
+          when Numeric then { ns: set.map(&:to_s) }
+          when StringIO, IO then { bs: set.map(&:read) }
+          else
+            msg = "set types only support String, Numeric, or IO objects"
+            raise ArgumentError, msg
+          end
+        end
+
+      end
+
+      class Unmarshaler
+
+        def format(obj)
+          type, value = extract_type_and_value(obj)
+          case type
+          when :s then value
+          when :n then BigDecimal.new(value)
+          when :b then StringIO.new(value)
+          when :ss then Set.new(value)
+          when :ns then Set.new(value.map { |n| BigDecimal.new(n) })
+          when :bs then Set.new(value.map { |b| StringIO.new(b) })
+          else
+            raise ArgumentError, "unhandled type #{type.inspect}"
+          end
+        end
+
+        private
+
+        def extract_type_and_value(obj)
+          case obj
+          when Hash then obj.to_a.first
+          when Struct
+            obj.members.each do |key|
+              value = obj[key]
+              return [key, value] unless value.nil?
+            end
+          else
+            raise ArgumentError, "unhandled type #{obj.inspect}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/empty_structure.rb

@@ -6,14 +6,14 @@ module Aws
     end
 
     def ==(other)
-      other.is_a?(EmptyStruct)
+      other.is_a?(EmptyStructure)
     end
 
     def [](member_name)
       raise NameError, "no member '#{member_name}' in struct"
     end
 
-    def []=(member_name)
+    def []=(member_name, value)
       raise NameError, "no member '#{member_name}' in struct"
     end
 
@@ -30,7 +30,7 @@ module Aws
     end
 
     def eql?(other)
-      other.is_a?(EmptyStruct)
+      other.is_a?(EmptyStructure)
     end
 
     # @api private
@@ -52,6 +52,7 @@ module Aws
     end
 
     def select(&block)
+      []
     end
 
     def size

data/lib/aws/endpoint_provider.rb

@@ -1,6 +1,7 @@
 require 'multi_json'
 
 module Aws
+  # @api private
   class EndpointProvider
 
     # @option options [Array<Hash>] :rules ([]) An array of grouped rules.

data/lib/aws/errors.rb

@@ -1,6 +1,8 @@
 require 'thread'
 
 module Aws
+
+  # Each Service module has its own Errors module, e.g. {S3::Errors}.
   module Errors
 
     # The base class for all errors returned by an Amazon Web Service.

data/lib/aws/instance_profile_credentials.rb

@@ -96,7 +96,7 @@ module Aws
     end
 
     def open_connection
-      http = Net::HTTP.new(@ip_address, @port)
+      http = Net::HTTP.new(@ip_address, @port, nil)
       http.open_timeout = @http_open_timeout
       http.read_timeout = @http_read_timeout
       http.set_debug_output(@http_debug_output) if @http_debug_output

data/lib/aws/plugins/csd_conditional_signing.rb

@@ -0,0 +1,32 @@
+module Aws
+  module Plugins
+
+    # Makes it possible to conditional sign {Aws::CloudSearchDomain::Client}
+    # requests. When credentials are configured, requests are signed.
+    # When they are omitted, the request is sent anonymously.
+    #
+    # @seahorse.client.option [String] :sigv4_region Only needed when sending
+    #   authenticated/signed requests to a Cloud Search domain and the
+    #   endpoint does not contain the region name.
+    #
+    class CSDConditionalSigning < Seahorse::Client::Plugin
+
+      option(:sigv4_region) do |cfg|
+        # extract the region name from the cloud search domain endpoint
+        if cfg.endpoint
+          cfg.endpoint.to_s.split('.')[1]
+        else
+          raise ArgumentError, 'missing required option :endpoint'
+        end
+      end
+
+      def after_initialize(client)
+        # disable request singing when credentials are not set
+        if client.config.credentials.nil? or !client.config.credentials.set?
+          client.config.signature_version = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/plugins/dynamodb_simple_attributes.rb

@@ -0,0 +1,179 @@
+module Aws
+  module Plugins
+
+    # Simplifies working with Amazon DynamoDB attribute values.
+    # Translates attribute values for requests and responses to sensible
+    # Ruby natives.
+    #
+    # This plugin is enabled by default for all {DynamoDB::Client}
+    # objects. You can disable this plugin by passing
+    # `simple_attributes: false` to the client constructor:
+    #
+    #     ddb = Aws::DynamoDB::Client.new(simple_attributes: false)
+    #
+    # ## Input Examples
+    #
+    # With this plugin **enabled**, `simple_attributes: true`:
+    #
+    #     dynamodb.put_item(
+    #       table_name: 'aws-sdk',
+    #       item: {
+    #         id: 'uuid',
+    #         age: 35,
+    #         tags: Set.new(%w(simple attributes)),
+    #         data: StringIO.new('data')
+    #       }
+    #     )
+    #
+    # With this plugin **disabled**, `simple_attributes: false`:
+    #
+    #     # note that all types are prefixed in a hash and that
+    #     # numeric types must be serialized as strings
+    #     dynamodb.put_item(
+    #       table_name: 'aws-sdk',
+    #       item: {
+    #         'id' => { s: 'uuid' },
+    #         'age' => { n: '35' },
+    #         'tags' => { ss: ['simple', 'attributes'] },
+    #         'data' => { b: 'data' },
+    #       }
+    #     )
+    #
+    # ## Output Examples
+    #
+    # With this plugin **enabled**, `simple_attributes: true`:
+    #
+    #     resp = dynamodb.get(table_name: 'aws-sdk', key: { id: 'uuid' })
+    #     resp.item
+    #     {
+    #       id: 'uuid',
+    #       age: 35,
+    #       tags: Set.new(%w(simple attributes)),
+    #       data: StringIO.new('data')
+    #     }
+    #
+    # With this plugin **disabled**, `simple_attributes: false`:
+    #
+    #     # note that the request `:key` had to be type prefixed
+    #     resp = dynamodb.get(table_name: 'aws-sdk', key: { 'id' => { s: 'uuid' }})
+    #     resp.item
+    #     # {
+    #     #   "id"=> <struct s='uuid', n=nil, b=nil, ss=nil, ns=nil, bs=nil>,
+    #     #   "age"=> <struct s=nil, n="35", b=nil, ss=nil, ns=nil, bs=nil>,
+    #     #   "tags"=> <struct s=nil, n=nil, b=nil, ss=['simple', 'attributes'], ns=nil, bs=nil>,
+    #     #   "data"=> <struct s=nil, n=nil, b="data", ss=nil, ns=nil, bs=nil>,
+    #     # }
+    #
+    # @seahorse.client.option [Boolean] :simple_attributes (true)
+    #   Enables working with DynamoDB attribute values using simple
+    #   Ruby natives.
+    #
+    #   Disabling this option requires that all attribute values have
+    #   their types specified, e.g. `{ s: 'abc' }` instead of simply
+    #   `'abc'`.
+    #
+    class DynamoDBSimpleAttributes < Seahorse::Client::Plugin
+
+      option(:simple_attributes) { |config| !config.simple_json }
+
+      def add_handlers(handlers, config)
+        if config.simple_attributes
+          handlers.add(Handler, step: :initialize)
+        end
+      end
+
+      class Handler < Seahorse::Client::Handler
+
+        def call(context)
+          context.params = translate_input(context)
+          @handler.call(context).on(200) do |response|
+            response.data = translate_output(response)
+          end
+        end
+
+        private
+
+        def translate_input(context)
+          if shape = context.operation.input
+            ValueTranslator.new(shape, :marshal).apply(context.params)
+          else
+            context.params
+          end
+        end
+
+        def translate_output(response)
+          if shape = response.context.operation.output
+            ValueTranslator.new(shape, :unmarshal).apply(response.data)
+          else
+            response.data
+          end
+        end
+
+      end
+
+      # @api private
+      class ValueTranslator
+
+        # @param [Seahorse::Model::Shapes::Shape] shape
+        # @param [Symbol<:marshal,:unmarshal>] mode
+        def initialize(shape, mode)
+          @shape = shape
+          @mode = mode
+        end
+
+        def apply(values)
+          structure(@shape, values) if @shape
+        end
+
+        private
+
+        def structure(shape, values)
+          if values.is_a?(Struct)
+            values.members.each do |key|
+              values[key] = translate(shape.member(key), values[key])
+            end
+            values
+          elsif values.is_a?(Hash)
+            values.each.with_object({}) do |(key, value), hash|
+              hash[key] = translate(shape.member(key), value)
+            end
+          else
+            values
+          end
+        end
+
+        def list(shape, values)
+          return values unless values.is_a?(Array)
+          values.inject([]) do |list, value|
+            list << translate(shape.member, value)
+          end
+        end
+
+        def map(shape, values)
+          return values unless values.is_a?(Hash)
+          values.each.with_object({}) do |(key, value), hash|
+            hash[key] = translate(shape.value, value)
+          end
+        end
+
+        def translate(shape, value)
+          if shape.name == 'AttributeValue'
+            DynamoDB::AttributeValue.new.send(@mode, value)
+          else
+            translate_complex(shape, value)
+          end
+        end
+
+        def translate_complex(shape, value)
+          case shape
+          when Seahorse::Model::Shapes::Structure then structure(shape, value)
+          when Seahorse::Model::Shapes::List then list(shape, value)
+          when Seahorse::Model::Shapes::Map then map(shape, value)
+          else value
+          end
+        end
+
+      end
+    end
+  end
+end