aws-sdk-core 2.11.549

data/lib/seahorse/client/http/request.rb

@@ -0,0 +1,68 @@
+require 'stringio'
+require 'uri'
+
+module Seahorse
+  module Client
+    module Http
+      class Request
+
+        # @option options [URI::HTTP, URI::HTTPS] :endpoint (nil)
+        # @option options [String] :http_method ('GET')
+        # @option options [Headers] :headers (Headers.new)
+        # @option options [Body] :body (StringIO.new)
+        def initialize(options = {})
+          self.endpoint = options[:endpoint]
+          self.http_method = options[:http_method] || 'GET'
+          self.headers = Headers.new(options[:headers] || {})
+          self.body = options[:body]
+        end
+
+        # @return [String] The HTTP request method, e.g. `GET`, `PUT`, etc.
+        attr_accessor :http_method
+
+        # @return [Headers] The hash of request headers.
+        attr_accessor :headers
+
+        # @return [URI::HTTP, URI::HTTPS, nil]
+        def endpoint
+          @endpoint
+        end
+
+        # @param [String, URI::HTTP, URI::HTTPS, nil] endpoint
+        def endpoint=(endpoint)
+          endpoint = URI.parse(endpoint) if endpoint.is_a?(String)
+          if endpoint.nil? or URI::HTTP === endpoint or URI::HTTPS === endpoint
+            @endpoint = endpoint
+          else
+            msg = "invalid endpoint, expected URI::HTTP, URI::HTTPS, or nil, "
+            msg << "got #{endpoint.inspect}"
+            raise ArgumentError, msg
+          end
+        end
+
+        # @return [IO]
+        def body
+          @body
+        end
+
+        # @return [String]
+        def body_contents
+          body.rewind
+          contents = body.read
+          body.rewind
+          contents
+        end
+
+        # @param [#read, #size, #rewind] io
+        def body=(io)
+          @body =case io
+            when nil then StringIO.new('')
+            when String then StringIO.new(io)
+            else io
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/http/response.rb

@@ -0,0 +1,181 @@
+module Seahorse
+  module Client
+    module Http
+      class Response
+
+        # @option options [Integer] :status_code (0)
+        # @option options [Headers] :headers (Headers.new)
+        # @option options [IO] :body (StringIO.new)
+        def initialize(options = {})
+          @status_code = options[:status_code] || 0
+          @headers = options[:headers] || Headers.new
+          @body = options[:body] || StringIO.new
+          @listeners = Hash.new { |h,k| h[k] = [] }
+          @complete = false
+          @done = nil
+          @error = nil
+        end
+
+        # @return [Integer] Returns `0` if the request failed to generate
+        #   any response.
+        attr_accessor :status_code
+
+        # @return [Headers]
+        attr_accessor :headers
+
+        # @return [StandardError, nil]
+        attr_reader :error
+
+        # @return [IO]
+        def body
+          @body
+        end
+
+        # @param [#read, #size, #rewind] io
+        def body=(io)
+          @body = case io
+            when nil then StringIO.new('')
+            when String then StringIO.new(io)
+            else io
+          end
+        end
+
+        # @return [String]
+        def body_contents
+          body.rewind
+          contents = body.read
+          body.rewind
+          contents
+        end
+
+        # @param [Integer] status_code
+        # @param [Hash<String,String>] headers
+        def signal_headers(status_code, headers)
+          @status_code = status_code
+          @headers = Headers.new(headers)
+          emit(:headers, @status_code, @headers)
+        end
+
+        # @param [string] chunk
+        def signal_data(chunk)
+          unless chunk == ''
+            @body.write(chunk)
+            emit(:data, chunk)
+          end
+        end
+
+        # Completes the http response.
+        #
+        # @example Completing the response in a singal call
+        #
+        #     http_response.signal_done(
+        #       status_code: 200,
+        #       headers: {},
+        #       body: ''
+        #     )
+        #
+        # @example Complete the response in parts
+        #
+        #     # signal headers straight-way
+        #     http_response.signal_headers(200, {})
+        #
+        #     # signal data as it is received from the socket
+        #     http_response.signal_data("...")
+        #     http_response.signal_data("...")
+        #     http_response.signal_data("...")
+        #
+        #     # signal done once the body data is all written
+        #     http_response.signal_done
+        #
+        # @overload signal_done()
+        #
+        # @overload signal_done(options = {})
+        #   @option options [required, Integer] :status_code
+        #   @option options [required, Hash] :headers
+        #   @option options [required, String] :body
+        #
+        def signal_done(options = {})
+          if options.keys.sort == [:body, :headers, :status_code]
+            signal_headers(options[:status_code], options[:headers])
+            signal_data(options[:body])
+            signal_done
+          elsif options.empty?
+            @body.rewind if @body.respond_to?(:rewind)
+            @done = true
+            emit(:done)
+          else
+            msg = "options must be empty or must contain :status_code, :headers, "
+            msg << "and :body"
+            raise ArgumentError, msg
+          end
+        end
+
+        # @param [StandardError] networking_error
+        def signal_error(networking_error)
+          @error = networking_error
+          signal_done
+        end
+
+        def on_headers(status_code_range = nil, &block)
+          @listeners[:headers] << listener(status_code_range, block)
+        end
+
+        def on_data(&callback)
+          @listeners[:data] << callback
+        end
+
+        def on_done(status_code_range = nil, &callback)
+          listener = listener(status_code_range, callback)
+          if @done
+            listener.call
+          else
+            @listeners[:done] << listener
+          end
+        end
+
+        def on_success(status_code_range = 200..599, &callback)
+          on_done(status_code_range) do
+            unless @error
+              yield
+            end
+          end
+        end
+
+        def on_error(&callback)
+          on_done(0..599) do
+            if @error
+              yield(@error)
+            end
+          end
+        end
+
+        def reset
+          @status_code = 0
+          @headers.clear
+          @body.truncate(0)
+          @error = nil
+        end
+
+        private
+
+        def listener(range, callback)
+          range = range..range if Integer === range
+          if range
+            lambda do |*args|
+              if range.include?(@status_code)
+                callback.call(*args)
+              end
+            end
+          else
+            callback
+          end
+        end
+
+        def emit(event_name, *args)
+          @listeners[event_name].each { |listener| listener.call(*args) }
+        end
+
+      end
+    end
+  end
+end

data/lib/seahorse/client/logging/formatter.rb

@@ -0,0 +1,314 @@
+require 'pathname'
+
+module Seahorse
+  module Client
+    module Logging
+
+      # A log formatter receives a {Response} object and return
+      # a log message as a string. When you construct a {Formatter}, you provide
+      # a pattern string with substitutions.
+      #
+      #     pattern = ':operation :http_response_status_code :time'
+      #     formatter = Seahorse::Client::Logging::Formatter.new(pattern)
+      #     formatter.format(response)
+      #     #=> 'get_bucket 200 0.0352'
+      #
+      # # Canned Formatters
+      #
+      # Instead of providing your own pattern, you can choose a canned log
+      # formatter.
+      #
+      # * {Formatter.default}
+      # * {Formatter.colored}
+      # * {Formatter.short}
+      #
+      # # Pattern Substitutions
+      #
+      # You can put any of these placeholders into you pattern.
+      #
+      #   * `:client_class` - The name of the client class.
+      #
+      #   * `:operation` - The name of the client request method.
+      #
+      #   * `:request_params` - The user provided request parameters. Long
+      #     strings are truncated/summarized if they exceed the
+      #     {#max_string_size}.  Other objects are inspected.
+      #
+      #   * `:time` - The total time in seconds spent on the
+      #     request.  This includes client side time spent building
+      #     the request and parsing the response.
+      #
+      #   * `:retries` - The number of times a client request was retried.
+      #
+      #   * `:http_request_method` - The http request verb, e.g., `POST`,
+      #     `PUT`, `GET`, etc.
+      #
+      #   * `:http_request_endpoint` - The request endpoint.  This includes
+      #      the scheme, host and port, but not the path.
+      #
+      #   * `:http_request_scheme` - This is replaced by `http` or `https`.
+      #
+      #   * `:http_request_host` - The host name of the http request
+      #     endpoint (e.g. 's3.amazon.com').
+      #
+      #   * `:http_request_port` - The port number (e.g. '443' or '80').
+      #
+      #   * `:http_request_headers` - The http request headers, inspected.
+      #
+      #   * `:http_request_body` - The http request payload.
+      #
+      #   * `:http_response_status_code` - The http response status
+      #     code, e.g., `200`, `404`, `500`, etc.
+      #
+      #   * `:http_response_headers` - The http response headers, inspected.
+      #
+      #   * `:http_response_body` - The http response body contents.
+      #
+      #   * `:error_class`
+      #
+      #   * `:error_message`
+      #
+      class Formatter
+
+        # @param [String] pattern The log format pattern should be a string
+        #   and may contain substitutions.
+        #
+        # @option options [Integer] :max_string_size (1000) When summarizing
+        #   request parameters, strings longer than this value will be
+        #   truncated.
+        #
+        def initialize(pattern, options = {})
+          @pattern = pattern
+          @max_string_size = options[:max_string_size] || 1000
+        end
+
+        # @return [String]
+        attr_reader :pattern
+
+        # @return [Integer]
+        attr_reader :max_string_size
+
+        # Given a {Response}, this will format a log message and return it
+        #   as a string.
+        # @param [Response] response
+        # @return [String]
+        def format(response)
+          pattern.gsub(/:(\w+)/) {|sym| send("_#{sym[1..-1]}", response) }
+        end
+
+        # @api private
+        def eql?(other)
+          other.is_a?(self.class) and other.pattern == self.pattern
+        end
+        alias :== :eql?
+
+        private
+
+        def method_missing(method_name, *args)
+          if method_name.to_s.chars.first == '_'
+            ":#{method_name.to_s[1..-1]}"
+          else
+            super
+          end
+        end
+
+        def _client_class(response)
+          response.context.client.class.name
+        end
+
+        def _operation(response)
+          response.context.operation_name
+        end
+
+        def _request_params(response)
+          summarize_hash(response.context.params)
+        end
+
+        def _time(response)
+          duration = response.context[:logging_completed_at] -
+            response.context[:logging_started_at]
+          ("%.06f" % duration).sub(/0+$/, '')
+        end
+
+        def _retries(response)
+          response.context.retries
+        end
+
+        def _http_request_endpoint(response)
+          response.context.http_request.endpoint.to_s
+        end
+
+        def _http_request_scheme(response)
+          response.context.http_request.endpoint.scheme
+        end
+
+        def _http_request_host(response)
+          response.context.http_request.endpoint.host
+        end
+
+        def _http_request_port(response)
+          response.context.http_request.endpoint.port.to_s
+        end
+
+        def _http_request_method(response)
+          response.context.http_request.http_method
+        end
+
+        def _http_request_headers(response)
+          response.context.http_request.headers.inspect
+        end
+
+        def _http_request_body(response)
+          summarize_value(response.context.http_request.body_contents)
+        end
+
+        def _http_response_status_code(response)
+          response.context.http_response.status_code.to_s
+        end
+
+        def _http_response_headers(response)
+          response.context.http_response.headers.inspect
+        end
+
+        def _http_response_body(response)
+          response.context.http_response.body.respond_to?(:rewind) ?
+            summarize_value(response.context.http_response.body_contents) :
+            ''
+        end
+
+        def _error_class(response)
+          response.error ? response.error.class.name : ''
+        end
+
+        def _error_message(response)
+          response.error ? response.error.message : ''
+        end
+
+        # @param [Hash] hash
+        # @return [String]
+        def summarize_hash(hash)
+          hash.keys.first.is_a?(String) ?
+            summarize_string_hash(hash) :
+            summarize_symbol_hash(hash)
+        end
+
+        def summarize_symbol_hash(hash)
+          hash.map do |key,v|
+            "#{key}:#{summarize_value(v)}"
+          end.join(",")
+        end
+
+        def summarize_string_hash(hash)
+          hash.map do |key,v|
+            "#{key.inspect}=>#{summarize_value(v)}"
+          end.join(",")
+        end
+
+        # @param [Object] value
+        # @return [String]
+        def summarize_value value
+          case value
+          when String   then summarize_string(value)
+          when Hash     then '{' + summarize_hash(value) + '}'
+          when Array    then summarize_array(value)
+          when File     then summarize_file(value.path)
+          when Pathname then summarize_file(value)
+          else value.inspect
+          end
+        end
+
+        # @param [String] str
+        # @return [String]
+        def summarize_string str
+          max = max_string_size
+          if str.size > max
+            "#<String #{str[0...max].inspect} ... (#{str.size} bytes)>"
+          else
+            str.inspect
+          end
+        end
+
+        # Given the path to a file on disk, this method returns a summarized
+        # inspecton string that includes the file size.
+        # @param [String] path
+        # @return [String]
+        def summarize_file path
+          "#<File:#{path} (#{File.size(path)} bytes)>"
+        end
+
+        # @param [Array] array
+        # @return [String]
+        def summarize_array array
+          "[" + array.map{|v| summarize_value(v) }.join(",") + "]"
+        end
+
+        class << self
+
+          # The default log format.
+          #
+          # @example A sample of the default format.
+          #
+          #     [ClientClass 200 0.580066 0 retries] list_objects(:bucket_name => 'bucket')
+          #
+          # @return [Formatter]
+          #
+          def default
+            pattern = []
+            pattern << "[:client_class"
+            pattern << ":http_response_status_code"
+            pattern << ":time"
+            pattern << ":retries retries]"
+            pattern << ":operation(:request_params)"
+            pattern << ":error_class"
+            pattern << ":error_message"
+            Formatter.new(pattern.join(' ') + "\n")
+          end
+
+          # The short log format.  Similar to default, but it does not
+          # inspect the request params or report on retries.
+          #
+          # @example A sample of the short format
+          #
+          #     [ClientClass 200 0.494532] list_buckets
+          #
+          # @return [Formatter]
+          #
+          def short
+            pattern = []
+            pattern << "[:client_class"
+            pattern << ":http_response_status_code"
+            pattern << ":time]"
+            pattern << ":operation"
+            pattern << ":error_class"
+            Formatter.new(pattern.join(' ') + "\n")
+          end
+
+          # The default log format with ANSI colors.
+          #
+          # @example A sample of the colored format (sans the ansi colors).
+          #
+          #     [ClientClass 200 0.580066 0 retries] list_objects(:bucket_name => 'bucket')
+          #
+          # @return [Formatter]
+          #
+          def colored
+            bold = "\x1b[1m"
+            color = "\x1b[34m"
+            reset = "\x1b[0m"
+            pattern = []
+            pattern << "#{bold}#{color}[:client_class"
+            pattern << ":http_response_status_code"
+            pattern << ":time"
+            pattern << ":retries retries]#{reset}#{bold}"
+            pattern << ":operation(:request_params)"
+            pattern << ":error_class"
+            pattern << ":error_message#{reset}"
+            Formatter.new(pattern.join(' ') + "\n")
+          end
+
+        end
+
+      end
+    end
+  end
+end