google-api-client 0.8.7 → 0.9.pre1

data/lib/google/apis/core/batch.rb

@@ -0,0 +1,222 @@
+# Copyright 2015 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.
+# Copyright 2015 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 'hurley'
+require 'google/apis/core/multipart'
+require 'google/apis/core/http_command'
+require 'google/apis/core/upload'
+require 'google/apis/core/download'
+require 'addressable/uri'
+
+module Google
+  module Apis
+    module Core
+      # Wrapper request for batching multiple calls in a single server request
+      class BatchCommand < HttpCommand
+        BATCH_BOUNDARY = 'RubyApiBatchRequest'.freeze
+        MULTIPART_MIXED = 'multipart/mixed'
+
+        # @param [symbol] method
+        #   HTTP method
+        # @param [String,Addressable::URI, Addressable::Template] url
+        #   HTTP URL or template
+        def initialize(method, url)
+          super(method, url)
+          @calls = []
+        end
+
+        ##
+        # Add a new call to the batch request.
+        #
+        # @param [Google::Apis::Core::HttpCommand] call API Request to add
+        # @yield [result, err] Result & error when response available
+        # @return [Google::Apis::Core::BatchCommand] self
+        def add(call, &block)
+          ensure_valid_command(call)
+          @calls << [call, block]
+          self
+        end
+
+        protected
+
+        ##
+        # Deconstruct the batch response and process the individual results
+        #
+        # @param [String] content_type
+        #  Content type of body
+        # @param [String, #read] body
+        #  Response body
+        # @return [Object]
+        #   Response object
+        def decode_response_body(content_type, body)
+          m = /.*boundary=(.+)/.match(content_type)
+          if m
+            parts = split_parts(body, m[1])
+            deserializer = CallDeserializer.new
+            parts.each_index do |index|
+              call, callback = @calls[index]
+              begin
+                result = call.process_response(*deserializer.to_http_response(parts[index])) unless call.nil?
+                success(result, &callback)
+              rescue => e
+                error(e, &callback)
+              end
+            end
+          end
+          nil
+        end
+
+        def split_parts(body, boundary)
+          parts = body.split(/\r?\n?--#{Regexp.escape(boundary)}/)
+          parts[1...-1]
+        end
+
+        # Encode the batch request
+        # @return [void]
+        # @raise [Google::Apis::BatchError] if batch is empty
+        def prepare!
+          fail BatchError, 'Cannot make an empty batch request' if @calls.empty?
+
+          serializer = CallSerializer.new
+          multipart = Multipart.new(boundary: BATCH_BOUNDARY, content_type: MULTIPART_MIXED)
+          @calls.each do |(call, _)|
+            io = serializer.to_upload_io(call)
+            multipart.add_upload(io)
+          end
+          self.body = multipart.assemble
+
+          header[:content_type] = multipart.content_type
+          header[:content_length] = "#{body.length}"
+          super
+        end
+
+        def ensure_valid_command(command)
+          if command.is_a?(Google::Apis::Core::BaseUploadCommand) || command.is_a?(Google::Apis::Core::DownloadCommand)
+            fail Google::Apis::ClientError, 'Can not include media requests in batch'
+          end
+          fail Google::Apis::ClientError, 'Invalid command object' unless command.is_a?(HttpCommand)
+        end
+      end
+
+      # Wrapper request for batching multiple uploads in a single server request
+      class BatchUploadCommand < BatchCommand
+        def ensure_valid_command(command)
+          fail Google::Apis::ClientError, 'Can only include upload commands in batch' \
+            unless command.is_a?(Google::Apis::Core::BaseUploadCommand)
+        end
+
+        def prepare!
+          header['X-Goog-Upload-Protocol'] = 'batch'
+          super
+        end
+      end
+
+      # Serializes a command for embedding in a multipart batch request
+      # @private
+      class CallSerializer
+        HTTP_CONTENT_TYPE = 'application/http'
+
+        ##
+        # Serialize a single batched call for assembling the multipart message
+        #
+        # @param [Google::Apis::Core::HttpCommand] call
+        #   the call to serialize.
+        # @return [Hurley::UploadIO]
+        #   the serialized request
+        def to_upload_io(call)
+          call.prepare!
+          parts = []
+          parts << build_head(call)
+          parts << build_body(call) unless call.body.nil?
+          length = parts.inject(0) { |a, e| a + e.length }
+          Hurley::UploadIO.new(Hurley::CompositeReadIO.new(length, *parts),
+                               HTTP_CONTENT_TYPE,
+                               'ruby-api-request')
+        end
+
+        protected
+
+        def build_head(call)
+          request_head = "#{call.method.to_s.upcase} #{Addressable::URI.parse(call.url).request_uri} HTTP/1.1"
+          call.header.each do |key, value|
+            request_head << sprintf("\r\n%s: %s", key, value)
+          end
+          request_head << sprintf("\r\nHost: %s", call.url.host)
+          request_head << "\r\n\r\n"
+          StringIO.new(request_head)
+        end
+
+        def build_body(call)
+          return nil if call.body.nil?
+          return call.body if call.body.respond_to?(:read)
+          StringIO.new(call.body)
+        end
+      end
+
+      # Deconstructs a raw HTTP response part
+      # @private
+      class CallDeserializer
+        # Convert a single batched response into a BatchedCallResponse object.
+        #
+        # @param [String] call_response
+        #   the response to parse.
+        # @return [Array<(Fixnum, Hurley::Header, String)>]
+        #   Status, header, and response body.
+        def to_http_response(call_response)
+          _, outer_body = split_header_and_body(call_response)
+          status_line, payload = outer_body.split(/\n/, 2)
+          _, status = status_line.split(' ', 3)
+
+          header, body = split_header_and_body(payload)
+          [status.to_i, header, body]
+        end
+
+        protected
+
+        # Auxiliary method to split the header from the body in an HTTP response.
+        #
+        # @param [String] response
+        #   the response to parse.
+        # @return [Array<(Hurley::Header, String)>]
+        #   the header and the body, separately.
+        def split_header_and_body(response)
+          header = Hurley::Header.new
+          payload = response.lstrip
+          while payload
+            line, payload = payload.split(/\n/, 2)
+            line.sub!(/\s+\z/, '')
+            break if line.empty?
+            match = /\A([^:]+):\s*/.match(line)
+            fail BatchError, sprintf('Invalid header line in response: %s', line) if match.nil?
+            header[match[1]] = match.post_match
+          end
+          [header, payload]
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/core/download.rb

@@ -0,0 +1,94 @@
+# Copyright 2015 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/apis/core/multipart'
+require 'google/apis/core/api_command'
+require 'google/apis/errors'
+require 'addressable/uri'
+
+module Google
+  module Apis
+    module Core
+      # Streaming/resumable media download support
+      class DownloadCommand < ApiCommand
+        RANGE_HEADER = 'range'
+
+        # File or IO to write content to
+        # @return [String, File, #write]
+        attr_accessor :download_dest
+
+        # Ensure the download destination is a writable stream.
+        #
+        # @return [void]
+        def prepare!
+          @state = :start
+          @download_url = nil
+          @offset = 0
+          if download_dest.respond_to?(:write)
+            @download_io = download_dest
+            @close_io_on_finish = false
+          elsif download_dest.is_a?(String)
+            @download_io = File.open(download_dest, 'wb')
+            @close_io_on_finish = true
+          else
+            @download_io = StringIO.new('', 'wb')
+            @close_io_on_finish = false
+          end
+          super
+        end
+
+        # Close IO stream when command done. Only closes the stream if it was opened by the command.
+        def release!
+          @download_io.close if @close_io_on_finish
+        end
+
+        # Execute the upload request once. Overrides the default implementation to handle streaming/chunking
+        # of file content.
+        #
+        # @private
+        # @param [Hurley::Client] client
+        #   HTTP client
+        # @yield [result, err] Result or error if block supplied
+        # @return [Object]
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_once(client, &block)
+          client.get(@download_url || url) do |req|
+            apply_request_options(req)
+            if @offset > 0
+              logger.debug { sprintf('Resuming download from offset %d', @offset) }
+              req.header[RANGE_HEADER] = sprintf('bytes=%d-', @offset)
+            end
+            req.on_body do |res, chunk|
+              check_status(res.status_code, chunk) unless res.status_code.nil?
+              logger.debug { sprintf('Writing chunk (%d bytes)', chunk.length) }
+              @offset += chunk.length
+              @download_io.write(chunk)
+              @download_io.flush
+            end
+          end
+          if @close_io_on_finish
+            result = nil
+          else
+            result = @download_io
+          end
+          success(result, &block)
+        rescue => e
+          error(e, rethrow: true, &block)
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/core/hashable.rb

@@ -0,0 +1,44 @@
+# Copyright 2015 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
+  module Apis
+    module Core
+      # Adds to_hash to objects
+      module Hashable
+        # Convert object to hash representation
+        #
+        # @return [Hash]
+        def to_h
+          Hash[instance_variables.map { |k| [k[1..-1].to_sym, Hashable.process_value(instance_variable_get(k))] }]
+        end
+
+        # Recursively serialize an object
+        #
+        # @param [Object] val
+        # @return [Hash]
+        def self.process_value(val)
+          case val
+          when Hash
+            Hash[val.map {|k, v| [k.to_sym, Hashable.process_value(v)] }]
+          when Array
+            val.map{ |v| Hashable.process_value(v) }
+          else
+            val.respond_to?(:to_h) ? val.to_h : val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/core/http_command.rb

@@ -0,0 +1,275 @@
+# Copyright 2015 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 'addressable/template'
+require 'google/apis/options'
+require 'google/apis/errors'
+require 'retriable'
+require 'hurley'
+require 'hurley/addressable'
+require 'google/apis/core/logging'
+require 'pp'
+
+module Google
+  module Apis
+    module Core
+      # Command for HTTP request/response.
+      class HttpCommand
+        include Logging
+
+        RETRIABLE_ERRORS = [Google::Apis::ServerError, Google::Apis::RateLimitError, Google::Apis::TransmissionError]
+
+        # Request options
+        # @return [Google::Apis::RequestOptions]
+        attr_accessor :options
+
+        # HTTP request URL
+        # @return [String, Addressable::URI]
+        attr_accessor :url
+
+        # HTTP headers
+        # @return [Hurley::Header]
+        attr_accessor :header
+
+        # Request body
+        # @return [#read]
+        attr_accessor :body
+
+        # HTTP method
+        # @return [symbol]
+        attr_accessor :method
+
+        # HTTP Client
+        # @return [Hurley::Client]
+        attr_accessor :connection
+
+        # Query params
+        # @return [Hash]
+        attr_accessor :query
+
+        # Path params for URL Template
+        # @return [Hash]
+        attr_accessor :params
+
+        # @param [symbol] method
+        #   HTTP method
+        # @param [String,Addressable::URI, Addressable::Template] url
+        #   HTTP URL or template
+        # @param [String, #read] body
+        #   Request body
+        def initialize(method, url, body: nil)
+          self.options = Google::Apis::RequestOptions.default.dup
+          self.url = url
+          self.url = Addressable::Template.new(url) if url.is_a?(String)
+          self.method = method
+          self.header = Hurley::Header.new
+          self.body = body
+          self.query = {}
+          self.params = {}
+        end
+
+        # Execute the command, retrying as necessary
+        #
+        # @param [Hurley::Client] client
+        #   HTTP client
+        # @yield [result, err] Result or error if block supplied
+        # @return [Object]
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute(client)
+          prepare!
+          proc = block_given? ? Proc.new : nil
+          begin
+            Retriable.retriable tries: options.retries + 1,
+                                base_interval: 1,
+                                multiplier: 2,
+                                on: RETRIABLE_ERRORS do |try|
+              # This 2nd level retriable only catches auth errors, and supports 1 retry, which allows
+              # auth to be re-attempted without having to retry all sorts of other failures like
+              # NotFound, etc
+              auth_tries = (try == 1 && authorization_refreshable? ? 2 : 1)
+              Retriable.retriable tries: auth_tries,
+                                  on: [Google::Apis::AuthorizationError],
+                                  on_retry: proc { |*| refresh_authorization } do
+                return execute_once(client, &proc)
+              end
+            end
+          rescue => e
+            raise e if proc.nil?
+          end
+        ensure
+          release!
+        end
+
+        # Refresh the authorization authorization after a 401 error
+        #
+        # @private
+        # @return [void]
+        def refresh_authorization
+          # Handled implicitly by auth lib, here in case need to override
+          logger.debug('Retrying after authentication failure')
+        end
+
+        # Check if attached credentials can be automatically refreshed
+        # @return [Boolean]
+        def authorization_refreshable?
+          options.authorization.respond_to?(:apply!)
+        end
+
+        # Prepare the request (e.g. calculate headers, serialize data, etc) before sending
+        #
+        # @private
+        # @return [void]
+        def prepare!
+          header.update(options.header) if options && options.header
+          self.url = url.expand(params) if url.is_a?(Addressable::Template)
+          url.query_values = query
+        end
+
+        # Release any resources used by this command
+        # @private
+        # @return [void]
+        def release!
+        end
+
+        # Check the response and either decode body or raise error
+        #
+        # @param [Fixnum] status
+        #   HTTP status code of response
+        # @param [Hurley::Header] header
+        #   Response headers
+        # @param [String, #read] body
+        #  Response body
+        # @return [Object]
+        #   Response object
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def process_response(status, header, body)
+          check_status(status, body)
+          decode_response_body(header[:content_type], body)
+        end
+
+        # Check the response and raise error if needed
+        #
+        # @param [Fixnum] status
+        #   HTTP status code of response
+        # @param [String] body
+        #   HTTP response body
+        # @return [void]
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def check_status(status, body = nil)
+          # TODO: 304 Not Modified depends on context...
+          case status
+          when 200...300
+            nil
+          when 301, 302, 303, 307
+            fail Google::Apis::RedirectError, header[:location]
+          when 401
+            fail Google::Apis::AuthorizationError, body
+          when 304, 400, 402...500
+            fail Google::Apis::ClientError, body
+          when 500...600
+            fail Google::Apis::ServerError, body
+          else
+            logger.warn(sprintf('Encountered unexpected status code %s', status))
+            fail Google::Apis::TransmissionError, body
+          end
+        end
+
+        # Process the actual response body. Intended to be overridden by subclasses
+        #
+        # @param [String] _content_type
+        #  Content type of body
+        # @param [String, #read] body
+        #  Response body
+        # @return [Object]
+        def decode_response_body(_content_type, body)
+          body
+        end
+
+        # Process a success response
+        # @param [Object] result
+        #  Result object
+        # @return [Object] result if no block given
+        # @yield [result, nil] if block given
+        def success(result, &block)
+          logger.debug { sprintf('Success - %s', PP.pp(result, '')) }
+          block.call(result, nil) if block_given?
+          result
+        end
+
+        # Process an error response
+        # @param [StandardError] err
+        #  Error object
+        # @param [Boolean] rethrow
+        #  True if error should be raised again after handling
+        # @return [void]
+        # @yield [nil, err] if block given
+        # @raise [StandardError] if no block
+        def error(err, rethrow: false, &block)
+          logger.debug { sprintf('Error - %s', PP.pp(err, '')) }
+          err = Google::Apis::TransmissionError.new(err) if err.is_a?(Hurley::ClientError)
+          block.call(nil, err) if block_given?
+          fail err if rethrow || block.nil?
+        end
+
+        # Execute the command once.
+        #
+        # @private
+        # @param [Hurley::Client] client
+        #   HTTP client
+        # @yield [result, err] Result or error if block supplied
+        # @return [Object]
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def execute_once(client, &block)
+          body.rewind if body.respond_to?(:rewind)
+          begin
+            logger.debug { sprintf('Sending HTTP %s %s', method, url) }
+            response = client.send(method, url, body) do |req|
+              apply_request_options(req)
+            end
+            logger.debug { response.status_code }
+            logger.debug { response.inspect }
+            response = process_response(response.status_code, response.header, response.body)
+            success(response, &block)
+          rescue => e
+            logger.debug { sprintf('Caught error %s', e) }
+            error(e, rethrow: true, &block)
+          end
+        end
+
+        # Update the request with any specified options.
+        # @param [Hurley::Request] req
+        #  HTTP request
+        # @return [void]
+        def apply_request_options(req)
+          if options.authorization.respond_to?(:apply!)
+            options.authorization.apply!(req.header)
+          elsif options.authorization.is_a?(String)
+            req.header[:authorization] = sprintf('Bearer %s', options.authorization)
+          end
+          req.header.update(header)
+          req.options.timeout = options.timeout_sec
+        end
+      end
+    end
+  end
+end