aws-sdk-core 2.0.0 → 2.11.632

data/lib/aws-sdk-core/xml/parser/parsing_error.rb

@@ -0,0 +1,19 @@
+module Aws
+  module Xml
+    class Parser
+      class ParsingError < RuntimeError
+
+        def initialize(msg, line, column)
+          super(msg)
+        end
+
+        # @return [Integer,nil]
+        attr_reader :line
+
+        # @return [Integer,nil]
+        attr_reader :column
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-core/xml/parser/stack.rb

@@ -0,0 +1,66 @@
+module Aws
+  module Xml
+    class Parser
+      class Stack
+
+        def initialize(ref, result = nil, &unhandled_callback)
+          @ref = ref
+          @frame = self
+          @result = result
+          @unhandled_callback = unhandled_callback
+        end
+
+        attr_reader :frame
+
+        attr_reader :result
+
+        def start_element(name)
+          @frame = @frame.child_frame(name.to_s)
+        end
+
+        def attr(name, value)
+          if name.to_s == 'encoding' && value.to_s == 'base64'
+            @frame = BlobFrame.new(name, @frame.parent, @frame.ref)
+          else
+            start_element(name)
+            text(value)
+            end_element(name)
+          end
+        end
+
+        def text(value)
+          @frame.set_text(value)
+        end
+
+        def end_element(*args)
+          @frame.parent.consume_child_frame(@frame)
+          if @frame.parent.is_a?(FlatListFrame)
+            @frame = @frame.parent
+            @frame.parent.consume_child_frame(@frame)
+          end
+          @frame = @frame.parent
+        end
+
+        def error(msg, line = nil, column = nil)
+          raise ParsingError.new(msg, line, column)
+        end
+
+        def child_frame(name)
+          Frame.new(name, self, @ref, @result)
+        end
+
+        def consume_child_frame(frame)
+          @result = frame.result
+        end
+
+        # @api private
+        def yield_unhandled_value(path, value)
+          if @unhandled_callback
+            @unhandled_callback.call(path, value)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+Aws.add_service(:XRay, {
+  api: "#{Aws::API_DIR}/xray/2016-04-12/api-2.json",
+  docs: "#{Aws::API_DIR}/xray/2016-04-12/docs-2.json",
+  examples: "#{Aws::API_DIR}/xray/2016-04-12/examples-1.json",
+  paginators: "#{Aws::API_DIR}/xray/2016-04-12/paginators-1.json",
+})

data/lib/seahorse.rb

@@ -12,8 +12,7 @@ module Seahorse
     autoload :HandlerList, 'seahorse/client/handler_list'
     autoload :HandlerListEntry, 'seahorse/client/handler_list_entry'
     autoload :ManagedFile, 'seahorse/client/managed_file'
-    autoload :ParamConverter, 'seahorse/client/param_converter'
-    autoload :ParamValidator, 'seahorse/client/param_validator'
+    autoload :NetworkingError, 'seahorse/client/networking_error'
     autoload :Plugin, 'seahorse/client/plugin'
     autoload :PluginList, 'seahorse/client/plugin_list'
     autoload :Request, 'seahorse/client/request'
@@ -21,12 +20,13 @@ module Seahorse
     autoload :Response, 'seahorse/client/response'
 
     module Http
-      autoload :Error, 'seahorse/client/http/error'
       autoload :Headers, 'seahorse/client/http/headers'
       autoload :Request, 'seahorse/client/http/request'
       autoload :Response, 'seahorse/client/http/response'
     end
 
+    # The following module has been deprecated.
+    # @api private
     module Logging
       autoload :Handler, 'seahorse/client/logging/handler'
       autoload :Formatter, 'seahorse/client/logging/formatter'
@@ -42,26 +42,18 @@ module Seahorse
     module Plugins
       autoload :ContentLength, 'seahorse/client/plugins/content_length'
       autoload :Endpoint, 'seahorse/client/plugins/endpoint'
-      autoload :JsonSimple, 'seahorse/client/plugins/json_simple'
       autoload :Logging, 'seahorse/client/plugins/logging'
       autoload :NetHttp, 'seahorse/client/plugins/net_http'
-      autoload :ParamConversion, 'seahorse/client/plugins/param_conversion'
-      autoload :ParamValidation, 'seahorse/client/plugins/param_validation'
       autoload :RaiseResponseErrors, 'seahorse/client/plugins/raise_response_errors'
+      autoload :ResponseTarget, 'seahorse/client/plugins/response_target'
       autoload :RestfulBindings, 'seahorse/client/plugins/restful_bindings'
     end
 
-    # @api private
-    module Xml
-      autoload :Builder, 'seahorse/client/xml/builder'
-    end
-
   end
 
   module Model
     autoload :Api, 'seahorse/model/api'
     autoload :Operation, 'seahorse/model/operation'
-    autoload :ShapeMap, 'seahorse/model/shape_map'
     autoload :Shapes, 'seahorse/model/shapes'
   end
 

data/lib/seahorse/client/base.rb

@@ -10,9 +10,8 @@ module Seahorse
       @plugins = PluginList.new([
         Plugins::Endpoint,
         Plugins::NetHttp,
-        Plugins::ParamConversion,
-        Plugins::ParamValidation,
         Plugins::RaiseResponseErrors,
+        Plugins::ResponseTarget,
       ])
 
       # @api private
@@ -56,38 +55,8 @@ module Seahorse
         self.class.api.operation_names
       end
 
-      # @api private
-      def respond_to?(method_name, *args)
-        if request_method?(method_name)
-          true
-        else
-          super
-        end
-      end
-
-      # @api private
-      def method_missing(method_name, *args, &block)
-        if request_method?(method_name)
-          make_request(method_name, *args, &block)
-        else
-          super
-        end
-      end
-
       private
 
-      # @return [Boolean] Returns `true` if the method name is an API operation.t 
-      def request_method?(method_name)
-        operation_names.include?(method_name.to_sym)
-      end
-
-      # Builds and sends a request.
-      def make_request(name, *args, &block)
-        params = args[0] || {}
-        options = args[1] || {}
-        build_request(name, params).send_request(options, &block)
-      end
-
       # Constructs a {Configuration} object and gives each plugin the
       # opportunity to register options with default values.
       def build_config(plugins, options)
@@ -111,7 +80,7 @@ module Seahorse
 
       # Gives each plugin the opportunity to modify this client.
       def after_initialize(plugins)
-        plugins.each do |plugin|
+        plugins.reverse.each do |plugin|
           plugin.after_initialize(self) if plugin.respond_to?(:after_initialize)
         end
       end
@@ -119,7 +88,7 @@ module Seahorse
       # @return [RequestContext]
       def context_for(operation_name, params)
         RequestContext.new(
-          operation_name: operation_name.to_s,
+          operation_name: operation_name,
           operation: operation(operation_name),
           client: self,
           params: params,
@@ -206,14 +175,12 @@ module Seahorse
           @api ||= Model::Api.new
         end
 
-        # @param [Model::Api, Hash] api
+        # @param [Model::Api] api
         # @return [Model::Api]
         def set_api(api)
-          if api.is_a?(Hash)
-            @api = Model::Api.new(api)
-          else
-            @api = api
-          end
+          @api = api
+          define_operation_methods
+          @api
         end
 
         # @option options [Model::Api, Hash] :api ({})
@@ -232,6 +199,16 @@ module Seahorse
 
         private
 
+        def define_operation_methods
+          @api.operation_names.each do |method_name|
+            define_method(method_name) do |*args, &block|
+              params = args[0] || {}
+              options = args[1] || {}
+              build_request(method_name, params).send_request(options, &block)
+            end
+          end
+        end
+
         def build_plugins
           plugins.map { |plugin| plugin.is_a?(Class) ? plugin.new : plugin }
         end

data/lib/seahorse/client/configuration.rb

@@ -33,7 +33,7 @@ module Seahorse
     #     cfg1.color #=> 'red'
     #
     #     # supplied color
-    #     cfg2 = configuration.build!(color: blue)
+    #     cfg2 = configuration.build!(color: 'blue')
     #     cfg2.color #=> 'blue'
     #
     # ## Accepted Options
@@ -59,9 +59,15 @@ module Seahorse
       end
 
       # @api private
-      DynamicDefault = Struct.new(:block) do
-        def call(*args)
-          block.call(*args)
+      class DynamicDefault
+        attr_accessor :block
+
+        def initialize(block = nil)
+          @block = block
+        end
+
+        def call(*args) 
+          @block.call(*args)
         end
       end
 
@@ -98,7 +104,7 @@ module Seahorse
       #
       # @return [self]
       def add_option(name, default = nil, &block)
-        default = DynamicDefault.new(Proc.new) if block_given?
+        default = DynamicDefault.new(block) if block_given?
         @defaults[name.to_sym] << default
         self
       end
@@ -191,7 +197,13 @@ module Seahorse
 
         def value_at(opt_name)
           value = @struct[opt_name]
-          value.is_a?(Defaults) ? resolve_defaults(opt_name, value) : value
+          if value.is_a?(Defaults)
+            # this config value is used by endpoint discovery etc
+            @struct[:regional_endpoint] = true if opt_name == :endpoint
+            resolve_defaults(opt_name, value)
+          else
+            value
+          end
         end
 
         def resolve_defaults(opt_name, defaults)

data/lib/seahorse/client/events.rb

@@ -0,0 +1,21 @@
+module Seahorse
+  module Client
+    module EventEmitter
+
+      def initialize(*args)
+        @listeners = {}
+        super
+      end
+
+      def emit(event_name, *args, &block)
+        @listeners[event_name] ||= []
+        @listeners[event_name] << block if block_given?
+      end
+
+      def signal(event, *args)
+        @listeners
+      end
+
+    end
+  end
+end

data/lib/seahorse/client/handler_list.rb

@@ -148,7 +148,7 @@ module Seahorse
       # Yields the handlers in stack order, which is reverse priority.
       def each(&block)
         entries.sort.each do |entry|
-          yield(entry.handler_class) if entry.operations.empty?
+          yield(entry.handler_class) if entry.operations.nil?
         end
       end
 
@@ -175,10 +175,10 @@ module Seahorse
 
       def filter(operation)
         entries.inject([]) do |filtered, entry|
-          if entry.operations.empty?
-            filtered << entry
+          if entry.operations.nil?
+            filtered << entry.copy
           elsif entry.operations.include?(operation)
-            filtered << entry.copy(operations: [])
+            filtered << entry.copy(operations: nil)
           end
           filtered
         end

data/lib/seahorse/client/handler_list_entry.rb

@@ -27,7 +27,8 @@ module Seahorse
         @options = options
         @handler_class = option(:handler_class, options)
         @inserted = option(:inserted, options)
-        @operations = Set.new((options[:operations] || []).map(&:to_s))
+        @operations = options[:operations]
+        @operations = Set.new(options[:operations]).map(&:to_s) if @operations
         set_step(options[:step] || :build)
         set_priority(options[:priority] || 50)
         compute_weight

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

@@ -11,7 +11,7 @@ module Seahorse
       #     headers[:Authorization] = 'Abc'
       #
       #     headers.keys
-      #     #=> ['content-length', 'authorization']]
+      #     #=> ['content-length', 'authorization']
       #
       #     headers.values
       #     #=> ['100', 'Abc']

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

@@ -11,23 +11,22 @@ module Seahorse
         # @option options [Headers] :headers (Headers.new)
         # @option options [Body] :body (StringIO.new)
         def initialize(options = {})
-          self.endpoint = options[:endpoint] if options[:endpoint]
+          self.endpoint = options[:endpoint]
           self.http_method = options[:http_method] || 'GET'
           self.headers = Headers.new(options[:headers] || {})
           self.body = options[:body]
         end
 
-        # @return [URI::HTTP, URI::HTTPS, nil]
-        attr_accessor :endpoint
-
         # @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 [IO]
-        attr_reader :body
+        # @return [URI::HTTP, URI::HTTPS, nil]
+        def endpoint
+          @endpoint
+        end
 
         # @param [String, URI::HTTP, URI::HTTPS, nil] endpoint
         def endpoint=(endpoint)
@@ -41,6 +40,11 @@ module Seahorse
           end
         end
 
+        # @return [IO]
+        def body
+          @body
+        end
+
         # @return [String]
         def body_contents
           body.rewind

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

@@ -10,6 +10,10 @@ module Seahorse
           @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
@@ -19,8 +23,13 @@ module Seahorse
         # @return [Headers]
         attr_accessor :headers
 
+        # @return [StandardError, nil]
+        attr_reader :error
+
         # @return [IO]
-        attr_accessor :body
+        def body
+          @body
+        end
 
         # @param [#read, #size, #rewind] io
         def body=(io)
@@ -39,6 +48,133 @@ module Seahorse
           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