aws-sdk-core 2.11.212 → 3.170.0

data/lib/seahorse/client/plugins/request_callback.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'forwardable'
+
+module Seahorse
+  module Client
+    module Plugins
+
+      # @api private
+      class ReadCallbackIO
+        extend Forwardable
+        def_delegators :@io, :size
+
+        def initialize(io, on_read = nil)
+          @io = io
+          @on_read = on_read if on_read.is_a? Proc
+          @bytes_read = 0
+
+          # Some IO objects support readpartial - IO.copy_stream used by the
+          # request will call readpartial if available, so define a wrapper
+          # for it if the underlying IO supports it.
+          if @io.respond_to?(:readpartial)
+            def self.readpartial(*args)
+              @io.readpartial(*args).tap do |chunk|
+                handle_chunk(chunk)
+              end
+            end
+          end
+        end
+
+        attr_reader :io
+
+        def read(*args)
+          @io.read(*args).tap do |chunk|
+            handle_chunk(chunk)
+          end
+        end
+
+        private
+
+        def handle_chunk(chunk)
+          @bytes_read += chunk.bytesize if chunk && chunk.respond_to?(:bytesize)
+          total_size = @io.respond_to?(:size) ? @io.size : nil
+          @on_read.call(chunk, @bytes_read, total_size) if @on_read
+        end
+      end
+
+      # @api private
+      class RequestCallback < Plugin
+
+        option(
+          :on_chunk_sent,
+           default: nil,
+           doc_type: 'Proc',
+           docstring: <<-DOCS)
+When a Proc object is provided, it will be used as callback when each chunk 
+of the request body is sent. It provides three arguments: the chunk,
+the number of bytes read from the body, and the total number of 
+bytes in the body.
+          DOCS
+
+        # @api private
+        class OptionHandler < Client::Handler
+          def call(context)
+            if context.params.is_a?(Hash) && context.params[:on_chunk_sent]
+              on_chunk_sent = context.params.delete(:on_chunk_sent)
+            end
+            on_chunk_sent = context.config.on_chunk_sent if on_chunk_sent.nil?
+            context[:on_chunk_sent] = on_chunk_sent if on_chunk_sent
+            @handler.call(context)
+          end
+        end
+
+        # @api private
+        class ReadCallbackHandler < Client::Handler
+          def call(context)
+            if (callback = context[:on_chunk_sent])
+              context.http_request.body = ReadCallbackIO.new(
+                context.http_request.body,
+                callback
+              )
+              @handler.call(context).tap do
+                unwrap_callback_body(context)
+              end
+            else
+              @handler.call(context)
+            end
+          end
+
+          def unwrap_callback_body(context)
+            body = context.http_request.body
+            if body.is_a? ReadCallbackIO
+              context.http_request.body = body.io
+            end
+          end
+        end
+
+        # OptionHandler is needed to remove :on_chunk_sent
+        # from the params before build
+        handler(OptionHandler, step: :initialize)
+
+        # ReadCallbackHandlerneeds to go late in the call stack
+        # other plugins including Sigv4 and content_md5 read the request body
+        # and rewind it
+        handler(ReadCallbackHandler, step: :sign, priority: 0)
+      end
+    end
+  end
+end

data/lib/seahorse/client/plugins/response_target.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
 module Seahorse
   module Client
     module Plugins
@@ -13,10 +17,9 @@ module Seahorse
 
           def call(context)
             if context.params.is_a?(Hash) && context.params[:response_target]
-              target = context.params.delete(:response_target)
-            else
-              target = context[:response_target]
+              context[:response_target] = context.params.delete(:response_target)
             end
+            target = context[:response_target]
             add_event_listeners(context, target) if target
             @handler.call(context)
           end
@@ -24,28 +27,43 @@ module Seahorse
           private
 
           def add_event_listeners(context, target)
-            handler = self
             context.http_response.on_headers(200..299) do
-              context.http_response.body = handler.send(:io, target)
+              # In a fresh response body will be a StringIO
+              # However, when a request is retried we may have
+              # an existing ManagedFile or BlockIO and those
+              # should be reused.
+              if context.http_response.body.is_a? StringIO
+                context.http_response.body = io(target, context.http_response.headers)
+              end
             end
 
             context.http_response.on_success(200..299) do
               body = context.http_response.body
-              if ManagedFile === body && body.open?
+              if body.is_a?(ManagedFile) && body.open?
                 body.close
               end
             end
 
             context.http_response.on_error do
               body = context.http_response.body
-              File.unlink(body) if ManagedFile === body
-              context.http_response.body = StringIO.new
+
+              # When using response_target of file we do not want to write
+              # error messages to the file.  So set the body to a new StringIO
+              if body.is_a? ManagedFile
+                File.unlink(body)
+                context.http_response.body = StringIO.new
+              end
+
+              # Aws::S3::Encryption::DecryptHandler (with lower priority)
+              # has callbacks registered after ResponseTarget::Handler,
+              # where http_response.body is an IODecrypter
+              # and has error callbacks handling for it so no action is required here
             end
           end
 
-          def io(target)
+          def io(target, headers)
             case target
-            when Proc then BlockIO.new(&target)
+            when Proc then BlockIO.new(headers, &target)
             when String, Pathname then ManagedFile.new(target, 'w+b')
             else target
             end

data/lib/seahorse/client/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Client
     class Request

data/lib/seahorse/client/request_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 
 module Seahorse
@@ -6,6 +8,7 @@ module Seahorse
 
       # @option options [required,Symbol] :operation_name (nil)
       # @option options [required,Model::Operation] :operation (nil)
+      # @option options [Model::Authorizer] :authorizer (nil)
       # @option options [Hash] :params ({})
       # @option options [Configuration] :config (nil)
       # @option options [Http::Request] :http_request (Http::Request.new)
@@ -14,6 +17,7 @@ module Seahorse
       def initialize(options = {})
         @operation_name = options[:operation_name]
         @operation = options[:operation]
+        @authorizer = options[:authorizer]
         @client = options[:client]
         @params = options[:params] || {}
         @config = options[:config]
@@ -29,6 +33,9 @@ module Seahorse
       # @return [Model::Operation]
       attr_accessor :operation
 
+      # @return [Model::Authorizer] APIG SDKs only
+      attr_accessor :authorizer
+
       # @return [Seahorse::Client::Base]
       attr_accessor :client
 

data/lib/seahorse/client/response.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'delegate'
 
 module Seahorse
   module Client
     class Response < Delegator
-
       # @option options [RequestContext] :context (nil)
       # @option options [Integer] :status_code (nil)
       # @option options [Http::Headers] :headers (Http::Headers.new)
@@ -39,10 +40,10 @@ module Seahorse
       #     witin the given range.
       #
       # @return [self]
-      def on(range, &block)
+      def on(range, &_block)
         response = self
         @context.http_response.on_success(range) do
-          block.call(response)
+          yield response
         end
         self
       end
@@ -56,7 +57,7 @@ module Seahorse
       # @return [Boolean] Returns `true` if the response is complete with
       #   a ~ 200 level http status code.
       def successful?
-        (200..299).include?(@context.http_response.status_code) && @error.nil?
+        (200..299).cover?(@context.http_response.status_code) && @error.nil?
       end
 
       # @api private
@@ -76,7 +77,6 @@ module Seahorse
       def __setobj__(obj)
         @data = obj
       end
-
     end
   end
 end

data/lib/seahorse/model/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Model
     class Api
@@ -5,7 +7,9 @@ module Seahorse
       def initialize
         @metadata = {}
         @operations = {}
+        @authorizers = {}
         @endpoint_operation = nil
+        @require_endpoint_discovery = false
       end
 
       # @return [String, nil]
@@ -17,6 +21,9 @@ module Seahorse
       # @return [Symbol|nil]
       attr_accessor :endpoint_operation
 
+      # @return [Boolean|nil]
+      attr_accessor :require_endpoint_discovery
+
       def operations(&block)
         if block_given?
           @operations.each(&block)
@@ -37,10 +44,42 @@ module Seahorse
         @operations.keys
       end
 
+      def async_operation_names
+        @operations.select {|_, op| op.async }.keys
+      end
+
       def add_operation(name, operation)
         @operations[name.to_sym] = operation
       end
 
+      def authorizers(&block)
+        if block_given?
+          @authorizers.each(&block)
+        else
+          @authorizers.enum_for(:each)
+        end
+      end
+
+      def authorizer(name)
+        if @authorizers.key?(name.to_sym)
+          @authorizers[name.to_sym]
+        else
+          raise ArgumentError, "unknown authorizer #{name.inspect}"
+        end
+      end
+
+      def authorizer_names
+        @authorizers.keys
+      end
+
+      def add_authorizer(name, authorizer)
+        @authorizers[name.to_sym] = authorizer
+      end
+
+      def inspect(*args)
+        "#<#{self.class.name}>"
+      end
+
     end
   end
 end

data/lib/seahorse/model/authorizer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Seahorse
+  module Model
+    class Authorizer
+
+      def initialize
+        @type = 'provided'
+        @placement = {}
+      end
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :type
+
+      # @return [Hash]
+      attr_accessor :placement
+
+    end
+  end
+end

data/lib/seahorse/model/operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   module Model
     class Operation
@@ -8,6 +10,7 @@ module Seahorse
         @deprecated = false
         @errors = []
         @metadata = {}
+        @async = false
       end
 
       # @return [String, nil]
@@ -19,6 +22,12 @@ module Seahorse
       # @return [String]
       attr_accessor :http_request_uri
 
+      # @return [Boolean]
+      attr_accessor :http_checksum_required
+
+      # @return [Hash]
+      attr_accessor :http_checksum
+
       # @return [Boolean]
       attr_accessor :deprecated
 
@@ -34,6 +43,9 @@ module Seahorse
       # @return [Hash, nil]
       attr_accessor :endpoint_pattern
 
+      # @return [String, nil]
+      attr_accessor :authorizer
+
       # @return [ShapeRef, nil]
       attr_accessor :input
 
@@ -43,6 +55,13 @@ module Seahorse
       # @return [Array<ShapeRef>]
       attr_accessor :errors
 
+      # APIG only
+      # @return [Boolean]
+      attr_accessor :require_apikey
+
+      # @return [Boolean]
+      attr_accessor :async
+
       def [](key)
         @metadata[key.to_s]
       end

data/lib/seahorse/model/shapes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module Seahorse
@@ -10,6 +12,14 @@ module Seahorse
           @metadata = {}
           @required = false
           @deprecated = false
+          @location = nil
+          @location_name = nil
+          @event = false
+          @eventstream = false
+          @eventpayload = false
+          @eventpayload_type = ''.freeze
+          @eventheader = false
+          @eventheader_type = ''.freeze
           options.each do |key, value|
             if key == :metadata
               value.each do |k,v|
@@ -33,6 +43,27 @@ module Seahorse
         # @return [Boolean]
         attr_accessor :deprecated
 
+        # @return [Boolean]
+        attr_accessor :event
+
+        # @return [Boolean]
+        attr_accessor :eventstream
+
+        # @return [Boolean]
+        attr_accessor :eventpayload
+
+        # @return [Boolean]
+        attr_accessor :eventheader
+
+        # @return [String]
+        attr_accessor :eventpayload_type
+
+        # @return [Boolean]
+        attr_accessor :eventheader_type
+
+        # @return [Boolean]
+        attr_accessor :document
+
         # @return [String, nil]
         def location
           @location || (shape && shape[:location])
@@ -69,8 +100,15 @@ module Seahorse
 
       class Shape
 
-        def initialize
+        def initialize(options = {})
           @metadata = {}
+          options.each_pair do |key, value|
+            if respond_to?("#{key}=")
+              send("#{key}=", value)
+            else
+              self[key] = value
+            end
+          end
         end
 
         # @return [String]
@@ -79,6 +117,9 @@ module Seahorse
         # @return [String, nil]
         attr_accessor :documentation
 
+        # @return [Boolean]
+        attr_accessor :union
+
         # Gets metadata for the given `key`.
         def [](key)
           @metadata[key.to_s]
@@ -134,6 +175,9 @@ module Seahorse
         # @return [Integer, nil]
         attr_accessor :max
 
+        # @return [Boolean]
+        attr_accessor :flattened
+
       end
 
       class MapShape < Shape
@@ -150,6 +194,9 @@ module Seahorse
         # @return [Integer, nil]
         attr_accessor :max
 
+        # @return [Boolean]
+        attr_accessor :flattened
+
       end
 
       class StringShape < Shape
@@ -171,12 +218,15 @@ module Seahorse
           @members = {}
           @members_by_location_name = {}
           @required = Set.new
-          super()
+          super
         end
 
         # @return [Set<Symbol>]
         attr_accessor :required
 
+        # @return [Class<Struct>]
+        attr_accessor :struct_class
+
         # @param [Symbol] name
         # @param [ShapeRef] shape_ref
         def add_member(name, shape_ref)
@@ -220,8 +270,27 @@ module Seahorse
 
       end
 
+      class UnionShape < StructureShape
+        def initialize(options = {})
+          @member_subclasses = {}
+          super options.merge(union: true)
+        end
+
+        # @api private
+        def member_subclass(member)
+          @member_subclasses[member]
+        end
+
+        # @api private
+        def add_member_subclass(member, subclass)
+          @member_subclasses[member] = subclass
+        end
+      end
+
       class TimestampShape < Shape; end
 
+      class DocumentShape < Shape; end
+
     end
   end
 end

data/lib/seahorse/util.rb

@@ -1,39 +1,29 @@
+# frozen_string_literal: true
+
 require 'cgi'
 
 module Seahorse
   # @api private
   module Util
     class << self
-
-      def irregular_inflections(hash)
-        @irregular_inflections.update(hash)
-        @irregular_regex = Regexp.new(@irregular_inflections.keys.join('|'))
-      end
-
-      # @param [String] string
-      # @return [String] Returns the underscored version of the given string.
-      def underscore(string)
-        new_string = string.dup
-        new_string.gsub!(@irregular_regex) { |word| "_#{@irregular_inflections[word]}" }
-        new_string.gsub!(/([A-Z0-9]+)([A-Z][a-z])/, '\1_\2'.freeze)
-        new_string = new_string.scan(/[a-z0-9]+|\d+|[A-Z0-9]+[a-z]*/).join('_'.freeze)
-        new_string.downcase!
-        new_string
-      end
-
       def uri_escape(string)
-        CGI.escape(string.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
+        CGI.escape(string.to_s.encode('UTF-8')).gsub('+', '%20').gsub('%7E', '~')
       end
 
       def uri_path_escape(path)
         path.gsub(/[^\/]+/) { |part| uri_escape(part) }
       end
 
-    end
-
-    @irregular_inflections = {}
-
-    irregular_inflections('ETag' => 'etag')
+      def escape_header_list_string(s)
+        s.include?('"') || s.include?(',') ? "\"#{s.gsub('"', '\"')}\"" : s
+      end
 
+      # Checks for a valid host label
+      # @see https://tools.ietf.org/html/rfc3986#section-3.2.2
+      # @see https://tools.ietf.org/html/rfc1123#page-13
+      def host_label?(str)
+        str =~ /^(?!-)[a-zA-Z0-9-]{1,63}(?<!-)$/
+      end
+    end
   end
 end

data/lib/seahorse/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seahorse
   VERSION = '0.1.0'
 end