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.
#
# `true` if the request must be signed or somehow
# authenticated, `false` otherwise.
#
- # @return [Faraday::Request] The generated request.
+ # @return [Google::APIClient::Reference] The generated request.
#
# @example
# request = client.generate_request(
:user_ip => self.user_ip,
:connection => Faraday.default_connection
}.merge(options)
-
- # The Reference object is going to need this to do method ID lookups.
- options[:client] = self
- # The default value for the :authenticated option depends on whether an
- # authorization mechanism has been set.
- if options[:authorization]
- options = {:authenticated => true}.merge(options)
- else
- options = {:authenticated => false}.merge(options)
- end
- reference = Google::APIClient::Reference.new(options)
- request = reference.to_request
- if options[:authenticated] && options[:authorization].respond_to?(:generate_authenticated_request)
- request = options[:authorization].generate_authenticated_request(
- :request => request,
- :connection => options[:connection]
- )
- end
- return request
- end
-
- ##
- # Signs a request using the current authorization mechanism.
- #
- # @param [Hash] options a customizable set of options
- #
- # @return [Faraday::Request] The signed or otherwise authenticated request.
- # @deprecated No longer used internally
- def generate_authenticated_request(options={})
- return authorization.generate_authenticated_request(options)
+
+ options[:api_method] = self.normalize_api_method(options)
+ return Google::APIClient::Reference.new(options)
end
##
#
# @option options [Array, Faraday::Request] :request
# The HTTP request to transmit.
- # @option options [String, Symbol] :method
- # The method for the HTTP request.
- # @option options [String, Addressable::URI] :uri
- # The URI for the HTTP request.
- # @option options [Array, Hash] :headers
- # The headers for the HTTP request.
- # @option options [String] :body
- # The body for the HTTP request.
# @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
- if options[:request]
- if options[:request].kind_of?(Array)
- method, uri, headers, body = options[:request]
- elsif options[:request].kind_of?(Faraday::Request)
- unless options[:connection]
- raise ArgumentError,
- "Faraday::Request used, requires a connection to be provided."
- end
- method = options[:request].method.to_s.downcase.to_sym
- uri = options[:connection].build_url(
- options[:request].path, options[:request].params
- )
- headers = options[:request].headers || {}
- body = options[:request].body || ''
- end
- else
- method = options[:method] || :get
- uri = options[:uri]
- headers = options[:headers] || []
- body = options[:body] || ''
- end
- headers = headers.to_a if headers.kind_of?(Hash)
- request_components = {
- :method => method,
- :uri => uri,
- :headers => headers,
- :body => body
- }
- # Verify that we have all pieces required to transmit an HTTP request
- request_components.each do |(key, value)|
- unless value
- raise ArgumentError, "Missing :#{key} parameter."
- end
- end
-
- if self.user_agent != nil
- # If there's no User-Agent header, set one.
- unless headers.kind_of?(Enumerable)
- # We need to use some Enumerable methods, relying on the presence of
- # the #each method.
- class << headers
- include Enumerable
- end
- end
- if self.user_agent.kind_of?(String)
- unless headers.any? { |k, v| k.downcase == 'User-Agent'.downcase }
- headers = headers.to_a.insert(0, ['User-Agent', self.user_agent])
- end
- elsif self.user_agent != nil
- raise TypeError,
- "Expected User-Agent to be String, got #{self.user_agent.class}"
- end
- end
-
- request = options[:connection].build_request(
- method.to_s.downcase.to_sym
- ) do |req|
- req.url(Addressable::URI.parse(uri).normalize.to_s)
- req.headers = Faraday::Utils::Headers.new(headers)
- req.body = body
- end
+ 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
params.size == 1
batch = params.pop
options = batch.options
- options[:connection] ||= Faraday.default_connection
- http_request = batch.to_http_request
- request = nil
-
- if @authorization
- method, uri, headers, body = http_request
- method = method.to_s.downcase.to_sym
-
- faraday_request = options[:connection].build_request(
- method.to_s.downcase.to_sym
- ) do |req|
- req.url(Addressable::URI.parse(uri).normalize.to_s)
- req.headers = Faraday::Utils::Headers.new(headers)
- req.body = body
- end
-
- request = {
- :request => self.generate_authenticated_request(
- :request => faraday_request,
- :connection => options[:connection]
- ),
- :connection => options[:connection]
- }
- else
- request = {
- :request => http_request,
- :connection => options[:connection]
- }
- end
-
- response = self.transmit(request)
+ method, uri, headers, body = batch.to_http_request
+ reference = self.generate_request({
+ :uri => uri,
+ :http_method => method,
+ :headers => headers,
+ :body => body
+ }.merge(options))
+ response = self.transmit(:request => reference.to_http_request, :connection => options[:connection])
batch.process_response(response)
return nil
else
options[:body] = params.shift if params.size > 0
options[:headers] = params.shift if params.size > 0
options[:client] = self
- options[:connection] ||= Faraday.default_connection
- reference = Google::APIClient::Reference.new(options)
- request = self.generate_request(reference)
+ reference = self.generate_request(options)
response = self.transmit(
- :request => request,
+ :request => reference.to_http_request,
:connection => options[:connection]
)
- return Google::APIClient::Result.new(reference, request, response)
+ result = Google::APIClient::Result.new(reference, response)
+ return result
end
end
call_response = deserialize_call_response(part)
callback = @callbacks[call_response.call_id]
call = @calls[call_response.call_id]
- result = Google::APIClient::Result.new(call, nil, call_response)
+ result = Google::APIClient::Result.new(call, call_response)
callback.call(result) if callback
end
end
#
# @return [String] The request as a string in application/http format.
def serialize_call(call)
- http_request = call.to_request
+ http_request = call.to_http_request
method = http_request.method.to_s.upcase
path = http_request.path.to_s
status_line = method + " " + path + " HTTP/1.1"
# @return [Array] The generated HTTP request.
def generate_request(parameters={}, body='', headers=[], options={})
options[:connection] ||= Faraday.default_connection
- if body.respond_to?(:string)
- body = body.string
- elsif body.respond_to?(:to_str)
- body = body.to_str
- else
- raise TypeError, "Expected String or StringIO, got #{body.class}."
- end
if !headers.kind_of?(Array) && !headers.kind_of?(Hash)
raise TypeError, "Expected Hash or Array, got #{headers.class}."
end
# See the License for the specific language governing permissions and
# limitations under the License.
-
require 'faraday'
require 'faraday/utils'
require 'multi_json'
MULTIPART_BOUNDARY = "-----------RubyApiMultipartPost".freeze
def initialize(options={})
- # We only need this to do lookups on method ID String values
- # It's optional, but method ID lookups will fail if the client is
- # omitted.
- @client = options[:client]
- @version = options[:version] || 'v1'
self.connection = options[:connection] || Faraday.default_connection
self.authorization = options[:authorization]
self.api_method = options[:api_method]
+
self.parameters = options[:parameters] || {}
# These parameters are handled differently because they're not
# parameters to the API method, but rather to the API system.
- if self.parameters.kind_of?(Array)
- if options[:key]
- self.parameters.reject! { |k, _| k == 'key' }
- self.parameters << ['key', options[:key]]
- end
- if options[:user_ip]
- self.parameters.reject! { |k, _| k == 'userIp' }
- self.parameters << ['userIp', options[:user_ip]]
- end
- elsif self.parameters.kind_of?(Hash)
- self.parameters['key'] ||= options[:key] if options[:key]
- self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
- # Convert to Array, because they're easier to work with when
- # repeated parameters are an issue.
- self.parameters = self.parameters.to_a
- else
- raise TypeError,
- "Expected Array or Hash, got #{self.parameters.class}."
- end
+ self.parameters['key'] ||= options[:key] if options[:key]
+ self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
+
self.headers = options[:headers] || {}
if options[:media]
- self.media = options[:media]
- upload_type = self.parameters.find { |(k, _)| ['uploadType', 'upload_type'].include?(k) }.last
- case upload_type
- when "media"
- if options[:body] || options[:body_object]
- raise ArgumentError,
- "Can not specify body & body object for simple uploads."
- end
- self.headers['Content-Type'] ||= self.media.content_type
- self.body = self.media
- when "multipart"
- unless options[:body_object]
- raise ArgumentError, "Multipart requested but no body object."
- end
- # This is all a bit of a hack due to Signet requiring body to be a
- # string. Ideally, update Signet to delay serialization so we can
- # just pass streams all the way down through to the HTTP library.
- metadata = StringIO.new(serialize_body(options[:body_object]))
- env = {
- :request_headers => {
- 'Content-Type' =>
- "multipart/related;boundary=#{MULTIPART_BOUNDARY}"
- },
- :request => {:boundary => MULTIPART_BOUNDARY}
- }
- multipart = Faraday::Request::Multipart.new
- self.body = multipart.create_multipart(env, [
- [nil, Faraday::UploadIO.new(
- metadata, 'application/json', 'file.json'
- )],
- [nil, self.media]])
- self.headers.update(env[:request_headers])
- when "resumable"
- file_length = self.media.length
- self.headers['X-Upload-Content-Type'] = self.media.content_type
- self.headers['X-Upload-Content-Length'] = file_length.to_s
- if options[:body_object]
- self.headers['Content-Type'] ||= 'application/json'
- self.body = serialize_body(options[:body_object])
- else
- self.body = ''
- end
- else
- raise ArgumentError, "Invalid uploadType for media."
- end
+ self.initialize_media_upload
elsif options[:body]
self.body = options[:body]
elsif options[:body_object]
self.http_method = options[:http_method] || 'GET'
self.uri = options[:uri]
unless self.parameters.empty?
- query_values = (self.uri.query_values(Array) || [])
- self.uri.query = Addressable::URI.form_encode(
- (query_values + self.parameters).sort
- )
- self.uri.query = nil if self.uri.query == ""
+ self.uri.query = Addressable::URI.form_encode(self.parameters)
end
end
end
+ def initialize_media_upload
+ self.media = options[:media]
+ case self.upload_type
+ when "media"
+ if options[:body] || options[:body_object]
+ raise ArgumentError, "Can not specify body & body object for simple uploads"
+ end
+ self.headers['Content-Type'] ||= self.media.content_type
+ self.body = self.media
+ when "multipart"
+ unless options[:body_object]
+ raise ArgumentError, "Multipart requested but no body object"
+ end
+ metadata = StringIO.new(serialize_body(options[:body_object]))
+ env = {
+ :request_headers => {'Content-Type' => "multipart/related;boundary=#{MULTIPART_BOUNDARY}"},
+ :request => { :boundary => MULTIPART_BOUNDARY }
+ }
+ multipart = Faraday::Request::Multipart.new
+ self.body = multipart.create_multipart(env, [
+ [nil,Faraday::UploadIO.new(metadata, 'application/json', 'file.json')],
+ [nil, self.media]])
+ self.headers.update(env[:request_headers])
+ when "resumable"
+ file_length = self.media.length
+ self.headers['X-Upload-Content-Type'] = self.media.content_type
+ self.headers['X-Upload-Content-Length'] = file_length.to_s
+ if options[:body_object]
+ self.headers['Content-Type'] ||= 'application/json'
+ self.body = serialize_body(options[:body_object])
+ else
+ self.body = ''
+ end
+ else
+ raise ArgumentError, "Invalid uploadType for media"
+ end
+ end
+
def serialize_body(body)
return body.to_json if body.respond_to?(:to_json)
return MultiJson.dump(options[:body_object].to_hash) if body.respond_to?(:to_hash)
def media=(media)
@media = (media)
end
+
+ def upload_type
+ return self.parameters['uploadType'] || self.parameters['upload_type']
+ end
def authorization
return @authorization
if new_api_method.kind_of?(Google::APIClient::Method) ||
new_api_method == nil
@api_method = new_api_method
- elsif new_api_method.respond_to?(:to_str) ||
- new_api_method.kind_of?(Symbol)
- unless @client
- raise ArgumentError,
- "API method lookup impossible without client instance."
- end
- new_api_method = new_api_method.to_s
- # 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.
- api = new_api_method[/^([^.]+)\./, 1]
- @api_method = @client.discovered_method(
- new_api_method, api, @version
- )
- if @api_method
- # Ditch the client reference, we won't need it again.
- @client = nil
- else
- raise ArgumentError, "API method could not be found."
- end
else
raise TypeError,
"Expected Google::APIClient::Method, got #{new_api_method.class}."
end
def parameters=(new_parameters)
- # No type-checking needed, the Method class handles this.
- @parameters = new_parameters
+ @parameters = Hash[new_parameters]
end
def body
end
def body=(new_body)
- if new_body.respond_to?(:to_str)
- @body = new_body.to_str
- elsif new_body.respond_to?(:read)
- @body = new_body.read()
- elsif new_body.respond_to?(:inject)
- @body = (new_body.inject(StringIO.new) do |accu, chunk|
- accu.write(chunk)
- accu
- end).string
- else
- raise TypeError,
- "Expected body to be String, IO, or Enumerable chunks."
- end
+ @body = new_body
end
def headers
def http_method=(new_http_method)
if new_http_method.kind_of?(Symbol)
- @http_method = new_http_method.to_s.upcase
+ @http_method = new_http_method.to_s.downcase.to_sym
elsif new_http_method.respond_to?(:to_str)
- @http_method = new_http_method.to_str.upcase
+ @http_method = new_http_method.to_s.downcase.to_sym
else
raise TypeError,
"Expected String or Symbol, got #{new_http_method.class}."
@uri = Addressable::URI.parse(new_uri)
end
- def to_request
- if self.api_method
- return self.api_method.generate_request(
- self.parameters, self.body, self.headers,
+ def to_http_request
+ request = (
+ if self.api_method
+ self.api_method.generate_request(
+ self.parameters, self.body, self.headers, :connection => self.connection
+ )
+ else
+ 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
+ end)
+
+ if self.authorization.respond_to?(:generate_authenticated_request)
+ request = self.authorization.generate_authenticated_request(
+ :request => request,
:connection => self.connection
)
- else
- return self.connection.build_request(
- self.http_method.to_s.downcase.to_sym
- ) do |req|
- req.url(Addressable::URI.parse(self.uri).normalize.to_s)
- req.headers = Faraday::Utils::Headers.new(self.headers)
- req.body = self.body
- end
end
+ return request
end
def to_hash
##
# This class wraps a result returned by an API call.
class Result
- def initialize(reference, request, response)
+ def initialize(reference, response)
@reference = reference
- @request = request
@response = response
end
attr_reader :reference
- attr_reader :request
-
attr_reader :response
def status
:uri => CLIENT.discovery_uri('prediction', 'v1.2'),
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should === (
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
'?userIp=127.0.0.1'
)
:uri => CLIENT.discovery_uri('prediction', 'v1.2'),
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should === (
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
'?key=qwerty'
)
:authenticated => false
)
Addressable::URI.parse(
- request.to_env(Faraday.default_connection)[:url]
+ request.to_http_request.to_env(Faraday.default_connection)[:url]
).query_values.should == {
'key' => 'qwerty',
'userIp' => '127.0.0.1'
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
- request.method.should == :post
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.method.should == :post
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
request.headers.should be_empty
request.body.should == ''
:api_method => @prediction.training.insert,
:parameters => [['data', '1'], ['data','2']]
)
- request.method.should == :post
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.method.should == :post
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=1&data=2'
end
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
end
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
end
:api_method => prediction_rebase.training.insert,
:parameters => {'data' => '123'}
)
- request.to_env(Faraday.default_connection)[:url].to_s.should === (
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://testing-domain.example.com/' +
'prediction/v1.2/training?data=123'
)
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
- request.headers.should have_key('Authorization')
- request.headers['Authorization'].should =~ /^OAuth/
+ http_request = request.to_http_request
+ http_request.headers.should have_key('Authorization')
+ http_request.headers['Authorization'].should =~ /^OAuth/
end
it 'should generate OAuth 2 requests' do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
- request.headers.should have_key('Authorization')
- request.headers['Authorization'].should =~ /^Bearer/
+ http_request = request.to_http_request
+ http_request.headers.should have_key('Authorization')
+ http_request.headers['Authorization'].should =~ /^Bearer/
end
it 'should not be able to execute improperly authorized requests' do
MultiJson.dump({"id" => "bucket/object"}),
{'Content-Type' => 'application/json'}
)
- result.request.headers['Content-Type'].should == 'application/json'
+ result.reference.to_http_request.headers['Content-Type'].should == 'application/json'
end
end
},
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should === (
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/plus/v1/' +
'people/107807692475771887386/activities/public'
)
:api_method => @plus.activities.list,
:parameters => {'alt' => 'json'},
:authenticated => false
- )
+ ).to_http_request
end).should raise_error(ArgumentError)
end
'userId' => '107807692475771887386', 'collection' => 'bogus'
},
:authenticated => false
- )
+ ).to_http_request
end).should raise_error(ArgumentError)
end
end
:api_method => 'latitude.currentLocation.get',
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/latitude/v1/currentLocation'
end
:api_method => @latitude.current_location.get,
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/latitude/v1/currentLocation'
end
:api_method => 'moderator.profiles.get',
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/moderator/v1/profiles/@me'
end
:api_method => @moderator.profiles.get,
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/moderator/v1/profiles/@me'
end
:api_method => 'adsense.adclients.list',
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/adsense/v1/adclients'
end
:api_method => @adsense.adclients.list,
:authenticated => false
)
- request.to_env(Faraday.default_connection)[:url].to_s.should ===
+ request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/adsense/v1/adclients'
end
CLIENT.generate_request(
:api_method => @adsense.reports.generate,
:authenticated => false
- )
+ ).to_http_request
end).should raise_error(ArgumentError)
end
'metric' => 'PAGE_VIEWS'
},
:authenticated => false
- )
+ ).to_http_request
end).should_not raise_error
end
'metric' => 'PAGE_VIEWS'
},
:authenticated => false
- )
+ ).to_http_request
end).should raise_error(ArgumentError)
end
'metric' => ['PAGE_VIEWS', 'CLICKS']
},
:authenticated => false
- )
+ ).to_http_request
end).should raise_error(ArgumentError)
end
end
'maxResults' => 20
}
})
- @request = @reference.to_request
+ @request = @reference.to_http_request
# Response stub
@response = stub("response")
}
END_OF_STRING
)
- @result = Google::APIClient::Result.new(@reference, @request, @response)
+ @result = Google::APIClient::Result.new(@reference, @response)
end
it 'should indicate a successful response' do
reference = @result.next_page
Hash[reference.parameters].should include('pageToken')
Hash[reference.parameters]['pageToken'].should == 'NEXT+PAGE+TOKEN'
- url = reference.to_request.to_env(Faraday.default_connection)[:url]
+ url = reference.to_http_request.to_env(Faraday.default_connection)[:url]
url.to_s.should include('pageToken=NEXT%2BPAGE%2BTOKEN')
end
}
END_OF_STRING
)
- @result = Google::APIClient::Result.new(@reference, @request, @response)
+ @result = Google::APIClient::Result.new(@reference, @response)
end
it 'should not return a next page token' do
END_OF_STRING
)
@response.stub(:status).and_return(400)
- @result = Google::APIClient::Result.new(@reference, @request, @response)
+ @result = Google::APIClient::Result.new(@reference, @response)
end
it 'should return error status correctly' do
it 'should transmit a User-Agent header when sending requests' do
client.user_agent = 'Custom User Agent/1.2.3'
- request = Faraday::Request.new(:get) do |req|
- req.url('http://www.google.com/')
- end
+
stubs = Faraday::Adapter::Test::Stubs.new do |stub|
stub.get('/') do |env|
headers = env[:request_headers]
connection = Faraday.new(:url => 'https://www.google.com') do |builder|
builder.adapter(:test, stubs)
end
+ request = connection.build_request(:get) do |req|
+ req.url('http://www.google.com/')
+ end
client.transmit(:request => request, :connection => connection)
stubs.verify_stubbed_calls
end
projects / arvados.git / commitdiff