# 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.
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>
@return [String] The API version of the request/client.
@return [Boolean] true if the response was generated from a
another cached response.
@return [Boolean] true if the response was generated from a
another cached response.
@api private
@return [Hash] Returns the response data as a hash.
@return [Float] The total number of seconds taken to make the
request and return the response.
@return [AWS::Error,nil] Returns nil unless the request failed.
Normally this will be nil unless you are using the Asynchronous interface.
@return [Core::Http::Request]
@return [Core::Http::Response]
@return [Hash] Returns the hash of options passed to the client
request method that generated this response.
@return [Symbol] The name of the client request method that
returned this response.
@return [Integer] Returns the number of times the request
was retried.
@param [Http::Request] #http_request @param [Http::Response] #http_response
# File lib/aws/core/response.rb, line 107 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`.
@param [Symbol,String] key @return [Hash,nil]
# File lib/aws/core/response.rb, line 122 def [] key data[key] end
@return [String] @api private
# File lib/aws/core/response.rb, line 145 def cache_key [ api_version, http_request.access_key_id, http_request.host, request_type, serialized_options ].join(":") end
@return [String] @api private
# File lib/aws/core/response.rb, line 139 def inspect data.inspect end
@return [Boolean] Returns `true` if the http request failed due to
a networking issue.
# File lib/aws/core/response.rb, line 133 def network_error? http_response.network_error? 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
# File lib/aws/core/response.rb, line 159 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.
# File lib/aws/core/response.rb, line 167 def safe_to_retry? @http_request.body_stream.nil? or @http_request.body_stream.respond_to?(:rewind) end
@return [Boolean] Returns true if there is no response error.
# File lib/aws/core/response.rb, line 127 def successful? error.nil? end
# File lib/aws/core/response.rb, line 174 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
# File lib/aws/core/response.rb, line 187 def method_missing *args, &block Core::Data.new(data).send(*args, &block) end
# File lib/aws/core/response.rb, line 209 def serialize_options_array array "[" + array.map{|v| serialize_options_value(v) }.join(" ") + "]" end
# File lib/aws/core/response.rb, line 195 def serialize_options_hash(hash) "(" + hash.keys.sort_by(&:to_s).map do |key| "#{key}=#{serialize_options_value(hash[key])}" end.join(" ") + ")" end
# File lib/aws/core/response.rb, line 201 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
# File lib/aws/core/response.rb, line 191 def serialized_options serialize_options_hash(request_options) end