aws-sdk-core 2.0.48 → 2.1.0

data/lib/aws-sdk-core/credential_provider_chain.rb

@@ -6,10 +6,11 @@ module Aws
       @config = config
     end
 
+    # @return [CredentialProvider, nil]
     def resolve
       providers.each do |method_name, options|
-        credentials = send(method_name, options.merge(config: @config))
-        return credentials if credentials && credentials.set?
+        provider = send(method_name, options.merge(config: @config))
+        return provider if provider && provider.set?
       end
       nil
     end

data/lib/aws-sdk-core/credentials.rb

@@ -19,6 +19,11 @@ module Aws
     # @return [String, nil]
     attr_reader :session_token
 
+    # @return [Credentials]
+    def credentials
+      self
+    end
+
     # @return [Boolean] Returns `true` if the access key id and secret
     #   access key are both set.
     def set?

data/lib/aws-sdk-core/deprecations.rb

@@ -0,0 +1,69 @@
+module Aws
+
+  # A utility module that provides a class method that wraps
+  # a method such that it generates a deprecation warning when called.
+  # Given the following class:
+  #
+  #     class Example
+  #
+  #       def do_something
+  #       end
+  #
+  #     end
+  #
+  # If you want to deprecate the `#do_something` method, you can extend
+  # this module and then call `deprecated` on the method (after it
+  # has been defined).
+  #
+  #     class Example
+  #
+  #       extend Aws::Deprecations
+  #
+  #       def do_something
+  #       end
+  #
+  #       def do_something_else
+  #       end
+  #
+  #       deprecated :do_something
+  #
+  #     end
+  #
+  # The `#do_something` method will continue to function, but will
+  # generate a deprecation warning when called.
+  #
+  # @api private
+  module Deprecations
+
+    # @param [Symbol] method_name The name of the deprecated method.
+    #
+    # @option options [String] :message The warning message to issue
+    #   when the deprecated method is called.
+    #
+    # @option options [Symbol] :use The name of an use
+    #   method that should be used.
+    #
+    def deprecated(method_name, options = {})
+
+      deprecation_msg = options[:message] || begin
+        msg = "DEPRECATION WARNING: called deprecated method `#{method_name}' "
+        msg << "of an #{self}"
+        msg << ", use #{options[:use]} instead" if options[:use]
+        msg
+      end
+
+      alias_method(:"deprecated_#{method_name}", method_name)
+
+      warned = false # we only want to issue this warning once
+
+      define_method(method_name) do |*args,&block|
+        unless warned
+          warned = true
+          warn(deprecation_msg + "\n" + caller.join("\n"))
+        end
+        send("deprecated_#{method_name}", *args, &block)
+      end
+    end
+
+  end
+end

data/lib/aws-sdk-core/dynamodb.rb

@@ -9,5 +9,17 @@ Aws.add_service(:DynamoDB, {
 module Aws
   module DynamoDB
     autoload :AttributeValue, 'aws-sdk-core/dynamodb/attribute_value'
+
+    class Client
+      def data_to_http_resp(operation_name, data)
+        api = config.api
+        operation = api.operation(operation_name)
+        translator = Plugins::DynamoDBSimpleAttributes::ValueTranslator
+        translator = translator.new(operation.output, :marshal)
+        data = translator.apply(data)
+        ParamValidator.validate!(operation.output, data)
+        protocol_helper.stub_data(api, operation, data)
+      end
+    end
   end
 end

data/lib/aws-sdk-core/eager_loader.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+module Aws
+  # @api private
+  class EagerLoader
+
+    def initialize
+      @loaded = Set.new
+    end
+
+    # @return [Set<Module>]
+    attr_reader :loaded
+
+    # @param [Module] klass_or_module
+    # @return [self]
+    def load(klass_or_module)
+      @loaded << klass_or_module
+      klass_or_module.constants.each do |const_name|
+        path = klass_or_module.autoload?(const_name)
+        require(path) if path
+        const = klass_or_module.const_get(const_name)
+        if const.is_a?(Module)
+          unless @loaded.include?(const)
+            load(const)
+          end
+        end
+      end
+      self
+    end
+  end
+end

data/lib/aws-sdk-core/ecs.rb

@@ -1,4 +1,6 @@
 Aws.add_service(:ECS, {
   api: "#{Aws::API_DIR}/ecs/2014-11-13/api-2.json",
   docs: "#{Aws::API_DIR}/ecs/2014-11-13/docs-2.json",
+  paginators: "#{Aws::API_DIR}/ecs/2014-11-13/paginators-1.json",
+  waiters: "#{Aws::API_DIR}/ecs/2014-11-13/waiters-2.json",
 })

data/lib/aws-sdk-core/empty_structure.rb

@@ -1,84 +1,3 @@
 module Aws
-  class EmptyStructure < Structure
-
-    def self.new
-      super([])
-    end
-
-    def ==(other)
-      other.is_a?(EmptyStructure)
-    end
-
-    def [](member_name)
-      raise NameError, "no member '#{member_name}' in struct"
-    end
-
-    def []=(member_name, value)
-      raise NameError, "no member '#{member_name}' in struct"
-    end
-
-    def each(&block)
-      unless block_given?
-        [].to_enum
-      end
-    end
-
-    def each_pair(&block)
-      unless block_given?
-        {}.to_enum
-      end
-    end
-
-    def eql?(other)
-      other.is_a?(EmptyStructure)
-    end
-
-    # @api private
-    def inspect
-      '#<struct>'
-    end
-
-    # @api private
-    def pretty_print(q)
-      q.text(inspect)
-    end
-
-    def length
-      0
-    end
-
-    def members
-      []
-    end
-
-    def select(&block)
-      []
-    end
-
-    def size
-      0
-    end
-
-    def to_a
-      []
-    end
-
-    def to_h
-      {}
-    end
-
-    def values
-      []
-    end
-
-    def values_at(*selector)
-      if selector.empty?
-        []
-      else
-        offset = selector.first
-        raise IndexError, "offset #{offset} too large for struct(size:0)"
-      end
-    end
-
-  end
+  EmptyStructure = Class.new(Structure.new('AwsEmptyStructure'))
 end

data/lib/aws-sdk-core/endpoint_provider.rb

@@ -6,7 +6,7 @@ module Aws
     PATH = File.join(File.dirname(__FILE__), '..', '..', 'endpoints.json')
 
     # @api private
-    RULES = MultiJson.load(File.read(PATH))['endpoints']
+    RULES = Json.load_file(PATH)['endpoints']
 
     class << self
 

data/lib/aws-sdk-core/instance_profile_credentials.rb

@@ -2,8 +2,9 @@ require 'time'
 require 'net/http'
 
 module Aws
-  class InstanceProfileCredentials < Credentials
+  class InstanceProfileCredentials
 
+    include CredentialProvider
     include RefreshingCredentials
 
     # @api private
@@ -64,15 +65,13 @@ module Aws
     end
 
     def refresh
-      credentials = MultiJson.load(get_credentials)
-      @access_key_id = credentials['AccessKeyId']
-      @secret_access_key = credentials['SecretAccessKey']
-      @session_token = credentials['Token']
-      if expires = credentials['Expiration']
-        @expiration = Time.parse(expires)
-      else
-        @expiration = nil
-      end
+      c = Json.load(get_credentials)
+      @credentials = Credentials.new(
+        c['AccessKeyId'],
+        c['SecretAccessKey'],
+        c['Token']
+      )
+      @expiration = c['Expiration'] ? Time.parse(c['Expiration']) : nil
     end
 
     def get_credentials

data/lib/aws-sdk-core/json.rb

@@ -0,0 +1,56 @@
+module Aws
+  # @api private
+  module Json
+
+    autoload :Builder, 'aws-sdk-core/json/builder'
+    autoload :ErrorHandler, 'aws-sdk-core/json/error_handler'
+    autoload :Handler, 'aws-sdk-core/json/handler'
+    autoload :Parser, 'aws-sdk-core/json/parser'
+
+    class ParseError < StandardError
+
+      def initialize(error)
+        @error = error
+        super(error.message)
+      end
+
+      attr_reader :error
+
+    end
+
+    class << self
+
+      def load(json)
+        ENGINE.load(json)
+      rescue ENGINE_ERROR => e
+        raise ParseError.new(e)
+      end
+
+      def load_file(path)
+        self.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
+      end
+
+      def dump(value)
+        ENGINE.dump(value)
+      end
+
+      private
+
+      def oj_engine
+        require 'oj'
+        [Oj, Oj::ParseError]
+      rescue LoadError
+        false
+      end
+
+      def json_engine
+        require 'json'
+        [JSON, JSON::ParserError]
+      end
+
+    end
+
+    ENGINE, ENGINE_ERROR = oj_engine || json_engine
+
+  end
+end

data/lib/aws-sdk-core/json/builder.rb

@@ -4,58 +4,57 @@ module Aws
   module Json
     class Builder
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Hash] params
-      # @return [String<JSON>]
-      def to_json(shape, params)
-        MultiJson.dump(format(shape, params))
+      include Seahorse::Model::Shapes
+
+      def initialize(rules)
+        @rules = rules
+      end
+
+      def to_json(params)
+        Json.dump(format(@rules, params))
       end
+      alias serialize to_json
 
       private
 
-      # @param [Seahorse::Model::Shapes::Structure] structure
-      # @param [Hash] values
-      # @return [Hash]
-      def structure(structure, values)
-        values.each.with_object({}) do |(key, value), data|
-          if structure.member?(key) && !value.nil?
-            member_shape = structure.member(key)
-            name = member_shape.location_name || key
-            data[name] = format(member_shape, value)
+      def structure(ref, values)
+        shape = ref.shape
+        values.each_pair.with_object({}) do |(key, value), data|
+          if shape.member?(key) && !value.nil?
+            member_ref = shape.member(key)
+            member_name = member_ref.location_name || key
+            data[member_name] = format(member_ref, value)
           end
         end
       end
 
-      # @param [Seahorse::Model::Shapes::List] list
-      # @param [Array] values
-      # @return [Array]
-      def list(list, values)
-        values.collect { |value| format(list.member, value) }
+      def list(ref, values)
+        member_ref = ref.shape.member
+        values.collect { |value| format(member_ref, value) }
       end
 
-      # @param [Seahorse::Model::Shapes::Map] map
-      # @param [Hash] values
-      # @return [Hash]
-      def map(map, values)
+      def map(ref, values)
+        value_ref = ref.shape.value
         values.each.with_object({}) do |(key, value), data|
-          data[key] = format(map.value, value)
+          data[key] = format(value_ref, value)
         end
       end
 
-      # @param [Seahorse::Model::Shapes::Shape] shape
-      # @param [Object] value
-      # @return [Object]
-      def format(shape, value)
-        case shape.type
-        when 'structure' then structure(shape, value)
-        when 'list'      then list(shape, value)
-        when 'map'       then map(shape, value)
-        when 'timestamp' then shape.format_time(value, 'unixTimestamp')
-        when 'blob'      then Base64.strict_encode64(value.read)
+      def format(ref, value)
+        case ref.shape
+        when StructureShape then structure(ref, value)
+        when ListShape      then list(ref, value)
+        when MapShape       then map(ref, value)
+        when TimestampShape then value.to_i
+        when BlobShape      then encode(value)
         else value
         end
       end
 
+      def encode(blob)
+        Base64.strict_encode64(String === blob ? blob : blob.read)
+      end
+
     end
   end
 end

data/lib/aws-sdk-core/json/error_handler.rb

@@ -14,11 +14,11 @@ module Aws
       private
 
       def extract_error(body, context)
-        json = MultiJson.load(body)
+        json = Json.load(body)
         code = error_code(json, context)
         message = error_message(code, json)
         [code, message]
-      rescue MultiJson::ParseError
+      rescue Json::ParseError
         [http_status_error_code(context), '']
       end