arvados-google-api-client 0.8.7.2

data/lib/google/api_client/auth/storage.rb

@@ -0,0 +1,102 @@
+# Copyright 2013 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License 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.
+
+require 'signet/oauth_2/client'
+
+module Google
+  class APIClient
+    ##
+    # Represents cached OAuth 2 tokens stored on local disk in a
+    # JSON serialized file. Meant to resemble the serialized format
+    # http://google-api-python-client.googlecode.com/hg/docs/epy/oauth2client.file.Storage-class.html
+    #
+    class Storage
+
+      AUTHORIZATION_URI = 'https://accounts.google.com/o/oauth2/auth'
+      TOKEN_CREDENTIAL_URI = 'https://accounts.google.com/o/oauth2/token'
+
+      # @return [Object] Storage object.
+      attr_accessor :store
+
+      # @return [Signet::OAuth2::Client]
+      attr_reader :authorization
+
+      ##
+      # Initializes the Storage object.
+      #
+      # @params [Object] Storage object
+      def initialize(store)
+        @store= store
+        @authorization = nil
+      end
+
+      ##
+      # Write the credentials to the specified store.
+      #
+      # @params [Signet::OAuth2::Client] authorization
+      #    Optional authorization instance. If not provided, the authorization
+      #    already associated with this instance will be written.
+      def write_credentials(authorization=nil)
+        @authorization = authorization if authorization
+        if @authorization.respond_to?(:refresh_token) && @authorization.refresh_token
+          store.write_credentials(credentials_hash)
+        end
+      end
+
+      ##
+      # Loads credentials and authorizes an client.
+      # @return [Object] Signet::OAuth2::Client or NIL
+      def authorize
+        @authorization = nil
+        cached_credentials = load_credentials
+        if cached_credentials && cached_credentials.size > 0
+          @authorization = Signet::OAuth2::Client.new(cached_credentials)
+          @authorization.issued_at = Time.at(cached_credentials['issued_at'].to_i)
+          self.refresh_authorization if @authorization.expired?
+        end
+        return @authorization
+      end
+
+      ##
+      # refresh credentials and save them to store
+      def refresh_authorization
+        authorization.refresh!
+        self.write_credentials
+      end
+
+      private
+
+      ##
+      # Attempt to read in credentials from the specified store.
+      def load_credentials
+        store.load_credentials
+      end
+
+      ##
+      # @return [Hash] with credentials
+      def credentials_hash
+        {
+          :access_token          => authorization.access_token,
+          :authorization_uri     => AUTHORIZATION_URI,
+          :client_id             => authorization.client_id,
+          :client_secret         => authorization.client_secret,
+          :expires_in            => authorization.expires_in,
+          :refresh_token         => authorization.refresh_token,
+          :token_credential_uri  => TOKEN_CREDENTIAL_URI,
+          :issued_at             => authorization.issued_at.to_i
+        }
+      end
+    end
+  end
+end

data/lib/google/api_client/auth/storages/file_store.rb

@@ -0,0 +1,58 @@
+# Copyright 2013 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License 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.
+
+require 'json'
+
+module Google
+  class APIClient
+    ##
+    # Represents cached OAuth 2 tokens stored on local disk in a
+    # JSON serialized file. Meant to resemble the serialized format
+    # http://google-api-python-client.googlecode.com/hg/docs/epy/oauth2client.file.Storage-class.html
+    #
+    class FileStore
+
+      attr_accessor :path
+
+      ##
+      # Initializes the FileStorage object.
+      #
+      # @param [String] path
+      #    Path to the credentials file.
+      def initialize(path)
+        @path= path
+      end
+
+      ##
+      # Attempt to read in credentials from the specified file.
+      def load_credentials
+        open(path, 'r') { |f| JSON.parse(f.read) }
+      rescue
+        nil
+      end
+
+      ##
+      # Write the credentials to the specified file.
+      #
+      # @param [Signet::OAuth2::Client] authorization
+      #    Optional authorization instance. If not provided, the authorization
+      #    already associated with this instance will be written.
+      def write_credentials(credentials_hash)
+        open(self.path, 'w+') do |f|
+          f.write(credentials_hash.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/google/api_client/auth/storages/redis_store.rb

@@ -0,0 +1,54 @@
+# Copyright 2013 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License 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.
+
+require 'json'
+
+module Google
+  class APIClient
+    class RedisStore
+
+      DEFAULT_REDIS_CREDENTIALS_KEY = "google_api_credentials"
+
+      attr_accessor :redis
+
+      ##
+      # Initializes the RedisStore object.
+      #
+      # @params [Object] Redis instance
+      def initialize(redis, key = nil)
+        @redis= redis
+        @redis_credentials_key = key
+      end
+
+      ##
+      # Attempt to read in credentials from redis.
+      def load_credentials
+        credentials = redis.get redis_credentials_key
+        JSON.parse(credentials) if credentials
+      end
+
+      def redis_credentials_key
+        @redis_credentials_key || DEFAULT_REDIS_CREDENTIALS_KEY
+      end
+
+      ##
+      # Write the credentials to redis.
+      #
+      # @params [Hash] credentials
+      def write_credentials(credentials_hash)
+        redis.set(redis_credentials_key, credentials_hash.to_json)
+      end
+    end
+  end
+end

data/lib/google/api_client/batch.rb

@@ -0,0 +1,326 @@
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License 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.
+
+require 'addressable/uri'
+require 'google/api_client/reference'
+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
+      # @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
+
+      # @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.
+      # @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.
+      #
+      # @yield [Google::APIClient::Result]
+      #   block to be called when result ready
+      def initialize(options = {}, &block)
+        @calls = []
+        @global_callback = nil
+        @global_callback = block if block_given?
+        @last_auto_id = 0
+
+        @base_id = SecureRandom.uuid
+
+        options[:uri] ||= 'https://www.googleapis.com/batch'
+        options[:http_method] ||= 'POST'
+
+        super options
+      end
+
+      ##
+      # Add a new call to the batch request.
+      # Each call must have its own call ID; if not provided, one will
+      # automatically be generated, avoiding collisions. If duplicate call IDs
+      # are provided, an error will be thrown.
+      #
+      # @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
+      #
+      # @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)
+        end
+        call_id ||= new_id
+        if @calls.assoc(call_id)
+          raise BatchError,
+              'A call with this ID already exists: %s' % call_id
+        end
+        callback = block_given? ? block : @global_callback
+        @calls << [call_id, call, callback]
+        return self
+      end
+
+      ##
+      # Processes the HTTP response to the batch request, issuing callbacks.
+      #
+      # @api private
+      #
+      # @param [Faraday::Response] response
+      #   the HTTP response.
+      def process_http_response(response)
+        content_type = find_header('Content-Type', response.headers)
+        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.
+      #
+      # @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)}
+        build_multipart(parts, 'multipart/mixed', BATCH_BOUNDARY)
+        super
+      end
+
+
+      protected
+
+      ##
+      # Helper method to find a header from its name, regardless of case.
+      #
+      # @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.
+      def find_header(name, headers)
+        _, header = headers.detect do |h, v|
+          h.downcase == name.downcase
+        end
+        return header
+      end
+
+      ##
+      # Create a new call ID. Uses an auto-incrementing, conflict-avoiding ID.
+      #
+      # @api private
+      #
+      # @return [String]
+      #  the new, unique ID.
+      def new_id
+        @last_auto_id += 1
+        while @calls.assoc(@last_auto_id)
+          @last_auto_id += 1
+        end
+        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.
+      #
+      # @api private
+      #
+      # @param [String] header
+      #   Content-ID header 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('+')
+        return Addressable::URI.unencode(call_id)
+      end
+
+      ##
+      # Auxiliary method to split the headers from the body in an HTTP response.
+      #
+      # @api private
+      #
+      # @param [String] response
+      #   the response to parse.
+      #
+      # @return [Array<Hash>, String]
+      #   the headers and the body, separately.
+      def split_headers_and_body(response)
+        headers = {}
+        payload = response.lstrip
+        while payload
+          line, payload = payload.split("\n", 2)
+          line.sub!(/\s+\z/, '')
+          break if line.empty?
+          match = /\A([^:]+):\s*/.match(line)
+          if match
+            headers[match[1]] = match.post_match
+          else
+            raise BatchError, 'Invalid header line in response: %s' % line
+          end
+        end
+        return headers, payload
+      end
+
+      ##
+      # Convert a single batched response into a BatchedCallResponse object.
+      #
+      # @api private
+      #
+      # @param [String] call_response
+      #   the request to deserialize.
+      #
+      # @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)
+
+        headers, body = split_headers_and_body(payload)
+        content_id = find_header('Content-ID', outer_headers)
+        call_id = header_to_id(content_id)
+        return BatchedCallResponse.new(call_id, status.to_i, headers, body)
+      end
+
+      ##
+      # Serialize a single batched call for assembling the multipart message
+      #
+      # @api private
+      #
+      # @param [Google::APIClient::Request] call
+      #   the call to serialize.
+      #
+      # @return [Faraday::UploadIO]
+      #   the serialized request
+      def serialize_call(call_id, call)
+        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 body
+          # TODO - CompositeIO if body is a stream
+          request << "\r\n\r\n"
+          if body.respond_to?(:read)
+            request << body.read
+          else
+            request << body.to_s
+          end
+        end
+        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.
+      #
+      # @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
+      #   prepended to the value because Content-ID headers are supposed to be
+      #   universally unique.
+      def id_to_header(call_id)
+        return '<%s+%s>' % [@base_id, Addressable::URI.encode(call_id)]
+      end
+
+    end
+  end
+end