aws-sdk-core 2.11.549

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

@@ -0,0 +1,6 @@
+Aws.add_service(:AutoScalingPlans, {
+  api: "#{Aws::API_DIR}/autoscaling-plans/2018-01-06/api-2.json",
+  docs: "#{Aws::API_DIR}/autoscaling-plans/2018-01-06/docs-2.json",
+  examples: "#{Aws::API_DIR}/autoscaling-plans/2018-01-06/examples-1.json",
+  paginators: "#{Aws::API_DIR}/autoscaling-plans/2018-01-06/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:Backup, {
+  api: "#{Aws::API_DIR}/backup/2018-11-15/api-2.json",
+  docs: "#{Aws::API_DIR}/backup/2018-11-15/docs-2.json",
+  examples: "#{Aws::API_DIR}/backup/2018-11-15/examples-1.json",
+  paginators: "#{Aws::API_DIR}/backup/2018-11-15/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:Batch, {
+  api: "#{Aws::API_DIR}/batch/2016-08-10/api-2.json",
+  docs: "#{Aws::API_DIR}/batch/2016-08-10/docs-2.json",
+  examples: "#{Aws::API_DIR}/batch/2016-08-10/examples-1.json",
+  paginators: "#{Aws::API_DIR}/batch/2016-08-10/paginators-1.json",
+})

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

@@ -0,0 +1,6 @@
+Aws.add_service(:Budgets, {
+  api: "#{Aws::API_DIR}/budgets/2016-10-20/api-2.json",
+  docs: "#{Aws::API_DIR}/budgets/2016-10-20/docs-2.json",
+  examples: "#{Aws::API_DIR}/budgets/2016-10-20/examples-1.json",
+  paginators: "#{Aws::API_DIR}/budgets/2016-10-20/paginators-1.json",
+})

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

@@ -0,0 +1,51 @@
+require 'openssl'
+require 'tempfile'
+
+module Aws
+  # @api private
+  module Checksums
+
+    CHUNK_SIZE = 1 * 1024 * 1024 # one MB
+
+    class << self
+
+      # @param [File, Tempfile, IO#read, String] value
+      # @return [String<SHA256 Hexdigest>]
+      def sha256_hexdigest(value)
+        if (File === value || Tempfile === value) && !value.path.nil? && File.exist?(value.path)
+          OpenSSL::Digest::SHA256.file(value).hexdigest
+        elsif value.respond_to?(:read)
+          sha256 = OpenSSL::Digest::SHA256.new
+          update_in_chunks(sha256, value)
+          sha256.hexdigest
+        else
+          OpenSSL::Digest::SHA256.hexdigest(value)
+        end
+      end
+
+      # @param [File, Tempfile, IO#read, String] value
+      # @return [String<MD5>]
+      def md5(value)
+        if (File === value || Tempfile === value) && !value.path.nil? && File.exist?(value.path)
+          Base64.encode64(OpenSSL::Digest::MD5.file(value).digest).strip
+        elsif value.respond_to?(:read)
+          md5 = OpenSSL::Digest::MD5.new
+          update_in_chunks(md5, value)
+          Base64.encode64(md5.digest).strip
+        else
+          Base64.encode64(OpenSSL::Digest::MD5.digest(value)).strip
+        end
+      end
+
+      private
+
+      def update_in_chunks(digest, io)
+        while chunk = io.read(CHUNK_SIZE)
+          digest.update(chunk)
+        end
+        io.rewind
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+Aws.add_service(:Chime, {
+  api: "#{Aws::API_DIR}/chime/2018-05-01/api-2.json",
+  docs: "#{Aws::API_DIR}/chime/2018-05-01/docs-2.json",
+  examples: "#{Aws::API_DIR}/chime/2018-05-01/examples-1.json",
+  paginators: "#{Aws::API_DIR}/chime/2018-05-01/paginators-1.json",
+})

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

@@ -0,0 +1,78 @@
+module Aws
+  # Base class for all {Aws} service clients.
+  class Client < Seahorse::Client::Base
+
+    # @api private
+    DEFAULT_PLUGINS = [
+      'Seahorse::Client::Plugins::ContentLength',
+      'Aws::Plugins::Logging',
+      'Aws::Plugins::ParamConverter',
+      'Aws::Plugins::ParamValidator',
+      'Aws::Plugins::UserAgent',
+      'Aws::Plugins::HelpfulSocketErrors',
+      'Aws::Plugins::RetryErrors',
+      'Aws::Plugins::GlobalConfiguration',
+      'Aws::Plugins::RegionalEndpoint',
+      'Aws::Plugins::RequestSigner',
+      'Aws::Plugins::ResponsePaging',
+      'Aws::Plugins::StubResponses',
+      'Aws::Plugins::IdempotencyToken',
+      'Aws::Plugins::JsonvalueConverter',
+      'Aws::Plugins::EndpointDiscovery',
+      'Aws::Plugins::EndpointPattern'
+    ]
+
+    # @api private
+    PROTOCOL_PLUGINS = Hash.new(DEFAULT_PLUGINS).merge({
+      'json'      => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::JsonRpc),
+      'rest-json' => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::RestJson),
+      'rest-xml'  => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::RestXml),
+      'query'     => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::Query),
+      'ec2'       => DEFAULT_PLUGINS + %w(Aws::Plugins::Protocols::EC2),
+    })
+
+    include ClientStubs
+    include ClientWaiters
+
+    class << self
+
+      # @return [Symbol]
+      # @api private
+      attr_accessor :identifier
+
+      # @api private
+      def define(svc_name, options)
+        client_class = Class.new(self)
+        client_class.identifier = svc_name.downcase.to_sym
+        client_class.set_api(Api::Builder.build(options[:api], options))
+        client_class.set_waiters(options[:waiters])
+
+        protocol = client_class.api.metadata['protocol']
+        PROTOCOL_PLUGINS[protocol].each do |plugin|
+          client_class.add_plugin(plugin)
+        end
+
+        Api::Customizations.apply_plugins(client_class)
+
+        soft_deprecation
+        client_class
+      end
+
+      private
+
+      def soft_deprecation
+        unless @warned
+          @warned = true
+          warn(
+            "Version 2 of the Ruby SDK will enter maintenance mode as of "\
+            "November 20, 2020. To continue receiving service updates and new "\
+            "features, please upgrade to Version 3. More information can be "\
+            "found here: https://aws.amazon.com/blogs/developer/"\
+            "deprecation-schedule-for-aws-sdk-for-ruby-v2/"
+          )
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,307 @@
+require 'thread'
+
+module Aws
+
+  # This module provides the ability to specify the data and/or errors to
+  # return when a client is using stubbed responses. Pass
+  # `:stub_responses => true` to a client constructor to enable this
+  # behavior.
+  module ClientStubs
+
+    # @api private
+    def setup_stubbing
+      @stubs = {}
+      @stub_mutex = Mutex.new
+      if Hash === @config.stub_responses
+        @config.stub_responses.each do |operation_name, stubs|
+          apply_stubs(operation_name, Array === stubs ? stubs : [stubs])
+        end
+        @config.stub_responses = true
+      end
+
+      # When a client is stubbed allow the user to access the requests made
+      @api_requests = []
+
+      requests = @api_requests
+      self.handle do |context|
+        requests << {
+          operation_name: context.operation_name,
+          params: context.params,
+          context: context
+        }
+        @handler.call(context)
+      end
+    end
+
+    # Configures what data / errors should be returned from the named operation
+    # when response stubbing is enabled.
+    #
+    # ## Basic usage
+    #
+    # When you enable response stubbing, the client will generate fake
+    # responses and will not make any HTTP requests.
+    #
+    #     client = Aws::S3::Client.new(stub_responses: true)
+    #     client.list_buckets
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput buckets=[], owner=nil>
+    #
+    # You can provide stub data that will be returned by the client.
+    #
+    #     # stub data in the constructor
+    #     client = Aws::S3::Client.new(stub_responses: {
+    #       list_buckets: { buckets: [{name: 'my-bucket' }] },
+    #       get_object: { body: 'data' },
+    #     })
+    #
+    #     client.list_buckets.buckets.map(&:name) #=> ['my-bucket']
+    #     client.get_object(bucket:'name', key:'key').body.read #=> 'data'
+    #
+    # You can also specify the stub data using {#stub_responses}
+    #
+    #     client = Aws::S3::Client.new(stub_responses: true)
+    #     client.stub_responses(:list_buckets, {
+    #       buckets: [{ name: 'my-bucket' }]
+    #     })
+    #
+    #     client.list_buckets.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    # With a Resource class {#stub_responses} on the corresponding client:
+    #
+    #     s3 = Aws::S3::Resource.new(stub_responses: true)
+    #     s3.client.stub_responses(:list_buckets, {
+    #       buckets: [{ name: 'my-bucket' }]
+    #     })
+    #
+    #     s3.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    # Lastly, default stubs can be configured via `Aws.config`:
+    #
+    #     Aws.config[:s3] = {
+    #       stub_responses: {
+    #         list_buckets: { buckets: [{name: 'my-bucket' }] }
+    #       }
+    #     }
+    #
+    #     Aws::S3::Client.new.list_buckets.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    #     Aws::S3::Resource.new.buckets.map(&:name)
+    #     #=> ['my-bucket']
+    #
+    # ## Dynamic Stubbing
+    #
+    # In addition to creating static stubs, it's also possible to generate
+    # stubs dynamically based on the parameters with which operations were
+    # called, by passing a `Proc` object:
+    #
+    #     s3 = Aws::S3::Resource.new(stub_responses: true)
+    #     s3.client.stub_responses(:put_object, -> (context) {
+    #       s3.client.stub_responses(:get_object, content_type: context.params[:content_type])
+    #     })
+    #
+    # The yielded object is an instance of {Seahorse::Client::RequestContext}.
+    #
+    # ## Stubbing Errors
+    #
+    # When stubbing is enabled, the SDK will default to generate
+    # fake responses with placeholder values. You can override the data
+    # returned. You can also specify errors it should raise.
+    #
+    #     # simulate service errors, give the error code
+    #     client.stub_responses(:get_object, 'NotFound')
+    #     client.get_object(bucket:'aws-sdk', key:'foo')
+    #     #=> raises Aws::S3::Errors::NotFound
+    #
+    #     # to simulate other errors, give the error class, you must
+    #     # be able to construct an instance with `.new`
+    #     client.stub_responses(:get_object, Timeout::Error)
+    #     client.get_object(bucket:'aws-sdk', key:'foo')
+    #     #=> raises new Timeout::Error
+    #
+    #     # or you can give an instance of an error class
+    #     client.stub_responses(:get_object, RuntimeError.new('custom message'))
+    #     client.get_object(bucket:'aws-sdk', key:'foo')
+    #     #=> raises the given runtime error object
+    #
+    # ## Stubbing HTTP Responses
+    #
+    # As an alternative to providing the response data, you can provide
+    # an HTTP response.
+    #
+    #     client.stub_responses(:get_object, {
+    #       status_code: 200,
+    #       headers: { 'header-name' => 'header-value' },
+    #       body: "...",
+    #     })
+    #
+    # To stub a HTTP response, pass a Hash with all three of the following
+    # keys set:
+    #
+    # * **`:status_code`** - <Integer> - The HTTP status code
+    # * **`:headers`** - Hash<String,String> - A hash of HTTP header keys and values
+    # * **`:body`** - <String,IO> - The HTTP response body.
+    #
+    # ## Stubbing Multiple Responses
+    #
+    # Calling an operation multiple times will return similar responses.
+    # You can configure multiple stubs and they will be returned in sequence.
+    #
+    #     client.stub_responses(:head_object, [
+    #       'NotFound',
+    #       { content_length: 150 },
+    #     ])
+    #
+    #     client.head_object(bucket:'aws-sdk', key:'foo')
+    #     #=> raises Aws::S3::Errors::NotFound
+    #
+    #     resp = client.head_object(bucket:'aws-sdk', key:'foo')
+    #     resp.content_length #=> 150
+    #
+    # @param [Symbol] operation_name
+    #
+    # @param [Mixed] stubs One or more responses to return from the named
+    #   operation.
+    #
+    # @return [void]
+    #
+    # @raise [RuntimeError] Raises a runtime error when called
+    #   on a client that has not enabled response stubbing via
+    #   `:stub_responses => true`.
+    #
+    def stub_responses(operation_name, *stubs)
+      if config.stub_responses
+        apply_stubs(operation_name, stubs.flatten)
+      else
+        msg = 'stubbing is not enabled; enable stubbing in the constructor '
+        msg << 'with `:stub_responses => true`'
+        raise msg
+      end
+    end
+
+    # Allows you to access all of the requests that the stubbed client has made
+    #
+    # @params [Boolean] exclude_presign Setting to true for filtering out not sent requests from
+    #                 generating presigned urls. Default to false.
+    # @return [Array] Returns an array of the api requests made, each request object contains the
+    #                 :operation_name, :params, and :context of the request. 
+    # @raise [NotImplementedError] Raises `NotImplementedError` when the client is not stubbed
+    def api_requests(options = {})
+      if config.stub_responses
+        if options[:exclude_presign]
+          @api_requests.reject {|req| req[:context][:presigned_url] }
+        else
+          @api_requests
+        end
+      else
+        msg = 'This method is only implemented for stubbed clients, and is '
+        msg << 'available when you enable stubbing in the constructor with `stub_responses: true`'
+        raise NotImplementedError.new(msg)
+      end
+    end
+
+    # Generates and returns stubbed response data from the named operation.
+    #
+    #     s3 = Aws::S3::Client.new
+    #     s3.stub_data(:list_buckets)
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput buckets=[], owner=#<struct Aws::S3::Types::Owner display_name="DisplayName", id="ID">>
+    #
+    # In addition to generating default stubs, you can provide data to
+    # apply to the response stub.
+    #
+    #     s3.stub_data(:list_buckets, buckets:[{name:'aws-sdk'}])
+    #     #=> #<struct Aws::S3::Types::ListBucketsOutput
+    #       buckets=[#<struct Aws::S3::Types::Bucket name="aws-sdk", creation_date=nil>],
+    #       owner=#<struct Aws::S3::Types::Owner display_name="DisplayName", id="ID">>
+    #
+    # @param [Symbol] operation_name
+    # @param [Hash] data
+    # @return [Structure] Returns a stubbed response data structure. The
+    #   actual class returned will depend on the given `operation_name`.
+    def stub_data(operation_name, data = {})
+      Stubbing::StubData.new(operation(operation_name)).stub(data)
+    end
+
+    # @api private
+    def next_stub(context)
+      operation_name = context.operation_name.to_sym
+      stub = @stub_mutex.synchronize do
+        stubs = @stubs[operation_name] || []
+        case stubs.length
+        when 0 then default_stub(operation_name)
+        when 1 then stubs.first
+        else stubs.shift
+        end
+      end
+      Proc === stub ? convert_stub(operation_name, stub.call(context)) : stub
+    end
+
+    private
+
+    def default_stub(operation_name)
+      stub = stub_data(operation_name)
+      http_response_stub(operation_name, stub)
+    end
+
+    # This method converts the given stub data and converts it to a
+    # HTTP response (when possible). This enables the response stubbing
+    # plugin to provide a HTTP response that triggers all normal events
+    # during response handling.
+    def apply_stubs(operation_name, stubs)
+      @stub_mutex.synchronize do
+        @stubs[operation_name.to_sym] = stubs.map do |stub|
+          convert_stub(operation_name, stub)
+        end
+      end
+    end
+
+    def convert_stub(operation_name, stub)
+      case stub
+      when Proc then stub
+      when Exception, Class then { error: stub }
+      when String then service_error_stub(stub)
+      when Hash then http_response_stub(operation_name, stub)
+      else { data: stub }
+      end
+    end
+
+    def service_error_stub(error_code)
+      { http: protocol_helper.stub_error(error_code) }
+    end
+
+    def http_response_stub(operation_name, data)
+      if Hash === data && data.keys.sort == [:body, :headers, :status_code]
+        { http: hash_to_http_resp(data) }
+      else
+        { http: data_to_http_resp(operation_name, data) }
+      end
+    end
+
+    def hash_to_http_resp(data)
+      http_resp = Seahorse::Client::Http::Response.new
+      http_resp.status_code = data[:status_code]
+      http_resp.headers.update(data[:headers])
+      http_resp.body = data[:body]
+      http_resp
+    end
+
+    def data_to_http_resp(operation_name, data)
+      api = config.api
+      operation = api.operation(operation_name)
+      ParamValidator.validate!(operation.output, data)
+      protocol_helper.stub_data(api, operation, data)
+    end
+
+    def protocol_helper
+      case config.api.metadata['protocol']
+      when 'json'      then Stubbing::Protocols::Json
+      when 'query'     then Stubbing::Protocols::Query
+      when 'ec2'       then Stubbing::Protocols::EC2
+      when 'rest-json' then Stubbing::Protocols::RestJson
+      when 'rest-xml'  then Stubbing::Protocols::RestXml
+      else raise "unsupported protocol"
+      end.new
+    end
+  end
+end