jomz-google-api-client 0.7.1

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

@@ -0,0 +1,41 @@
+# Copyright 2010 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 'google/api_client/auth/key_utils'
+module Google
+  class APIClient
+    ##
+    # Helper for loading keys from the PKCS12 files downloaded when
+    # setting up service accounts at the APIs Console.
+    #
+    module PKCS12
+      ##
+      # Loads a key from PKCS12 file, assuming a single private key
+      # is present.
+      #
+      # @param [String] keyfile
+      #    Path of the PKCS12 file to load. If not a path to an actual file,
+      #    assumes the string is the content of the file itself. 
+      # @param [String] passphrase
+      #   Passphrase for unlocking the private key
+      #
+      # @return [OpenSSL::PKey] The private key for signing assertions.
+      # @deprecated 
+      #  Use {Google::APIClient::KeyUtils} instead
+      def self.load_key(keyfile, passphrase)
+        KeyUtils.load_from_pkcs12(keyfile, passphrase)
+      end
+    end
+  end
+end

data/lib/google/api_client/batch.rb

@@ -0,0 +1,323 @@
+# 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 'uuidtools'
+
+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 = 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
+
+        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)
+        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
+        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

data/lib/google/api_client/client_secrets.rb

@@ -0,0 +1,176 @@
+# Copyright 2010 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 'multi_json'
+require 'compat/multi_json'
+
+
+module Google
+  class APIClient
+    ##
+    # Manages the persistence of client configuration data and secrets. Format
+    # inspired by the Google API Python client.
+    #
+    # @see https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+    #
+    # @example
+    #   {
+    #     "web": {
+    #       "client_id": "asdfjasdljfasdkjf",
+    #       "client_secret": "1912308409123890",
+    #       "redirect_uris": ["https://www.example.com/oauth2callback"],
+    #       "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    #       "token_uri": "https://accounts.google.com/o/oauth2/token"
+    #     }
+    #   }
+    #
+    # @example
+    #   {
+    #     "installed": {
+    #       "client_id": "837647042410-75ifg...usercontent.com",
+    #       "client_secret":"asdlkfjaskd",
+    #       "redirect_uris": ["http://localhost", "urn:ietf:oauth:2.0:oob"],
+    #       "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    #       "token_uri": "https://accounts.google.com/o/oauth2/token"
+    #     }
+    #   }
+    class ClientSecrets
+      
+      ##
+      # Reads client configuration from a file
+      #
+      # @param [String] filename
+      #   Path to file to load
+      #
+      # @return [Google::APIClient::ClientSecrets]
+      #   OAuth client settings
+      def self.load(filename=nil)
+        if filename && File.directory?(filename)
+          search_path = File.expand_path(filename)
+          filename = nil
+        end
+        while filename == nil
+          search_path ||= File.expand_path('.')
+          if File.exist?(File.join(search_path, 'client_secrets.json'))
+            filename = File.join(search_path, 'client_secrets.json')
+          elsif search_path == '/' || search_path =~ /[a-zA-Z]:[\/\\]/
+            raise ArgumentError,
+              'No client_secrets.json filename supplied ' +
+              'and/or could not be found in search path.'
+          else
+            search_path = File.expand_path(File.join(search_path, '..'))
+          end
+        end
+        data = File.open(filename, 'r') { |file| MultiJson.load(file.read) }
+        return self.new(data)
+      end
+
+      ##
+      # Intialize OAuth client settings.
+      #
+      # @param [Hash] options
+      #   Parsed client secrets files
+      def initialize(options={})
+        # Client auth configuration
+        @flow = options[:flow] || options.keys.first.to_s || 'web'
+        fdata = options[@flow]
+        @client_id = fdata[:client_id] || fdata["client_id"]
+        @client_secret = fdata[:client_secret] || fdata["client_secret"]
+        @redirect_uris = fdata[:redirect_uris] || fdata["redirect_uris"]
+        @redirect_uris ||= [fdata[:redirect_uri]]
+        @javascript_origins = (
+          fdata[:javascript_origins] ||
+          fdata["javascript_origins"]
+        )
+        @javascript_origins ||= [fdata[:javascript_origin]]
+        @authorization_uri = fdata[:auth_uri] || fdata["auth_uri"]
+        @authorization_uri ||= fdata[:authorization_uri]
+        @token_credential_uri = fdata[:token_uri] || fdata["token_uri"]
+        @token_credential_uri ||= fdata[:token_credential_uri]
+
+        # Associated token info
+        @access_token = fdata[:access_token] || fdata["access_token"]
+        @refresh_token = fdata[:refresh_token] || fdata["refresh_token"]
+        @id_token = fdata[:id_token] || fdata["id_token"]
+        @expires_in = fdata[:expires_in] || fdata["expires_in"]
+        @expires_at = fdata[:expires_at] || fdata["expires_at"]
+        @issued_at = fdata[:issued_at] || fdata["issued_at"]
+      end
+
+      attr_reader(
+        :flow, :client_id, :client_secret, :redirect_uris, :javascript_origins,
+        :authorization_uri, :token_credential_uri, :access_token,
+        :refresh_token, :id_token, :expires_in, :expires_at, :issued_at
+      )
+
+      ##
+      # Serialize back to the original JSON form
+      #
+      # @return [String]
+      #   JSON
+      def to_json
+        return MultiJson.dump({
+          self.flow => ({
+            'client_id' => self.client_id,
+            'client_secret' => self.client_secret,
+            'redirect_uris' => self.redirect_uris,
+            'javascript_origins' => self.javascript_origins,
+            'auth_uri' => self.authorization_uri,
+            'token_uri' => self.token_credential_uri,
+            'access_token' => self.access_token,
+            'refresh_token' => self.refresh_token,
+            'id_token' => self.id_token,
+            'expires_in' => self.expires_in,
+            'expires_at' => self.expires_at,
+            'issued_at' => self.issued_at
+          }).inject({}) do |accu, (k, v)|
+            # Prunes empty values from JSON output.
+            unless v == nil || (v.respond_to?(:empty?) && v.empty?)
+              accu[k] = v
+            end
+            accu
+          end
+        })
+      end
+      
+      def to_authorization
+        gem 'signet', '>= 0.4.0'
+        require 'signet/oauth_2/client'
+        # NOTE: Do not rely on this default value, as it may change
+        new_authorization = Signet::OAuth2::Client.new
+        new_authorization.client_id = self.client_id
+        new_authorization.client_secret = self.client_secret
+        new_authorization.authorization_uri = (
+          self.authorization_uri ||
+          'https://accounts.google.com/o/oauth2/auth'
+        )
+        new_authorization.token_credential_uri = (
+          self.token_credential_uri ||
+          'https://accounts.google.com/o/oauth2/token'
+        )
+        new_authorization.redirect_uri = self.redirect_uris.first
+
+        # These are supported, but unlikely.
+        new_authorization.access_token = self.access_token
+        new_authorization.refresh_token = self.refresh_token
+        new_authorization.id_token = self.id_token
+        new_authorization.expires_in = self.expires_in
+        new_authorization.issued_at = self.issued_at if self.issued_at
+        new_authorization.expires_at = self.expires_at if self.expires_at
+        return new_authorization
+      end
+    end
+  end
+end