google-api-client 0.6.4 → 0.7.0

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

@@ -0,0 +1,28 @@
+# 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 'faraday'
+require 'signet/oauth_2/client'
+
+module Google
+  class APIClient
+    class ComputeServiceAccount < Signet::OAuth2::Client
+      def fetch_access_token(options={})
+        connection = options[:connection] || Faraday.default_connection
+        response = connection.get 'http://metadata/computeMetadata/v1beta1/instance/service-accounts/default/token'
+        Signet::OAuth2.parse_json_credentials(response.body)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# 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'
+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 FileStorage
+      # @return [String] Path to the credentials file.
+      attr_accessor :path
+
+      # @return [Signet::OAuth2::Client] Path to the credentials file.
+      attr_reader :authorization
+
+      ##
+      # Initializes the FileStorage object.
+      #
+      # @param [String] path
+      #    Path to the credentials file.
+      def initialize(path)
+        @path = path
+        self.load_credentials
+      end
+
+      ##
+      # Attempt to read in credentials from the specified file.
+      def load_credentials
+        if File.exist? self.path
+          File.open(self.path, 'r') do |file|
+            cached_credentials = JSON.load(file)
+            @authorization = Signet::OAuth2::Client.new(cached_credentials)
+            @authorization.issued_at = Time.at(cached_credentials['issued_at'])
+            if @authorization.expired?
+              @authorization.fetch_access_token!
+              self.write_credentials
+            end
+          end
+        end
+      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(authorization=nil)
+        @authorization = authorization unless authorization.nil?
+
+        unless @authorization.refresh_token.nil?
+          hash = {}
+          %w'access_token
+           authorization_uri
+           client_id
+           client_secret
+           expires_in
+           refresh_token
+           token_credential_uri'.each do |var|
+            hash[var] = @authorization.instance_variable_get("@#{var}")
+          end
+          hash['issued_at'] = @authorization.issued_at.to_i
+
+          File.open(self.path, 'w', 0600) do |file|
+            file.write(hash.to_json)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -77,9 +77,13 @@ module Google
       ##
       # Request authorization. Opens a browser and waits for response.
       #
+      # @param [Google::APIClient::FileStorage] storage
+      #  Optional object that responds to :write_credentials, used to serialize
+      #  the OAuth 2 credentials after completing the flow.
+      #
       # @return [Signet::OAuth2::Client]
       #  Authorization instance, nil if user cancelled.
-      def authorize
+      def authorize(storage=nil)
         auth = @authorization
     
         server = WEBrick::HTTPServer.new(
@@ -103,6 +107,9 @@ module Google
         Launchy.open(auth.authorization_uri.to_s)
         server.start
         if @authorization.access_token
+          if storage.respond_to?(:write_credentials)
+            storage.write_credentials(@authorization)
+          end
           return @authorization
         else
           return nil

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

@@ -34,17 +34,6 @@ module Google
     #   client.authorization.fetch_access_token!
     #   client.execute(...)
     #
-    # @example Deprecated version
-    #
-    #    client = Google::APIClient.new
-    #    key = Google::APIClient::PKCS12.load_key('client.p12', 'notasecret')
-    #    service_account = Google::APIClient::JWTAsserter.new(
-    #     '123456-abcdef@developer.gserviceaccount.com',
-    #     'https://www.googleapis.com/auth/prediction',
-    #     key)
-    #    client.authorization = service_account.authorize
-    #    client.execute(...)
-    #
     # @deprecated
     #  Service accounts are now supported directly in Signet
     # @see https://developers.google.com/accounts/docs/OAuth2ServiceAccount

data/lib/google/api_client/client_secrets.rb

@@ -146,7 +146,7 @@ module Google
       end
       
       def to_authorization
-        gem 'signet', '~> 0.4.0'
+        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

data/lib/google/api_client/discovery/method.rb

@@ -187,6 +187,7 @@ module Google
       # @return [Addressable::URI] The URI after expansion.
       def generate_uri(parameters={})
         parameters = self.normalize_parameters(parameters)
+        
         self.validate_parameters(parameters)
         template_variables = self.uri_template.variables
         upload_type = parameters.assoc('uploadType') || parameters.assoc('upload_type')

data/lib/google/api_client/errors.rb

@@ -19,6 +19,17 @@ module Google
     # An error which is raised when there is an unexpected response or other
     # transport error that prevents an operation from succeeding.
     class TransmissionError < StandardError
+      attr_reader :result
+      def initialize(message = nil, result = nil)
+        super(message)
+        @result = result
+      end
+    end
+
+    ##
+    # An exception that is raised if a redirect is required
+    #
+    class RedirectError < TransmissionError
     end
 
     ##

data/lib/google/api_client/gzip.rb

@@ -0,0 +1,28 @@
+require 'faraday'
+require 'zlib'
+ 
+module Google
+  class APIClient
+    class Gzip < Faraday::Response::Middleware
+      include Google::APIClient::Logging
+ 
+      def on_complete(env)
+        encoding = env[:response_headers]['content-encoding'].to_s.downcase
+        case encoding
+        when 'gzip'
+          logger.debug { "Decompressing gzip encoded response (#{env[:body].length} bytes)" }        
+          env[:body] = Zlib::GzipReader.new(StringIO.new(env[:body])).read
+          env[:response_headers].delete('content-encoding')
+          logger.debug { "Decompressed (#{env[:body].length} bytes)" }        
+        when 'deflate'
+          logger.debug{ "Decompressing deflate encoded response (#{env[:body].length} bytes)" }        
+          env[:body] = Zlib::Inflate.inflate(env[:body])
+          env[:response_headers].delete('content-encoding')
+          logger.debug { "Decompressed (#{env[:body].length} bytes)" }        
+        end
+      end
+    end
+  end
+end
+ 
+Faraday::Response.register_middleware :gzip => Google::APIClient::Gzip

data/lib/google/api_client/media.rb

@@ -21,7 +21,11 @@ module Google
     # @see Faraday::UploadIO
     # @example
     #   media = Google::APIClient::UploadIO.new('mymovie.m4v', 'video/mp4')
-    class UploadIO < Faraday::UploadIO      
+    class UploadIO < Faraday::UploadIO
+      
+      # @return [Fixnum] Size of chunks to upload. Default is nil, meaning upload the entire file in a single request
+      attr_accessor :chunk_size
+            
       ##
       # Get the length of the stream
       #
@@ -32,6 +36,77 @@ module Google
       end
     end
     
+    ##
+    # Wraps an input stream and limits data to a given range
+    #
+    # @example
+    #   chunk = Google::APIClient::RangedIO.new(io, 0, 1000)
+    class RangedIO 
+      ##
+      # Bind an input stream to a specific range.
+      #
+      # @param [IO] io
+      #   Source input stream
+      # @param [Fixnum] offset
+      #   Starting offset of the range
+      # @param [Fixnum] length
+      #   Length of range
+      def initialize(io, offset, length)
+        @io = io
+        @offset = offset
+        @length = length
+        self.rewind
+      end
+      
+      ##
+      # @see IO#read
+      def read(amount = nil, buf = nil)
+        buffer = buf || ''
+        if amount.nil?
+          size = @length - @pos
+          done = ''
+        elsif amount == 0
+          size = 0
+          done = ''
+        else 
+          size = [@length - @pos, amount].min
+          done = nil
+        end
+
+        if size > 0
+          result = @io.read(size)
+          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+          buffer << result if result
+          @pos = @pos + size
+        end
+
+        if buffer.length > 0
+          buffer
+        else
+          done
+        end
+      end
+
+      ##
+      # @see IO#rewind
+      def rewind
+        self.pos = 0
+      end
+
+      ##
+      # @see IO#pos
+      def pos
+        @pos
+      end
+
+      ##
+      # @see IO#pos=
+      def pos=(pos)
+        @pos = pos
+        @io.pos = @offset + pos
+      end
+    end
+    
     ##
     # Resumable uploader.
     #
@@ -124,11 +199,11 @@ module Google
             'Content-Range' => "bytes */#{media.length}" })
         else
           start_offset = @offset
-          self.media.io.pos = start_offset
-          chunk = self.media.io.read(chunk_size)
-          content_length = chunk.bytesize
+          remaining = self.media.length - start_offset
+          chunk_size = self.media.chunk_size || self.chunk_size || self.media.length
+          content_length = [remaining, chunk_size].min
+          chunk = RangedIO.new(self.media.io, start_offset, content_length)
           end_offset = start_offset + content_length - 1
-          
           self.headers.update({
             'Content-Length' => "#{content_length}",
             'Content-Type' => self.media.content_type, 

data/lib/google/api_client/request.rb

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 require 'faraday'
-require 'faraday/utils'
+require 'faraday/request/multipart'
 require 'multi_json'
 require 'compat/multi_json'
 require 'addressable/uri'
@@ -71,8 +71,10 @@ module Google
       # @option options [String, Symbol] :http_method
       #   HTTP method when requesting a URI
       def initialize(options={})
-        @parameters = Hash[options[:parameters] || {}]
+        @parameters = Faraday::Utils::ParamsHash.new
         @headers = Faraday::Utils::Headers.new
+
+        self.parameters.merge!(options[:parameters]) unless options[:parameters].nil?
         self.headers.merge!(options[:headers]) unless options[:headers].nil?
         self.api_method = options[:api_method]
         self.authenticated = options[:authenticated]
@@ -150,10 +152,13 @@ module Google
       #
       # @param [Faraday::Connection] connection
       #   the connection to transmit with
+      # @param [TrueValue,FalseValue] is_retry
+      #   True if request has been previous sent
       #
       # @return [Google::APIClient::Result]
       #   result of API request
-      def send(connection)
+      def send(connection, is_retry = false)
+        self.body.rewind if is_retry && self.body.respond_to?(:rewind)          
         env = self.to_env(connection)
         logger.debug  { "#{self.class} Sending API request #{env[:method]} #{env[:url].to_s} #{env[:request_headers]}" }
         http_response = connection.app.call(env)
@@ -163,8 +168,8 @@ module Google
 
         # Resumamble slightly different than other upload protocols in that it requires at least
         # 2 requests.
-        if self.upload_type == 'resumable'
-          upload =  result.resumable_upload
+        if result.status == 200 && self.upload_type == 'resumable'
+          upload = result.resumable_upload
           unless upload.complete?
             logger.debug { "#{self.class} Sending upload body" }
             result = upload.send(connection)
@@ -282,6 +287,7 @@ module Google
             raise ArgumentError, "Can not specify body & body object for simple uploads"
           end
           self.headers['Content-Type'] ||= self.media.content_type
+          self.headers['Content-Length'] ||= self.media.length.to_s
           self.body = self.media
         when "multipart"
           unless options[:body_object]
@@ -314,10 +320,10 @@ module Google
       # @param [String] boundary
       #   Boundary for separating each part of the message
       def build_multipart(parts, mime_type = 'multipart/related', boundary = MULTIPART_BOUNDARY)
-        env = {
-          :request_headers => {'Content-Type' => "#{mime_type};boundary=#{boundary}"},
-          :request => { :boundary => boundary }
-        }
+        env = Faraday::Env.new
+        env.request = Faraday::RequestOptions.new
+        env.request.boundary = boundary
+        env.request_headers = {'Content-Type' => "#{mime_type};boundary=#{boundary}"}
         multipart = Faraday::Request::Multipart.new
         self.body = multipart.create_multipart(env, parts.map {|part| [nil, part]})
         self.headers.update(env[:request_headers])

data/lib/google/api_client/service/batch.rb

@@ -0,0 +1,103 @@
+# 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 'google/api_client/service/result'
+require 'google/api_client/batch'
+
+module Google
+  class APIClient
+    class Service
+
+      ##
+      # Helper class to contain the result of an individual batched call.
+      #
+      class BatchedCallResult < Result
+        # @return [Fixnum] Index of the call
+        def call_index
+          return @base_result.response.call_id.to_i - 1
+        end
+      end
+
+      ##
+      #
+      #
+      class BatchRequest
+        ##
+        # Creates a new batch request.
+        # This class shouldn't be instantiated directly, but rather through
+        # Service.batch.
+        #
+        # @param [Array] calls
+        #   List of Google::APIClient::Service::Request to be made.
+        # @param [Proc] block
+        #   Callback for every call's response. Won't be called if a call
+        #   defined a callback of its own.
+        #
+        # @yield [Google::APIClient::Service::Result]
+        #   block to be called when result ready
+        def initialize(service, calls, &block)
+          @service = service
+          @base_batch = Google::APIClient::BatchRequest.new
+          @global_callback = block if block_given?
+
+          if calls && calls.length > 0
+            calls.each do |call|
+              add(call)
+            end
+          end
+        end
+
+        ##
+        # Add a new call to the batch request.
+        #
+        # @param [Google::APIClient::Service::Request] call
+        #   the call to be added.
+        # @param [Proc] block
+        #   callback for this call's response.
+        #
+        # @return [Google::APIClient::Service::BatchRequest]
+        #   the BatchRequest, for chaining
+        #
+        # @yield [Google::APIClient::Service::Result]
+        #   block to be called when result ready
+        def add(call, &block)
+          if !block_given? && @global_callback.nil?
+            raise BatchError, 'Request needs a block'
+          end
+          callback = block || @global_callback
+          base_call = {
+            :api_method => call.method,
+            :parameters => call.parameters
+          }
+          @base_batch.add(base_call) do |base_result|
+            result = Google::APIClient::Service::BatchedCallResult.new(
+                call, base_result)
+            callback.call(result)
+          end
+          return self
+        end
+
+        ##
+        # Executes the batch request.
+        def execute
+          @service.execute(self)
+        end
+
+        attr_reader :base_batch
+
+      end
+
+    end
+  end
+end

data/lib/google/api_client/service/request.rb

@@ -0,0 +1,144 @@
+# 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.
+
+module Google
+  class APIClient
+    class Service
+      ##
+      # Handles an API request.
+      # This contains a full definition of the request to be made (including
+      # method name, parameters, body and media). The remote API call can be
+      # invoked with execute().
+      class Request
+        ##
+        # Build a request.
+        # This class should not be directly instantiated in user code;
+        # instantiation is handled by the stub methods created on Service and
+        # Resource objects.
+        #
+        # @param [Google::APIClient::Service] service
+        #   The parent Service instance that will execute the request.
+        # @param [Google::APIClient::Method] method
+        #   The Method instance that describes the API method invoked by the
+        #   request.
+        # @param [Hash] parameters
+        #   A Hash of parameter names and values to be sent in the API call.
+        def initialize(service, method, parameters)
+          @service = service
+          @method = method
+          @parameters = parameters
+          @body = nil
+          @media = nil
+
+          metaclass = (class << self; self; end)
+
+          # If applicable, add "body", "body=" and resource-named methods for
+          # retrieving and setting the HTTP body for this request.
+          # Examples of setting the body for files.insert in the Drive API:
+          #   request.body = object
+          #   request.execute
+          #  OR
+          #   request.file = object
+          #   request.execute
+          #  OR
+          #   request.body(object).execute
+          #  OR
+          #   request.file(object).execute
+          # Examples of retrieving the body for files.insert in the Drive API:
+          #   object = request.body
+          #  OR
+          #   object = request.file
+          if method.request_schema
+            body_name = method.request_schema.data['id'].dup
+            body_name[0] = body_name[0].chr.downcase
+            body_name_equals = (body_name + '=').to_sym
+            body_name = body_name.to_sym
+
+            metaclass.send(:define_method, :body) do |*args|
+              if args.length == 1
+                @body = args.first
+                return self
+              elsif args.length == 0
+                return @body
+              else
+                raise ArgumentError,
+                  "wrong number of arguments (#{args.length}; expecting 0 or 1)"
+              end
+            end
+
+            metaclass.send(:define_method, :body=) do |body|
+              @body = body
+            end
+
+            metaclass.send(:alias_method, body_name, :body)
+            metaclass.send(:alias_method, body_name_equals, :body=)
+          end
+
+          # If applicable, add "media" and "media=" for retrieving and setting
+          # the media object for this request.
+          # Examples of setting the media object:
+          #   request.media = object
+          #   request.execute
+          #  OR
+          #   request.media(object).execute
+          # Example of retrieving the media object:
+          #   object = request.media
+          if method.media_upload
+            metaclass.send(:define_method, :media) do |*args|
+              if args.length == 1
+                @media = args.first
+                return self
+              elsif args.length == 0
+                return @media
+              else
+                raise ArgumentError,
+                  "wrong number of arguments (#{args.length}; expecting 0 or 1)"
+              end
+            end
+
+            metaclass.send(:define_method, :media=) do |media|
+              @media = media
+            end
+          end
+        end
+
+        ##
+        # Returns the parent service capable of executing this request.
+        #
+        # @return [Google::APIClient::Service] The parent service.
+        attr_reader :service
+
+        ##
+        # Returns the Method instance that describes the API method invoked by
+        # the request.
+        #
+        # @return [Google::APIClient::Method] The API method description.
+        attr_reader :method
+
+        ##
+        # Contains the Hash of parameter names and values to be sent as the
+        # parameters for the API call.
+        #
+        # @return [Hash] The request parameters.
+        attr_accessor :parameters
+
+        ##
+        # Executes the request.
+        def execute
+          @service.execute(self)
+        end
+      end
+    end
+  end
+end

data/lib/google/api_client/service/resource.rb

@@ -0,0 +1,40 @@
+# 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.
+
+module Google
+  class APIClient
+    class Service
+      ##
+      # Handles an API resource.
+      # Simple class that contains API methods and/or child resources.
+      class Resource
+        include Google::APIClient::Service::StubGenerator
+
+        ##
+        # Build a resource.
+        # This class should not be directly instantiated in user code; resources
+        # are instantiated by the stub generation mechanism on Service creation.
+        #
+        # @param [Google::APIClient::Service] service
+        #   The Service instance this resource belongs to.
+        # @param [Google::APIClient::API, Google::APIClient::Resource] root
+        #   The node corresponding to this resource.
+        def initialize(service, root)
+          @service = service
+          generate_call_stubs(service, root)
+        end
+      end
+    end
+  end
+end