chiu/google-api-ruby-client
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Continue internal shuffling...

Browse Source
This commit is contained in:
Steven Bazyl committed 2012-10-10 14:28:45 -06:00
1 parent f9c1ab67ba
commit fc45135fcd
13 files changed
+503 -385
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lib/google/api_client.rb
+83 -104
View File
@@ -30,9 +30,6 @@ require 'google/api_client/service_account'
require 'google/api_client/batch'
module Google
# TODO(bobaman): Document all this stuff.
##
# This class manages APIs communication.
class APIClient
@@ -66,23 +63,23 @@ module Google
def initialize(options={})
# Normalize key to String to allow indifferent access.
options = options.inject({}) do |accu, (key, value)|
accu[key.to_s] = value
accu[key.to_sym] = value
accu
end
# Almost all API usage will have a host of 'www.googleapis.com'.
self.host = options["host"] || 'www.googleapis.com'
self.port = options["port"] || 443
self.discovery_path = options["discovery_path"] || '/discovery/v1'
self.host = options[:host] || 'www.googleapis.com'
self.port = options[:port] || 443
self.discovery_path = options[:discovery_path] || '/discovery/v1'
# Most developers will want to leave this value alone and use the
# application_name option.
application_string = (
options["application_name"] ? (
"#{options["application_name"]}/" +
"#{options["application_version"] || '0.0.0'}"
options[:application_name] ? (
"#{options[:application_name]}/" +
"#{options[:application_version] || '0.0.0'}"
) : ""
)
self.user_agent = options["user_agent"] || (
self.user_agent = options[:user_agent] || (
"#{application_string} " +
"google-api-ruby-client/#{VERSION::STRING} " +
ENV::OS_VERSION
@@ -90,9 +87,9 @@ module Google
# The writer method understands a few Symbols and will generate useful
# default authentication mechanisms.
self.authorization =
options.key?("authorization") ? options["authorization"] : :oauth_2
self.key = options["key"]
self.user_ip = options["user_ip"]
options.key?(:authorization) ? options[:authorization] : :oauth_2
self.key = options[:key]
self.user_ip = options[:user_ip]
@discovery_uris = {}
@discovery_documents = {}
@discovered_apis = {}
@@ -195,31 +192,6 @@ module Google
# The base path. Should almost always be '/discovery/v1'.
attr_accessor :discovery_path
##
# Resolves a URI template against the client's configured base.
#
# @param [String, Addressable::URI, Addressable::Template] template
# The template to resolve.
# @param [Hash] mapping The mapping that corresponds to the template.
# @return [Addressable::URI] The expanded URI.
def resolve_uri(template, mapping={})
@base_uri ||= Addressable::URI.new(
:scheme => 'https',
:host => self.host,
:port => self.port
).normalize
template = if template.kind_of?(Addressable::Template)
template.pattern
elsif template.respond_to?(:to_str)
template.to_str
else
raise TypeError,
"Expected String, Addressable::URI, or Addressable::Template, " +
"got #{template.class}."
end
return Addressable::Template.new(@base_uri + template).expand(mapping)
end
##
# Returns the URI for the directory document.
#
@@ -292,7 +264,7 @@ module Google
response = self.execute!(
:http_method => :get,
:uri => self.directory_uri,
:authorization => :none
:authenticated => false
)
response.data
end)
@@ -311,7 +283,7 @@ module Google
response = self.execute!(
:http_method => :get,
:uri => self.discovery_uri(api, version),
:authorization => :none
:authenticated => false
)
response.data
end)
@@ -447,7 +419,7 @@ module Google
response = self.execute!(
:http_method => :get,
:uri => 'https://www.googleapis.com/oauth2/v1/certs',
:authorization => :none
:authenticated => false
)
@certificates.merge!(
Hash[MultiJson.load(response.body).map do |key, cert|
@@ -464,31 +436,6 @@ module Google
return nil
end
def normalize_api_method(options)
method = options[:api_method]
version = options[:version]
if method.kind_of?(Google::APIClient::Method) || method == nil
return method
elsif method.respond_to?(:to_str) || method.kind_of?(Symbol)
# This method of guessing the API is unreliable. This will fail for
# APIs where the first segment of the RPC name does not match the
# service name. However, this is a fallback mechanism anyway.
# Developers should be passing in a reference to the method, rather
# than passing in a string or symbol. This should raise an error
# in the case of a mismatch.
method = method.to_s
api = method[/^([^.]+)\./, 1]
api_method = self.discovered_method(method, api, version)
if api_method.nil?
raise ArgumentError, "API method could not be found."
end
return api_method
else
raise TypeError,
"Expected Google::APIClient::Method, got #{new_api_method.class}."
end
end
##
# Generates a request.
#
@@ -516,46 +463,19 @@ module Google
# {'collection' => 'public', 'userId' => 'me'}
# )
def generate_request(options={})
# Note: The merge method on a Hash object will coerce an API Reference
# object into a Hash and merge with the default options.
options={
:version => 'v1',
:authorization => self.authorization,
:key => self.key,
:user_ip => self.user_ip,
:connection => Faraday.default_connection
options = {
:api_client => self
}.merge(options)
options[:api_method] = self.normalize_api_method(options) unless options[:api_method].nil?
return Google::APIClient::Reference.new(options)
end
##
# Transmits the request using the current HTTP adapter.
#
# @option options [Array, Faraday::Request] :request
# The HTTP request to transmit.
# @option options [Faraday::Connection] :connection
# The HTTP connection to use.
#
# @return [Faraday::Response] The response from the server.
def transmit(options={})
options[:connection] ||= Faraday.default_connection
request = options[:request]
request['User-Agent'] ||= '' + self.user_agent unless self.user_agent.nil?
request_env = request.to_env(options[:connection])
response = options[:connection].app.call(request_env)
return response
return Google::APIClient::Request.new(options)
end
##
# Executes a request, wrapping it in a Result object.
#
# @param [Google::APIClient::BatchRequest, Hash, Array] params
# Either a Google::APIClient::BatchRequest, a Hash, or an Array.
# @param [Google::APIClient::Request, Hash, Array] params
# Either a Google::APIClient::Request, a Hash, or an Array.
#
# If a Google::APIClient::BatchRequest, no other parameters are expected.
# If a Google::APIClient::Request, no other parameters are expected.
#
# If a Hash, the below parameters are handled. If an Array, the
# parameters are assumed to be in the below order:
@@ -592,6 +512,7 @@ module Google
if params.last.kind_of?(Google::APIClient::Request) &&
params.size == 1
request = params.pop
options = {}
else
# This block of code allows us to accept multiple parameter passing
# styles, and maintaining some backwards compatibility.
@@ -610,13 +531,16 @@ module Google
options[:client] = self
request = self.generate_request(options)
end
response = self.transmit(:request => request.to_http_request, :connection => Faraday.default_connection)
result = request.process_response(response)
connection = options[:connection] || Faraday.default_connection
request.authorization = options[:authorization] || self.authorization unless options[:authenticated] == false
result = request.send(connection)
if request.upload_type == 'resumable'
upload = result.resumable_upload
unless upload.complete?
response = self.transmit(:request => upload.to_http_request, :connection => Faraday.default_connection)
result = upload.process_response(response)
result = upload.send(connection)
end
end
return result
@@ -646,6 +570,61 @@ module Google
end
return result
end
##
# Ensures API method names specified as strings resolve to
# discovered method instances
def resolve_method(method, version)
version ||= 'v1'
if method.kind_of?(Google::APIClient::Method) || method == nil
return method
elsif method.respond_to?(:to_str) || method.kind_of?(Symbol)
# This method of guessing the API is unreliable. This will fail for
# APIs where the first segment of the RPC name does not match the
# service name. However, this is a fallback mechanism anyway.
# Developers should be passing in a reference to the method, rather
# than passing in a string or symbol. This should raise an error
# in the case of a mismatch.
method = method.to_s
api = method[/^([^.]+)\./, 1]
api_method = self.discovered_method(method, api, version)
if api_method.nil?
raise ArgumentError, "API method could not be found."
end
return api_method
else
raise TypeError,
"Expected Google::APIClient::Method, got #{method.class}."
end
end
protected
##
# Resolves a URI template against the client's configured base.
#
# @param [String, Addressable::URI, Addressable::Template] template
# The template to resolve.
# @param [Hash] mapping The mapping that corresponds to the template.
# @return [Addressable::URI] The expanded URI.
def resolve_uri(template, mapping={})
@base_uri ||= Addressable::URI.new(
:scheme => 'https',
:host => self.host,
:port => self.port
).normalize
template = if template.kind_of?(Addressable::Template)
template.pattern
elsif template.respond_to?(:to_str)
template.to_str
else
raise TypeError,
"Expected String, Addressable::URI, or Addressable::Template, " +
"got #{template.class}."
end
return Addressable::Template.new(@base_uri + template).expand(mapping)
end
end
end
lib/google/api_client/batch.rb
+14 -14
View File
@@ -40,8 +40,7 @@ module Google
# 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.
@@ -67,7 +66,7 @@ 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 [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.
#
@@ -90,7 +89,7 @@ module Google
# Processes the HTTP response to the batch request, issuing callbacks.
#
# @param [Faraday::Response] response: the HTTP response.
def process_response(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)}/)
@@ -212,21 +211,22 @@ module Google
#
# @return [StringIO] The request as a string in application/http format.
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]
call.api_client = self.api_client
method, uri, headers, body = call.to_http_request
request = "#{method.to_s.upcase} #{Addressable::URI.parse(uri).path} HTTP/1.1"
headers.each do |header, value|
request << "\r\n%s: %s" % [header, value]
end
if http_request.body
if 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
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
##
lib/google/api_client/discovery/method.rb
+4 -11
View File
@@ -222,21 +222,14 @@ module Google
# The HTTP connection to use.
#
# @return [Array] The generated HTTP request.
def generate_request(parameters={}, body='', headers=[], options={})
options[:connection] ||= Faraday.default_connection
def generate_request(parameters={}, body='', headers={}, options={})
if !headers.kind_of?(Array) && !headers.kind_of?(Hash)
raise TypeError, "Expected Hash or Array, got #{headers.class}."
end
method = self.http_method
method = self.http_method.to_s.downcase.to_sym
uri = self.generate_uri(parameters)
headers = headers.to_a if headers.kind_of?(Hash)
return options[:connection].build_request(
method.to_s.downcase.to_sym
) do |req|
req.url(Addressable::URI.parse(uri).to_s)
req.headers = Faraday::Utils::Headers.new(headers)
req.body = body
end
headers = Faraday::Utils::Headers.new(headers)
return [method, uri, headers, body]
end
lib/google/api_client/media.rb
+1 -1
View File
@@ -131,7 +131,7 @@ module Google
#
# @param [Faraday::Response] r
# Result of a chunk upload or range query
def process_response(response)
def process_http_response(response)
case response.status
when 200...299
@complete = true
lib/google/api_client/reference.rb
+103 -104
View File
@@ -26,23 +26,23 @@ module Google
class Request
MULTIPART_BOUNDARY = "-----------RubyApiMultipartPost".freeze
attr_reader :connection, :parameters, :api_method, :headers
attr_accessor :media, :authorization, :body
attr_reader :parameters, :headers
attr_accessor :api_client, :connection, :api_method, :version ,:media, :authorization, :authenticated, :body
def initialize(options={})
self.connection = options[:connection] || Faraday.default_connection
self.authorization = options[:authorization]
self.api_method = options[:api_method]
@parameters = Hash[options[:parameters] || {}]
@headers = Faraday::Utils::Headers.new
self.api_client = options[:api_client]
self.headers.merge!(options[:headers]) unless options[:headers].nil?
self.api_method = options[:api_method]
self.version = options[:version]
self.authenticated = options[:authenticated]
self.authorization = options[:authorization]
# These parameters are handled differently because they're not
# parameters to the API method, but rather to the API system.
self.parameters['key'] ||= options[:key] if options[:key]
self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
@headers = Faraday::Utils::Headers.new
self.headers.merge!(options[:headers]) if options[:headers]
if options[:media]
self.initialize_media_upload(options)
@@ -58,12 +58,102 @@ module Google
unless self.api_method
self.http_method = options[:http_method] || 'GET'
self.uri = options[:uri]
unless self.parameters.empty?
self.uri.query = Addressable::URI.form_encode(self.parameters)
end
end
end
def upload_type
return self.parameters['uploadType'] || self.parameters['upload_type']
end
def http_method
return @http_method ||= self.api_method.http_method.to_s.downcase.to_sym
end
def http_method=(new_http_method)
if new_http_method.kind_of?(Symbol)
@http_method = new_http_method.to_s.downcase.to_sym
elsif new_http_method.respond_to?(:to_str)
@http_method = new_http_method.to_s.downcase.to_sym
else
raise TypeError,
"Expected String or Symbol, got #{new_http_method.class}."
end
end
def uri
return @uri ||= self.api_method.generate_uri(self.parameters)
end
def uri=(new_uri)
@uri = Addressable::URI.parse(new_uri)
@parameters.update(@uri.query_values) unless @uri.query_values.nil?
end
def send(connection)
response = connection.app.call(self.to_env(connection))
self.process_http_response(response)
end
def to_http_request
if self.api_client
self.headers['User-Agent'] ||= '' + self.api_client.user_agent unless self.api_client.user_agent.nil?
self.parameters['key'] ||= self.api_client.key unless self.api_client.key.nil?
self.parameters['userIp'] ||= self.api_client.user_ip unless self.api_client.user_ip.nil?
self.api_method = self.api_client.resolve_method(self.api_method, self.version) unless self.api_method.nil?
end
request = (
if self.uri
unless self.parameters.empty?
self.uri.query = Addressable::URI.form_encode(self.parameters)
end
[self.http_method, self.uri.to_s, self.headers, self.body]
else
self.api_method.generate_request(self.parameters, self.body, self.headers)
end)
end
def to_hash
options = {}
if self.api_method
options[:api_method] = self.api_method
options[:parameters] = self.parameters
else
options[:http_method] = self.http_method
options[:uri] = self.uri
end
options[:headers] = self.headers
options[:body] = self.body
options[:media] = self.media
unless self.authorization.nil?
options[:authorization] = self.authorization
end
return options
end
def to_env(connection)
method, uri, headers, body = self.to_http_request
http_request = connection.build_request(method) do |req|
req.url(uri)
req.headers.update(headers)
req.body = body
end
if self.authorization.respond_to?(:generate_authenticated_request)
http_request = self.authorization.generate_authenticated_request(
:request => http_request,
:connection => connection
)
end
request_env = http_request.to_env(connection)
end
def process_http_response(response)
Result.new(self, response)
end
protected
def initialize_media_upload(options)
self.media = options[:media]
case self.upload_type
@@ -109,97 +199,6 @@ module Google
'Must respond to :to_json or :to_hash.'
end
def upload_type
return self.parameters['uploadType'] || self.parameters['upload_type']
end
def connection=(new_connection)
if new_connection.kind_of?(Faraday::Connection)
@connection = new_connection
else
raise TypeError,
"Expected Faraday::Connection, got #{new_connection.class}."
end
end
def api_method=(new_api_method)
if new_api_method.kind_of?(Google::APIClient::Method) ||
new_api_method == nil
@api_method = new_api_method
else
raise TypeError,
"Expected Google::APIClient::Method, got #{new_api_method.class}."
end
end
def http_method
return @http_method ||= self.api_method.http_method.to_s.downcase.to_sym
end
def http_method=(new_http_method)
if new_http_method.kind_of?(Symbol)
@http_method = new_http_method.to_s.downcase.to_sym
elsif new_http_method.respond_to?(:to_str)
@http_method = new_http_method.to_s.downcase.to_sym
else
raise TypeError,
"Expected String or Symbol, got #{new_http_method.class}."
end
end
def uri
return @uri ||= self.api_method.generate_uri(self.parameters)
end
def uri=(new_uri)
@uri = Addressable::URI.parse(new_uri)
end
def to_http_request
request = (
if self.uri
self.connection.build_request(self.http_method) do |req|
req.url(self.uri.to_str)
req.headers.update(self.headers)
req.body = self.body
end
else
self.api_method.generate_request(
self.parameters, self.body, self.headers, :connection => self.connection
)
end)
if self.authorization.respond_to?(:generate_authenticated_request)
request = self.authorization.generate_authenticated_request(
:request => request,
:connection => self.connection
)
end
return request
end
def to_hash
options = {}
if self.api_method
options[:api_method] = self.api_method
options[:parameters] = self.parameters
else
options[:http_method] = self.http_method
options[:uri] = self.uri
end
options[:headers] = self.headers
options[:body] = self.body
options[:connection] = self.connection
options[:media] = self.media
unless self.authorization.nil?
options[:authorization] = self.authorization
end
return options
end
def process_response(response)
Result.new(self, response)
end
end
class Reference < Request