aws-sdk-core 2.0.2 → 2.0.3

data/lib/aws-sdk-core.rb

@@ -68,7 +68,9 @@ module Aws
   end
 
   autoload :Client, 'aws-sdk-core/client'
+  autoload :ClientPaging, 'aws-sdk-core/client_paging'
   autoload :ClientStubs, 'aws-sdk-core/client_stubs'
+  autoload :ClientWaiters, 'aws-sdk-core/client_waiters'
   autoload :CredentialProviderChain, 'aws-sdk-core/credential_provider_chain'
   autoload :Credentials, 'aws-sdk-core/credentials'
   autoload :EmptyStructure, 'aws-sdk-core/empty_structure'
@@ -216,7 +218,7 @@ module Aws
 
     # @api private
     def load_json(path)
-      MultiJson.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
+      Seahorse::Util.load_json(path)
     end
 
     # Registers a new service.
@@ -259,42 +261,18 @@ module Aws
 
   # build service client classes
   service_added do |name, svc_module, options|
+
     svc_module.const_set(:Client, Client.define(name, options))
     svc_module.const_set(:Errors, Module.new { extend Errors::DynamicErrors })
-  end
-
-  # build service paginators
-  service_added do |name, svc_module, options|
-    paginators = options[:paginators]
-    paginators = case paginators
-      when Paging::Provider then paginators
-      when Hash then Paging::Provider.new(paginators)
-      when String then Paging::Provider.new(Aws.load_json(paginators))
-      when nil then Paging::NullProvider.new
-      else raise ArgumentError, 'invalid :paginators option'
-    end
-    svc_module.const_get(:Client).paginators = paginators
-  end
 
-  # build service waiters
-  service_added do |name, svc_module, options|
-    waiters = options[:waiters]
-    waiters = case waiters
-      when Waiters::Provider then waiters
-      when Hash              then Waiters::Provider.new(waiters)
-      when String            then Waiters::Provider.new(Aws.load_json(waiters))
-      when nil               then Waiters::NullProvider.new
-      else raise ArgumentError, 'invalid :waiters option'
-    end
+    # temporary workaround for issue with S3 waiter definition
     if name == 'S3'
-      # temporary workaround for issue with S3 waiter definition
-      defs = waiters.instance_variable_get("@definitions")
+      defs = svc_module::Client.waiters.instance_variable_get("@definitions")
       defs[:bucket_exists]['ignore_errors'] = ['NotFound']
       defs[:object_exists]['ignore_errors'] = ['NotFound']
       defs[:bucket_not_exists]['success_value'] = 'NotFound'
       defs[:object_not_exists]['success_value'] = 'NotFound'
     end
-    svc_module.const_get(:Client).waiters = waiters
   end
 
 end

data/lib/aws-sdk-core/api/service_customizations.rb

@@ -2,19 +2,6 @@ module Aws
   module Api
     module ServiceCustomizations
 
-      DEFAULT_PLUGINS = [
-        'Seahorse::Client::Plugins::Logging',
-        'Seahorse::Client::Plugins::RestfulBindings',
-        'Seahorse::Client::Plugins::ContentLength',
-        'Aws::Plugins::UserAgent',
-        'Aws::Plugins::RetryErrors',
-        'Aws::Plugins::GlobalConfiguration',
-        'Aws::Plugins::RegionalEndpoint',
-        'Aws::Plugins::ResponsePaging',
-        'Aws::Plugins::RequestSigner',
-        'Aws::Plugins::StubResponses',
-      ]
-
       @customizations = Hash.new {|h,k| h[k] = [] }
 
       class << self
@@ -40,7 +27,7 @@ module Aws
         # @see {#customize}
         # @see {Customizer}
         def apply(client_class)
-          apply_plugins(client_class)
+          apply_protocol_plugin(client_class)
           endpoint_prefix = client_class.api.metadata('endpointPrefix')
           @customizations[endpoint_prefix].each do |customization|
             Customizer.new(client_class).apply(&customization)
@@ -49,17 +36,6 @@ module Aws
 
         private
 
-        def apply_plugins(client_class)
-          apply_default_plugins(client_class)
-          apply_protocol_plugin(client_class)
-        end
-
-        def apply_default_plugins(client_class)
-          DEFAULT_PLUGINS.each do |plugin|
-            client_class.add_plugin(plugin)
-          end
-        end
-
         def apply_protocol_plugin(client_class)
           protocol = client_class.api.metadata('protocol')
           plugin = case protocol
@@ -126,6 +102,11 @@ module Aws
         add_plugin 'Aws::Plugins::S3Redirects'
         add_plugin 'Aws::Plugins::S3SseCpk'
         add_plugin 'Aws::Plugins::S3UrlEncodedKeys'
+        defs = client_class.waiters.instance_variable_get("@definitions")
+        defs[:bucket_exists]['ignore_errors'] = ['NotFound']
+        defs[:object_exists]['ignore_errors'] = ['NotFound']
+        defs[:bucket_not_exists]['success_value'] = 'NotFound'
+        defs[:object_not_exists]['success_value'] = 'NotFound'
       end
 
       customize 'sqs' do

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

@@ -2,85 +2,21 @@ module Aws
   # Base class for all {Aws} service clients.
   class Client < Seahorse::Client::Base
 
+    # @api private
+    DEFAULT_PLUGINS = [
+      'Seahorse::Client::Plugins::Logging',
+      'Seahorse::Client::Plugins::RestfulBindings',
+      'Seahorse::Client::Plugins::ContentLength',
+      'Aws::Plugins::UserAgent',
+      'Aws::Plugins::RetryErrors',
+      'Aws::Plugins::GlobalConfiguration',
+      'Aws::Plugins::RegionalEndpoint',
+      'Aws::Plugins::RequestSigner',
+    ]
+
+    include ClientPaging
     include ClientStubs
-
-    # Waits until a particular condition is satisfied. This works by
-    # polling a client request and checking for particular response
-    # data or errors. Waiters each have a default duration max attempts
-    # which are configurable.  Additionally, you can register callbacks
-    # and stop waiters by throwing `:success` or `:failure`.
-    #
-    # @example Basic usage
-    #   client.wait_until(:waiter_name)
-    #
-    # @example Configuring interval and maximum attempts
-    #   client.wait_until(:waiter_name) do |w|
-    #     w.interval = 10    # number of seconds to sleep between attempts
-    #     w.max_attempts = 6 # maximum number of polling attempts
-    #   end
-    #
-    # @example Rescuing a failed wait
-    #   begin
-    #     client.wait_until(:waiter_name)
-    #   rescue Aws::Waiters::Errors::WaiterFailed
-    #     # gave up waiting
-    #   end
-    #
-    # @example Waiting with progress callbacks
-    #   client.wait_until(:waiter_name) do |w|
-    #
-    #     # yields just before polling for change
-    #     w.before_attempt do |attempt|
-    #       # attempts - number of previous attempts made
-    #     end
-    #
-    #     # yields before sleeping
-    #     w.before_wait do |attempt, prev_response|
-    #       # attempts - number of previous attempts made
-    #       # prev_response - the last client response received
-    #     end
-    #   end
-    #
-    # @example Throw :success or :failure to terminate early
-    #   # wait for an hour, not for a number of requests
-    #   client.wait_until(:waiter_name) do |waiter|
-    #     one_hour = Time.now + 3600
-    #     waiter.max_attempts = nil
-    #     waiter.before_attempt do |attempt|
-    #       throw(:failure, 'waited to long') if Time.now > one_hour
-    #     end
-    #   end
-    #
-    # @param [Symbol] waiter_name The name of the waiter. See {#waiter_names}
-    #   for a full list of supported waiters.
-    # @param [Hash] params Additional request parameters. See the {#waiter_names}
-    #   for a list of supported waiters and what request they call. The
-    #   called request determines the list of accepted parameters.
-    # @return [Seahorse::Client::Response] Returns the client response from
-    #   the successful polling request. If `:success` is thrown from a callback,
-    #   then the 2nd argument to `#throw` is returned.
-    # @yieldparam [Waiters::Waiter] waiter Yields a {Waiters::Waiter Waiter} 
-    #   object that can be configured prior to waiting.
-    # @raise [Waiters::Errors::NoSuchWaiter] Raised when the named waiter
-    #   is not defined.
-    # @raise [Waiters::Errors::WaiterFailed] Raised when one of the
-    #   following conditions is met:
-    #
-    #   * A failure condition is detected
-    #   * The maximum number of attempts has been made without success
-    #   * `:failure` is thrown from a callback
-    #
-    def wait_until(waiter_name, params = {}, &block)
-      waiter = self.class.waiters.waiter(waiter_name)
-      yield(waiter) if block_given?
-      waiter.wait(self, params)
-    end
-
-    # Returns the list of supported waiters.
-    # @return [Array<Symbol>]
-    def waiter_names
-      self.class.waiters.waiter_names
-    end
+    include ClientWaiters
 
     class << self
 
@@ -88,35 +24,18 @@ module Aws
       # @api private
       attr_accessor :identifier
 
-      # @return [Paging::Provider]
-      # @api private
-      attr_accessor :paginators
-
-      # @return [Waiters::Provider]
-      # @api private
-      attr_accessor :waiters
-
       # @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, :paginators, :waiters].each do |definition|
+          client_class.send("set_#{definition}", options[definition])
+        end
+        DEFAULT_PLUGINS.each { |plugin| client_class.add_plugin(plugin) }
         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))
-        when nil then Seahorse::Model::Api.new({})
-        else raise ArgumentError, "invalid api definition #{api}"
-        end
-      end
-
     end
   end
 end

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

@@ -0,0 +1,29 @@
+module Aws
+  # @api private
+  module ClientPaging
+
+    # @api private
+    def self.included(subclass)
+
+      subclass.add_plugin('Aws::Plugins::ResponsePaging')
+
+      class << subclass
+
+        def set_paginators(paginators)
+          @paginators = case paginators
+            when Paging::Provider then paginators
+            when Hash then Paging::Provider.new(paginators)
+            when String then Paging::Provider.new(Aws.load_json(paginators))
+            when nil then Paging::NullProvider.new
+            else raise ArgumentError, 'invalid paginators'
+          end
+        end
+
+        def paginators
+          @paginators
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Aws
 
   # This module provides the ability to specify the data and/or errors to
@@ -6,8 +8,14 @@ module Aws
   # behavior.
   module ClientStubs
 
+    # @api private
+    def self.included(subclass)
+      subclass.add_plugin('Aws::Plugins::StubResponses')
+    end
+
     def initialize(*args)
       @stubs = {}
+      @stub_mutex = Mutex.new
       super
     end
 
@@ -83,11 +91,13 @@ module Aws
 
     # @api private
     def next_stub(operation_name)
-      stubs = @stubs[operation_name.to_sym] || []
-      case stubs.length
-      when 0 then new_stub(operation_name)
-      when 1 then stubs.first
-      else stubs.shift
+      @stub_mutex.synchronize do
+        stubs = @stubs[operation_name.to_sym] || []
+        case stubs.length
+        when 0 then new_stub(operation_name)
+        when 1 then stubs.first
+        else stubs.shift
+        end
       end
     end
 
@@ -101,12 +111,14 @@ module Aws
     end
 
     def apply_stubs(operation_name, stubs)
-      @stubs[operation_name.to_sym] = stubs.map do |stub|
-        case stub
-        when Exception then stub
-        when String then service_error_class(stub)
-        when Hash then new_stub(operation_name, stub)
-        else stub
+      @stub_mutex.synchronize do
+        @stubs[operation_name.to_sym] = stubs.map do |stub|
+          case stub
+          when Exception then stub
+          when String then service_error_class(stub)
+          when Hash then new_stub(operation_name, stub)
+          else stub
+          end
         end
       end
     end

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

@@ -0,0 +1,105 @@
+module Aws
+  module ClientWaiters
+
+    # @api private
+    def self.included(subclass)
+      class << subclass
+
+        def set_waiters(waiters)
+          @waiters =
+            case waiters
+            when Waiters::Provider then waiters
+            when Hash then Waiters::Provider.new(waiters)
+            when String then Waiters::Provider.new(Aws.load_json(waiters))
+            when nil then Waiters::NullProvider.new
+            else raise ArgumentError, 'invalid waiters'
+            end
+        end
+
+        def waiters
+          @waiters
+        end
+
+      end
+    end
+
+    # Waits until a particular condition is satisfied. This works by
+    # polling a client request and checking for particular response
+    # data or errors. Waiters each have a default duration max attempts
+    # which are configurable.  Additionally, you can register callbacks
+    # and stop waiters by throwing `:success` or `:failure`.
+    #
+    # @example Basic usage
+    #   client.wait_until(:waiter_name)
+    #
+    # @example Configuring interval and maximum attempts
+    #   client.wait_until(:waiter_name) do |w|
+    #     w.interval = 10    # number of seconds to sleep between attempts
+    #     w.max_attempts = 6 # maximum number of polling attempts
+    #   end
+    #
+    # @example Rescuing a failed wait
+    #   begin
+    #     client.wait_until(:waiter_name)
+    #   rescue Aws::Waiters::Errors::WaiterFailed
+    #     # gave up waiting
+    #   end
+    #
+    # @example Waiting with progress callbacks
+    #   client.wait_until(:waiter_name) do |w|
+    #
+    #     # yields just before polling for change
+    #     w.before_attempt do |attempt|
+    #       # attempts - number of previous attempts made
+    #     end
+    #
+    #     # yields before sleeping
+    #     w.before_wait do |attempt, prev_response|
+    #       # attempts - number of previous attempts made
+    #       # prev_response - the last client response received
+    #     end
+    #   end
+    #
+    # @example Throw :success or :failure to terminate early
+    #   # wait for an hour, not for a number of requests
+    #   client.wait_until(:waiter_name) do |waiter|
+    #     one_hour = Time.now + 3600
+    #     waiter.max_attempts = nil
+    #     waiter.before_attempt do |attempt|
+    #       throw(:failure, 'waited to long') if Time.now > one_hour
+    #     end
+    #   end
+    #
+    # @param [Symbol] waiter_name The name of the waiter. See {#waiter_names}
+    #   for a full list of supported waiters.
+    # @param [Hash] params Additional request parameters. See the {#waiter_names}
+    #   for a list of supported waiters and what request they call. The
+    #   called request determines the list of accepted parameters.
+    # @return [Seahorse::Client::Response] Returns the client response from
+    #   the successful polling request. If `:success` is thrown from a callback,
+    #   then the 2nd argument to `#throw` is returned.
+    # @yieldparam [Waiters::Waiter] waiter Yields a {Waiters::Waiter Waiter} 
+    #   object that can be configured prior to waiting.
+    # @raise [Waiters::Errors::NoSuchWaiter] Raised when the named waiter
+    #   is not defined.
+    # @raise [Waiters::Errors::WaiterFailed] Raised when one of the
+    #   following conditions is met:
+    #
+    #   * A failure condition is detected
+    #   * The maximum number of attempts has been made without success
+    #   * `:failure` is thrown from a callback
+    #
+    def wait_until(waiter_name, params = {}, &block)
+      waiter = self.class.waiters.waiter(waiter_name)
+      yield(waiter) if block_given?
+      waiter.wait(self, params)
+    end
+
+    # Returns the list of supported waiters.
+    # @return [Array<Symbol>]
+    def waiter_names
+      self.class.waiters.waiter_names
+    end
+
+  end
+end