aws-sdk 1.32.0 → 1.67.0

data/lib/aws/core/resource_cache.rb

@@ -1,40 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-
-    # @api private
-    class ResourceCache
-
-      def initialize
-        @cache = {}
-      end
-
-      def store(key, attributes)
-        (@cache[key] ||= {}).merge!(attributes)
-      end
-
-      def cached?(key, attribute)
-        attributes = @cache[key] and attributes.has_key?(attribute)
-      end
-
-      def get(key, attribute)
-        raise "No cached value for attribute :#{attribute} of #{key}" unless
-          cached?(key, attribute)
-        @cache[key][attribute]
-      end
-
-    end
-  end
-end

data/lib/aws/core/response.rb

@@ -1,211 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-
-    # # Response
-    #
-    # Each Service has a Client class.  There is one method per service
-    # operation defined on the client.  These methods all return a {Response}
-    # object.
-    #
-    # In addition to the response data, these responses provide metadata
-    # about the HTTP request made and the HTTP response received.
-    #
-    # ## Response Data
-    #
-    # You can access the response data for a client request using the {#data}
-    # method or the {#[]} method.  Response data is a hash and {#[]} is
-    # a shortcut for accessing this hash.
-    #
-    #     # make a request to describe one instance
-    #     ec2 = AWS::EC2.new
-    #     response = ec2.client.describe_instances(:instance_ids => ['i-12345678'])
-    #
-    #     # find the instance in the response data (2 ways to get the data)
-    #     instance = response[:reservation_set].first[:instance_set].first
-    #     instance = response.data[:reservation_set].first[:instance_set].first
-    #
-    #     instance[:status] #=> 'running'
-    #
-    # ## Response Metadata
-    #
-    # In addition to the response data, there is additional information
-    # available with the response, including:
-    #
-    # * {#request_type} - the name of the client request method
-    # * {#request_options} - the hash of options passed to the client method
-    # * {#http_request} - The HTTP request made
-    # * {#http_response} - the HTTP response received
-    #
-    # Given the example and response object from above:
-    #
-    #     response.request_type #=> :describe_instances
-    #     response.request_options #=> { :instance_ids => ['i-12345678'] }
-    #     response.http_request #=> #<AWS::Core::Http::Request>
-    #     response.http_response #=> #<AWS::Core::Http::Response>
-    #
-    class Response
-
-      include AsyncHandle
-
-      # @return [Hash] Returns the response data as a hash.
-      attr_accessor :data
-
-      # @api private
-      attr_accessor :config
-
-      # @return [Symbol] The name of the client request method that
-      #   returned this response.
-      attr_accessor :request_type
-
-      # @return [Hash] Returns the hash of options passed to the client
-      #   request method that generated this response.
-      attr_accessor :request_options
-
-      # @return [Core::Http::Request]
-      attr_accessor :http_request
-
-      # @return [Core::Http::Response]
-      attr_accessor :http_response
-
-      # @return [Boolean] true if the response was generated from a
-      #   another cached response.
-      attr_accessor :cached
-
-      alias_method :cached?, :cached
-
-      # @return [AWS::Error,nil] Returns nil unless the request failed.
-      #   Normally this will be nil unless you are using the Asynchronous
-      #   interface.
-      attr_accessor :error
-
-      # @return [Integer] Returns the number of times the request
-      #   was retried.
-      attr_accessor :retry_count
-
-      # @return [Float] The total number of seconds taken to make the
-      #   request and return the response.
-      attr_accessor :duration
-
-      # @param [Http::Request] http_request
-      # @param [Http::Response] http_response
-      def initialize http_request = nil, http_response = nil, &block
-        @http_request = http_request
-        @http_response = http_response
-        @request_builder = block
-        @data = {}
-        @retry_count = 0
-        @duration = 0
-        build_request if @request_builder && !http_request
-      end
-
-      # Provides access to the response data.  This is a short-cut
-      # for calling `response.data[key]`.
-      #
-      # @param [Symbol,String] key
-      # @return [Hash,nil]
-      def [] key
-        data[key]
-      end
-
-      # @return [Boolean] Returns true if there is no response error.
-      def successful?
-        error.nil?
-      end
-
-      # @return [Boolean] Returns `true` if the http request failed due to
-      #   a networking issue.
-      def network_error?
-        http_response.network_error?
-      end
-
-      # @return [String]
-      # @api private
-      def inspect
-        data.inspect
-      end
-
-      # @return [String]
-      # @api private
-      def cache_key
-        [
-          http_request.access_key_id,
-          http_request.host,
-          request_type,
-          serialized_options
-        ].join(":")
-      end
-
-      # Rebuilds the HTTP request using the block passed to the initializer.
-      # This is primarily used by the client when a request must be retried
-      # (throttling, server errors, socket errors, etc).
-      # @api private
-      def rebuild_request
-        @http_request.body_stream.rewind if @http_request.body_stream
-        build_request
-      end
-
-      # @return [Boolean] Returns `false` if it is not safe to retry a
-      #   request.  This happens when the http request body is an IO
-      #   object that can not be rewound and re-streamed.
-      def safe_to_retry?
-        @http_request.body_stream.nil? or
-        @http_request.body_stream.respond_to?(:rewind)
-      end
-
-      protected
-
-      def build_request
-        @http_request = @request_builder.call
-      end
-
-      # @note The prefered method to get as response data is to use {#[]}.
-      #
-      # This provides a backwards-compat layer to the old response objects
-      # where each response value had a method extended onto this object.
-      # Now all response data is accessible as a hash.
-      #
-      # @see #[]
-      # @see #data
-      #
-      def method_missing *args, &block
-        Core::Data.new(data).send(*args, &block)
-      end
-
-      def serialized_options
-        serialize_options_hash(request_options)
-      end
-
-      def serialize_options_hash(hash)
-        "(" + hash.keys.sort_by(&:to_s).map do |key|
-          "#{key}=#{serialize_options_value(hash[key])}"
-        end.join(" ") + ")"
-      end
-
-      def serialize_options_value(value)
-        case value
-        when Hash  then serialize_options_hash(value)
-        when Array then serialize_options_array(value)
-        else value.inspect
-        end
-      end
-
-      def serialize_options_array array
-        "[" + array.map{|v| serialize_options_value(v) }.join(" ") + "]"
-      end
-
-    end
-  end
-end

data/lib/aws/core/response_cache.rb

@@ -1,50 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-
-    # @api private
-    class ResponseCache
-
-      attr_reader :cached_responses
-
-      attr_reader :resource_cache
-
-      def initialize
-        @cached_responses = []
-        @indexed_responses = {}
-        @resource_cache = ResourceCache.new
-      end
-
-      def add(resp)
-        cached_responses.unshift(resp)
-        @indexed_responses[resp.cache_key] = resp if
-          resp.respond_to?(:cache_key)
-        @resource_cache = ResourceCache.new
-      end
-
-      def select(*types, &block)
-        cached_responses.select do |resp|
-          types.map{|t| t.to_s }.include?(resp.request_type.to_s) and
-            (block.nil? || block.call(resp))
-        end
-      end
-
-      def cached(resp)
-        @indexed_responses[resp.cache_key]
-      end
-
-    end
-  end
-end

data/lib/aws/core/rest_error_parser.rb

@@ -1,24 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-
-    # @api private
-    module RESTErrorParser
-
-
-    end
-
-  end
-end

data/lib/aws/core/rest_json_client.rb

@@ -1,40 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-    class RESTJSONClient < Core::Client
-
-      protected
-
-      def self.request_builder_for api_config, operation
-        Core::RESTRequestBuilder.new(operation, :format => :json)
-      end
-
-      def self.response_parser_for api_config, operation
-        Core::RESTResponseParser.new(operation, :format => :json)
-      end
-
-      def extract_error_details response
-        if
-          response.http_response.status >= 300 and
-          body = response.http_response.body and
-          json = (::JSON.load(body) rescue nil)
-        then
-          [json['code'], json['message']]
-        end
-      end
-
-    end
-  end
-end

data/lib/aws/core/rest_request_builder.rb

@@ -1,154 +0,0 @@
-# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-#     http://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file is
-# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
-# ANY KIND, either express or implied. See the License for the specific
-# language governing permissions and limitations under the License.
-
-module AWS
-  module Core
-
-    # Given a hash of request options, a REST::RequestHandler can
-    # populate a Core::Http::Request object.
-    class RESTRequestBuilder
-
-      # @api private
-      def initialize operation, options = {}
-
-        @http = operation[:http]
-        @rules = operation[:inputs]
-
-        @validator = Options::Validator.new(@rules)
-
-        @serializer =
-          case options[:format]
-          when :xml
-            namespace = options[:xmlnamespace]
-            name = operation[:name]
-            Options::XMLSerializer.new(namespace, name, operation)
-          when :json
-            Options::JSONSerializer.new(@rules, @http[:request_payload])
-          else
-            raise ArgumentError, "unhandled format: #{options[:format]}"
-          end
-
-      end
-
-      # Populates a Http::Request with the following:
-      #
-      #   * HTTP method
-      #   * URI
-      #   * headers
-      #   * body
-      #
-      # @param [Http::Request] request
-      #
-      # @param [Hash] params The hash of request options provided
-      #   to the client request method.  This will be used to populate
-      #   the headers, uri and body.
-      #
-      # @raise [ArgumentError] Raises ArgumentError when any of the
-      #   request options are invalid (wrong type, missing, unknown, etc).
-      #
-      def populate_request request, params
-        params = @validator.validate!(params)
-        populate_method(request)
-        populate_uri(request, params)
-        populate_headers(request, params)
-        populate_body(request, params)
-      end
-
-      private
-
-      def populate_method request
-        request.http_method = @http[:verb]
-      end
-
-      def populate_uri request, params
-        request.uri = extract_uri(params)
-      end
-
-      def populate_headers request, params
-        extract_headers(params).each_pair do |header_name, header_value|
-          request.headers[header_name] = header_value
-        end
-      end
-
-      # @param [Hash] params
-      # @return [String]
-      def extract_uri params
-
-        path, querystring = @http[:uri].split(/\?/)
-
-        uri = path.gsub(/:\w+/) do |param_name|
-          if param = params.delete(param_name.sub(/^:/, '').to_sym)
-            UriEscape.escape(param)
-          else
-            raise ArgumentError, "missing required option #{param_name}"
-          end
-        end
-
-        querystring_parts = []
-        querystring.to_s.split(/&|;/).each do |part|
-          param_name = part.match(/:(\w+)/)[1]
-          if param = params.delete(param_name.to_sym)
-            param = UriEscape.escape(param)
-            querystring_parts << part.sub(/:#{param_name}/, param)
-          end
-        end
-
-        unless querystring_parts.empty?
-          uri << "?#{querystring_parts.join('&')}"
-        end
-
-        uri
-
-      end
-
-      # @param [Hash] params
-      # @return [Hash]
-      def extract_headers params
-        headers = {}
-        (@http[:request_headers] || {}).each_pair do |param,header|
-          headers[header] = params[param] if params.key?(param)
-        end
-        headers
-      end
-
-      # @param [Hash] params
-      # @return [String,nil]
-      def populate_body request, params
-        if params.empty?
-          request.body = nil
-        elsif payload = streaming_param # streaming request
-          request.body_stream = params[payload]
-          request.headers['Content-Length'] = size(params[payload])
-        else
-          request.body = @serializer.serialize(params)
-        end
-      end
-
-      def size(payload)
-        if payload.respond_to?(:path) && payload.path
-          File.size(payload.path)
-        else
-          payload.size
-        end
-      end
-
-      def streaming_param
-        if payload = @http[:request_payload]
-          @rules[payload][:type] == :blob ? payload : nil
-        end
-      end
-
-    end
-
-  end
-end