X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/4665331502c7a6169e990bb1358278bb798f9f3b..349c26fa8bf0de53d915c81a03da65d99c53de0c:/lib/google/api_client/batch.rb diff --git a/lib/google/api_client/batch.rb b/lib/google/api_client/batch.rb index 94c651efef..627b7680af 100644 --- a/lib/google/api_client/batch.rb +++ b/lib/google/api_client/batch.rb @@ -14,46 +14,83 @@ require 'addressable/uri' require 'google/api_client/reference' -require 'uuidtools' +require 'securerandom' module Google class APIClient + ## # Helper class to contain a response to an individual batched call. + # + # @api private class BatchedCallResponse + # @return [String] UUID of the call attr_reader :call_id - attr_accessor :status, :headers, :body + # @return [Fixnum] HTTP status code + attr_accessor :status + # @return [Hash] HTTP response headers + attr_accessor :headers + # @return [String] HTTP response body + attr_accessor :body + ## + # Initialize the call response + # + # @param [String] call_id + # UUID of the original call + # @param [Fixnum] status + # HTTP status + # @param [Hash] headers + # HTTP response headers + # @param [#read, #to_str] body + # Response body def initialize(call_id, status = nil, headers = nil, body = nil) @call_id, @status, @headers, @body = call_id, status, headers, body end end - - ## + # Wraps multiple API calls into a single over-the-wire HTTP request. + # + # @example + # + # client = Google::APIClient.new + # urlshortener = client.discovered_api('urlshortener') + # batch = Google::APIClient::BatchRequest.new do |result| + # puts result.data + # end + # + # batch.add(:api_method => urlshortener.url.insert, :body_object => { 'longUrl' => 'http://example.com/foo' }) + # batch.add(:api_method => urlshortener.url.insert, :body_object => { 'longUrl' => 'http://example.com/bar' }) + # + # client.execute(batch) + # class BatchRequest < Request BATCH_BOUNDARY = "-----------RubyApiBatchRequest".freeze - attr_reader :calls, :callbacks + # @api private + # @return [Array<(String,Google::APIClient::Request,Proc)] List of API calls in the batch + attr_reader :calls ## # Creates a new batch request. # # @param [Hash] options - # Set of options for this request, the only important one being - # :connection, which specifies an HTTP connection to use. + # Set of options for this request. # @param [Proc] block # Callback for every call's response. Won't be called if a call defined # a callback of its own. # - # @return [Google::APIClient::BatchRequest] The constructed object. + # @return [Google::APIClient::BatchRequest] + # The constructed object. + # + # @yield [Google::APIClient::Result] + # block to be called when result ready def initialize(options = {}, &block) @calls = [] @global_callback = block if block_given? @last_auto_id = 0 - - # TODO(sgomes): Use SecureRandom.uuid, drop UUIDTools when we drop 1.8 - @base_id = UUIDTools::UUID.random_create.to_s + + @base_id = SecureRandom.uuid options[:uri] ||= 'https://www.googleapis.com/batch' options[:http_method] ||= 'POST' @@ -67,11 +104,18 @@ module Google # automatically be generated, avoiding collisions. If duplicate call IDs # are provided, an error will be thrown. # - # @param [Hash, Google::APIClient::Reference] call: the call to be added. - # @param [String] call_id: the ID to be used for this call. Must be unique - # @param [Proc] block: callback for this call's response. + # @param [Hash, Google::APIClient::Request] call + # the call to be added. + # @param [String] call_id + # the ID to be used for this call. Must be unique + # @param [Proc] block + # callback for this call's response. + # + # @return [Google::APIClient::BatchRequest] + # the BatchRequest, for chaining # - # @return [Google::APIClient::BatchRequest] The BatchRequest, for chaining + # @yield [Google::APIClient::Result] + # block to be called when result ready def add(call, call_id = nil, &block) unless call.kind_of?(Google::APIClient::Reference) call = Google::APIClient::Reference.new(call) @@ -82,50 +126,65 @@ module Google 'A call with this ID already exists: %s' % call_id end callback = block_given? ? block : @global_callback - @calls << [call_id, call, callback] + @calls << [call_id, call, callback] return self end ## # Processes the HTTP response to the batch request, issuing callbacks. # - # @param [Faraday::Response] response: the HTTP response. - def process_response(response) + # @api private + # + # @param [Faraday::Response] response + # the HTTP response. + def process_http_response(response) content_type = find_header('Content-Type', response.headers) - boundary = /.*boundary=(.+)/.match(content_type)[1] - parts = response.body.split(/--#{Regexp.escape(boundary)}/) - parts = parts[1...-1] - parts.each do |part| - call_response = deserialize_call_response(part) - _, call, callback = @calls.assoc(call_response.call_id) - result = Google::APIClient::Result.new(call, call_response) - callback.call(result) if callback + m = /.*boundary=(.+)/.match(content_type) + if m + boundary = m[1] + parts = response.body.split(/--#{Regexp.escape(boundary)}/) + parts = parts[1...-1] + parts.each do |part| + call_response = deserialize_call_response(part) + _, call, callback = @calls.assoc(call_response.call_id) + result = Google::APIClient::Result.new(call, call_response) + callback.call(result) if callback + end end + Google::APIClient::Result.new(self, response) end ## # Return the request body for the BatchRequest's HTTP request. # - # @return [String] The request body. + # @api private + # + # @return [String] + # the request body. def to_http_request if @calls.nil? || @calls.empty? raise BatchError, 'Cannot make an empty batch request' end - parts = @calls.map {|(call_id, call, callback)| serialize_call(call_id, call)} + parts = @calls.map {|(call_id, call, _callback)| serialize_call(call_id, call)} build_multipart(parts, 'multipart/mixed', BATCH_BOUNDARY) super end - - + + protected ## # Helper method to find a header from its name, regardless of case. # - # @param [String] name: The name of the header to find. - # @param [Hash] headers: The hash of headers and their values. + # @api private + # + # @param [String] name + # the name of the header to find. + # @param [Hash] headers + # the hash of headers and their values. # - # @return [String] The value of the desired header. + # @return [String] + # the value of the desired header. def find_header(name, headers) _, header = headers.detect do |h, v| h.downcase == name.downcase @@ -136,7 +195,10 @@ module Google ## # Create a new call ID. Uses an auto-incrementing, conflict-avoiding ID. # - # @return [String] the new, unique ID. + # @api private + # + # @return [String] + # the new, unique ID. def new_id @last_auto_id += 1 while @calls.assoc(@last_auto_id) @@ -145,31 +207,37 @@ module Google return @last_auto_id.to_s end - - ## # Convert a Content-ID header value to an id. Presumes the Content-ID # header conforms to the format that id_to_header() returns. # - # @param [String] header: Content-ID header value. + # @api private + # + # @param [String] header + # Content-ID header value. # - # @return [String] The extracted ID value. + # @return [String] + # The extracted ID value. def header_to_id(header) if !header.start_with?('<') || !header.end_with?('>') || !header.include?('+') raise BatchError, 'Invalid value for Content-ID: "%s"' % header end - base, call_id = header[1...-1].split('+') + _base, call_id = header[1...-1].split('+') return Addressable::URI.unencode(call_id) end ## # Auxiliary method to split the headers from the body in an HTTP response. # - # @param [String] response: the response to parse. + # @api private + # + # @param [String] response + # the response to parse. # - # @return [Array, String] The headers and the body, separately. + # @return [Array, String] + # the headers and the body, separately. def split_headers_and_body(response) headers = {} payload = response.lstrip @@ -190,14 +258,17 @@ module Google ## # Convert a single batched response into a BatchedCallResponse object. # - # @param [Google::APIClient::Reference] response: + # @api private + # + # @param [String] call_response # the request to deserialize. # - # @return [BatchedCallResponse] The parsed and converted response. + # @return [Google::APIClient::BatchedCallResponse] + # the parsed and converted response. def deserialize_call_response(call_response) outer_headers, outer_body = split_headers_and_body(call_response) status_line, payload = outer_body.split("\n", 2) - protocol, status, reason = status_line.split(' ', 3) + _protocol, status, _reason = status_line.split(' ', 3) headers, body = split_headers_and_body(payload) content_id = find_header('Content-ID', outer_headers) @@ -206,33 +277,40 @@ module Google end ## - # Convert a single batched call into a string. + # Serialize a single batched call for assembling the multipart message + # + # @api private # - # @param [Google::APIClient::Reference] call: the call to serialize. + # @param [Google::APIClient::Request] call + # the call to serialize. # - # @return [StringIO] The request as a string in application/http format. + # @return [Faraday::UploadIO] + # the serialized request def serialize_call(call_id, call) - http_request = call.to_http_request - body = "#{http_request.method.to_s.upcase} #{http_request.path} HTTP/1.1" - http_request.headers.each do |header, value| - body << "\r\n%s: %s" % [header, value] + method, uri, headers, body = call.to_http_request + request = "#{method.to_s.upcase} #{Addressable::URI.parse(uri).request_uri} HTTP/1.1" + headers.each do |header, value| + request << "\r\n%s: %s" % [header, value] end - if http_request.body - # TODO - CompositeIO if body is a stream - body << "\r\n\r\n" - if http_request.body.respond_to?(:read) - body << http_request.body.read + if body + # TODO - CompositeIO if body is a stream + request << "\r\n\r\n" + if body.respond_to?(:read) + request << body.read else - body << http_request.body.to_s + request << body.to_s end end - Faraday::UploadIO.new(StringIO.new(body), 'application/http', 'ruby-api-request', 'Content-ID' => id_to_header(call_id)) + Faraday::UploadIO.new(StringIO.new(request), 'application/http', 'ruby-api-request', 'Content-ID' => id_to_header(call_id)) end - + ## # Convert an id to a Content-ID header value. # - # @param [String] call_id: identifier of individual call. + # @api private + # + # @param [String] call_id + # identifier of individual call. # # @return [String] # A Content-ID header with the call_id encoded into it. A UUID is @@ -241,7 +319,7 @@ module Google def id_to_header(call_id) return '<%s+%s>' % [@base_id, Addressable::URI.encode(call_id)] end - + end end end \ No newline at end of file