google-api-client 0.10.3 → 0.11.0

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

@@ -54,8 +54,12 @@ module Google
         def prepare!
           query[FIELDS_PARAM] = normalize_fields_param(query[FIELDS_PARAM]) if query.key?(FIELDS_PARAM)
           if request_representation && request_object
-            header[:content_type] ||= JSON_CONTENT_TYPE
-            self.body = request_representation.new(request_object).to_json(user_options: { skip_undefined: true })
+            header['Content-Type'] ||= JSON_CONTENT_TYPE
+            if options && options.skip_serialization
+              self.body = request_object
+            else
+              self.body = request_representation.new(request_object).to_json(user_options: { skip_undefined: true })
+            end
           end
           super
         end
@@ -71,6 +75,7 @@ module Google
         # noinspection RubyUnusedLocalVariable
         def decode_response_body(content_type, body)
           return super unless response_representation
+          return super if options && options.skip_deserialization
           return super if content_type.nil?
           return nil unless content_type.start_with?(JSON_CONTENT_TYPE)
           instance = response_class.new
@@ -82,7 +87,7 @@ module Google
         #
         # @param [Fixnum] status
         #   HTTP status code of response
-        # @param [Hurley::Header] header
+        # @param [Hash] header
         #   HTTP response headers
         # @param [String] body
         #   HTTP response body

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

@@ -19,11 +19,9 @@ require 'google/apis/core/api_command'
 require 'google/apis/core/batch'
 require 'google/apis/core/upload'
 require 'google/apis/core/download'
-require 'google/apis/core/http_client_adapter'
 require 'google/apis/options'
 require 'googleauth'
-require 'hurley'
-require 'hurley/addressable'
+require 'httpclient'
 
 module Google
   module Apis
@@ -86,6 +84,8 @@ module Google
       # Base service for all APIs. Not to be used directly.
       #
       class BaseService
+        include Logging
+
         # Root URL (host/port) for the API
         # @return [Addressable::URI]
         attr_accessor :root_url
@@ -103,7 +103,7 @@ module Google
         attr_accessor :batch_path
 
         # HTTP client
-        # @return [Hurley::Client]
+        # @return [HTTPClient]
         attr_accessor :client
 
         # General settings
@@ -164,10 +164,10 @@ module Google
           batch_command.options = request_options.merge(options)
           apply_command_defaults(batch_command)
           begin
-            Thread.current[:google_api_batch] = batch_command
+            start_batch(batch_command)
             yield self
           ensure
-            Thread.current[:google_api_batch] = nil
+            end_batch
           end
           batch_command.execute(client)
         end
@@ -196,16 +196,16 @@ module Google
           batch_command.options = request_options.merge(options)
           apply_command_defaults(batch_command)
           begin
-            Thread.current[:google_api_batch] = batch_command
+            start_batch(batch_command)
             yield self
           ensure
-            Thread.current[:google_api_batch] = nil
+            end_batch
           end
           batch_command.execute(client)
         end
 
         # Get the current HTTP client
-        # @return [Hurley::Client]
+        # @return [HTTPClient]
         def client
           @client ||= new_client
         end
@@ -347,6 +347,7 @@ module Google
         def execute_or_queue_command(command, &callback)
           batch_command = current_batch
           if batch_command
+            fail "Can not combine services in a batch" if Thread.current[:google_api_batch_service] != self
             batch_command.add(command, &callback)
             nil
           else
@@ -374,20 +375,48 @@ module Google
           !current_batch.nil?
         end
 
+        # Start a new thread-local batch context
+        # @param [Google::Apis::Core::BatchCommand] cmd
+        def start_batch(cmd)
+          fail "Batch already in progress" if batch?
+          Thread.current[:google_api_batch] = cmd
+          Thread.current[:google_api_batch_service] = self
+        end
+
+        # Clear thread-local batch context
+        def end_batch
+          Thread.current[:google_api_batch] = nil
+          Thread.current[:google_api_batch_service] = nil
+        end
+
         # Create a new HTTP client
-        # @return [Hurley::Client]
+        # @return [HTTPClient]
         def new_client
-          client = Hurley::Client.new
-          client.connection = Google::Apis::Core::HttpClientAdapter.new unless client_options.use_net_http
-          client.request_options.timeout = request_options.timeout_sec
-          client.request_options.open_timeout = request_options.open_timeout_sec
-          client.request_options.proxy = client_options.proxy_url
-          client.request_options.query_class = Hurley::Query::Flat
-          client.ssl_options.ca_file = File.join(Google::Apis::ROOT, 'lib', 'cacerts.pem')
-          client.header[:user_agent] = user_agent
+          client = ::HTTPClient.new
+
+          client.transparent_gzip_decompression = true
+          client.proxy = client_options.proxy_url if client_options.proxy_url
+
+          if client_options.open_timeout_sec
+            client.connect_timeout = client_options.open_timeout_sec
+          end
+
+          if client_options.read_timeout_sec
+            client.receive_timeout = client_options.read_timeout_sec
+          end
+
+          if client_options.send_timeout_sec
+            client.send_timeout = client_options.send_timeout_sec
+          end
+
+          client.follow_redirect_count = 5
+          client.default_header = { 'User-Agent' => user_agent }
+
+          client.debug_dev = logger if client_options.log_http_requests
           client
         end
 
+
         # Build the user agent header
         # @return [String]
         def user_agent

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

@@ -25,19 +25,19 @@
 # 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 'google/apis/core/composite_io'
 require 'addressable/uri'
 require 'securerandom'
+
 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
@@ -81,7 +81,7 @@ module Google
             parts.each_index do |index|
               response = deserializer.to_http_response(parts[index])
               outer_header = response.shift
-              call_id = header_to_id(outer_header[:content_id]) || index
+              call_id = header_to_id(outer_header['Content-ID'].first) || index
               call, callback = @calls[call_id]
               begin
                 result = call.process_response(*response) unless call.nil?
@@ -106,17 +106,16 @@ module Google
           fail BatchError, 'Cannot make an empty batch request' if @calls.empty?
 
           serializer = CallSerializer.new
-          multipart = Multipart.new(boundary: BATCH_BOUNDARY, content_type: MULTIPART_MIXED)
+          multipart = Multipart.new(content_type: MULTIPART_MIXED)
           @calls.each_index do |index|
             call, _ = @calls[index]
             content_id = id_to_header(index)
-            io = serializer.to_upload_io(call)
-            multipart.add_upload(io, content_id: content_id)
+            io = serializer.to_part(call)
+            multipart.add_upload(io, content_type: 'application/http', content_id: content_id)
           end
           self.body = multipart.assemble
 
-          header[:content_type] = multipart.content_type
-          header[:content_length] = "#{body.length}"
+          header['Content-Type'] = multipart.content_type
           super
         end
 
@@ -155,24 +154,20 @@ module Google
       # 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]
+        # @return [IO]
         #   the serialized request
-        def to_upload_io(call)
+        def to_part(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')
+          Google::Apis::Core::CompositeIO.new(*parts)
         end
 
         protected
@@ -201,7 +196,7 @@ module Google
         #
         # @param [String] call_response
         #   the response to parse.
-        # @return [Array<(Fixnum, Hurley::Header, String)>]
+        # @return [Array<(Fixnum, Hash, String)>]
         #   Status, header, and response body.
         def to_http_response(call_response)
           outer_header, outer_body = split_header_and_body(call_response)
@@ -218,10 +213,10 @@ module Google
         #
         # @param [String] response
         #   the response to parse.
-        # @return [Array<(Hurley::Header, String)>]
+        # @return [Array<(HTTP::Message::Headers, String)>]
         #   the header and the body, separately.
         def split_header_and_body(response)
-          header = Hurley::Header.new
+          header = HTTP::Message::Headers.new
           payload = response.lstrip
           while payload
             line, payload = payload.split(/\n/, 2)

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

@@ -0,0 +1,97 @@
+# 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 'google/apis/core/http_command'
+require 'google/apis/core/upload'
+require 'google/apis/core/download'
+require 'addressable/uri'
+require 'securerandom'
+module Google
+  module Apis
+    module Core
+      class CompositeIO
+        def initialize(*ios)
+          @ios = ios.flatten
+          @pos = 0
+          @index = 0
+          @sizes = @ios.map(&:size)
+        end
+
+        def read(length = nil, buf = nil)
+          buf = buf ? buf.replace('') : ''
+
+          begin
+            io = @ios[@index]
+            break if io.nil?
+            result = io.read(length)
+            if result
+              buf << result
+              if length
+                length -= result.length
+                break if length == 0
+              end
+            end
+            @index += 1
+          end while @index < @ios.length
+          buf.length > 0 ? buf : nil
+        end
+
+        def size
+          @sizes.reduce(:+)
+        end
+
+        alias_method :length, :size
+
+        def pos
+          @pos
+        end
+
+        def pos=(pos)
+          fail ArgumentError, "Position can not be negative" if pos < 0
+          @pos = pos
+          new_index = nil
+          @ios.each_with_index do |io,idx|
+            size = io.size
+            if pos <= size
+              new_index ||= idx
+              io.pos = pos
+              pos = 0
+            else
+              io.pos = size
+              pos -= size
+            end
+          end
+          @index = new_index unless new_index.nil?
+        end
+
+        def rewind
+          self.pos = 0
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,6 @@
 # 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'
@@ -22,7 +21,7 @@ module Google
     module Core
       # Streaming/resumable media download support
       class DownloadCommand < ApiCommand
-        RANGE_HEADER = 'range'
+        RANGE_HEADER = 'Range'
         OK_STATUS = [200, 201, 206]
 
         # File or IO to write content to
@@ -58,7 +57,7 @@ module Google
         # of file content.
         #
         # @private
-        # @param [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
         # @yield [result, err] Result or error if block supplied
         # @return [Object]
@@ -66,40 +65,45 @@ module Google
         # @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)
-          response = client.get(@download_url || url) do |req|
-            apply_request_options(req)
-            check_if_rewind_needed = false
-            if @offset > 0
-              logger.debug { sprintf('Resuming download from offset %d', @offset) }
-              req.header[RANGE_HEADER] = sprintf('bytes=%d-', @offset)
-              check_if_rewind_needed = true
-            end
-            req.on_body(*OK_STATUS) do |res, chunk|
-              check_status(res.status_code, chunk) unless res.status_code.nil?
-              if check_if_rewind_needed && res.status_code != 206
+          request_header = header.dup
+          apply_request_options(request_header)
+
+          check_if_rewind_needed = false
+          if @offset > 0
+            logger.debug { sprintf('Resuming download from offset %d', @offset) }
+            request_header[RANGE_HEADER] = sprintf('bytes=%d-', @offset)
+            check_if_rewind_needed = true
+          end
+
+          http_res = client.get(url.to_s,
+                     query: query,
+                     header: request_header,
+                     follow_redirect: true) do |res, chunk|
+            status = res.http_header.status_code.to_i
+            if OK_STATUS.include?(status)
+              if check_if_rewind_needed && status != 206
                 # Oh no! Requested a chunk, but received the entire content
                 # Attempt to rewind the stream
                 @download_io.rewind
                 check_if_rewind_needed = false
               end
-
-              logger.debug { sprintf('Writing chunk (%d bytes)', chunk.length) }
-              @offset += chunk.length
+              # logger.debug { sprintf('Writing chunk (%d bytes, %d total)', chunk.length, bytes_read) }
               @download_io.write(chunk)
-              @download_io.flush
+              @offset += chunk.length
             end
           end
 
-          # Since the on_body block only runs on success, check status again just in case it failed
-          check_status(response.status_code, response.body) unless OK_STATUS.include?(response.status_code.to_i)
+          @download_io.flush
 
           if @close_io_on_finish
             result = nil
           else
             result = @download_io
           end
+          check_status(http_res.status.to_i, http_res.header, http_res.body)
           success(result, &block)
         rescue => e
+          @download_io.flush
           error(e, rethrow: true, &block)
         end
       end

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

@@ -17,9 +17,6 @@ require 'addressable/template'
 require 'google/apis/options'
 require 'google/apis/errors'
 require 'retriable'
-require 'hurley'
-require 'hurley/addressable'
-require 'hurley_patches'
 require 'google/apis/core/logging'
 require 'pp'
 
@@ -41,7 +38,7 @@ module Google
         attr_accessor :url
 
         # HTTP headers
-        # @return [Hurley::Header]
+        # @return [Hash]
         attr_accessor :header
 
         # Request body
@@ -53,7 +50,7 @@ module Google
         attr_accessor :method
 
         # HTTP Client
-        # @return [Hurley::Client]
+        # @return [HTTPClient]
         attr_accessor :connection
 
         # Query params
@@ -75,7 +72,7 @@ module Google
           self.url = url
           self.url = Addressable::Template.new(url) if url.is_a?(String)
           self.method = method
-          self.header = Hurley::Header.new
+          self.header = Hash.new
           self.body = body
           self.query = {}
           self.params = {}
@@ -83,7 +80,7 @@ module Google
 
         # Execute the command, retrying as necessary
         #
-        # @param [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
         # @yield [result, err] Result or error if block supplied
         # @return [Object]
@@ -142,8 +139,12 @@ module Google
         # @private
         # @return [void]
         def prepare!
-          header.update(options.header) if options && options.header
-          self.url = url.expand(params) if url.is_a?(Addressable::Template)
+          normalize_unicode = true
+          if options
+            header.update(options.header) if options.header
+            normalize_unicode = options.normalize_unicode
+          end
+          self.url = url.expand(params, nil, normalize_unicode) if url.is_a?(Addressable::Template)
           url.query_values = query.merge(url.query_values || {})
 
           if allow_form_encoding?
@@ -154,6 +155,9 @@ module Google
           else
             @form_encoded = false
           end
+
+          self.body = '' unless self.body
+
         end
 
         # Release any resources used by this command
@@ -166,7 +170,7 @@ module Google
         #
         # @param [Fixnum] status
         #   HTTP status code of response
-        # @param [Hurley::Header] header
+        # @param [Hash] header
         #   Response headers
         # @param [String, #read] body
         #  Response body
@@ -177,7 +181,7 @@ module Google
         # @raise [Google::Apis::AuthorizationError] Authorization is required
         def process_response(status, header, body)
           check_status(status, header, body)
-          decode_response_body(header[:content_type], body)
+          decode_response_body(header['Content-Type'].first, body)
         end
 
         # Check the response and raise error if needed
@@ -185,7 +189,7 @@ module Google
         # @param [Fixnum] status
         #   HTTP status code of response
         # @param
-        # @param [Hurley::Header] header
+        # @param [Hash] header
         #   HTTP response headers
         # @param [String] body
         #   HTTP response body
@@ -201,11 +205,14 @@ module Google
           when 200...300
             nil
           when 301, 302, 303, 307
-            message ||= sprintf('Redirect to %s', header[:location])
+            message ||= sprintf('Redirect to %s', header['Location'])
             raise Google::Apis::RedirectError.new(message, status_code: status, header: header, body: body)
           when 401
             message ||= 'Unauthorized'
             raise Google::Apis::AuthorizationError.new(message, status_code: status, header: header, body: body)
+          when 429
+            message ||= 'Rate limit exceeded'
+            raise Google::Apis::RateLimitError.new(message, status_code: status, header: header, body: body)
           when 304, 400, 402...500
             message ||= 'Invalid request'
             raise Google::Apis::ClientError.new(message, status_code: status, header: header, body: body)
@@ -251,7 +258,16 @@ module Google
         # @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) || err.is_a?(SocketError)
+          if err.is_a?(HTTPClient::BadResponseError)
+            begin
+              res = err.res
+              check_status(res.status.to_i, res.header, res.body)
+            rescue Google::Apis::Error => e
+              err = e
+            end
+          elsif err.is_a?(HTTPClient::TimeoutError) || err.is_a?(SocketError)
+            err = Google::Apis::TransmissionError.new(err)
+          end
           block.call(nil, err) if block_given?
           fail err if rethrow || block.nil?
         end
@@ -259,7 +275,7 @@ module Google
         # Execute the command once.
         #
         # @private
-        # @param [Hurley::Client] client
+        # @param [HTTPClient] client
         #   HTTP client
         # @return [Object]
         # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
@@ -269,21 +285,18 @@ module Google
           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|
-              # Temporary workaround for Hurley bug where the connection preference
-              # is ignored and it uses nested anyway
-              unless form_encoded?
-                req.url.query_class = Hurley::Query::Flat
-                query.each do | k, v|
-                 req.url.query[k] = normalize_query_value(v)
-                end
-              end
-              # End workaround
-              apply_request_options(req)
-            end
-            logger.debug { response.status_code }
-            logger.debug { response.inspect }
-            response = process_response(response.status_code, response.header, response.body)
+            request_header = header.dup
+            apply_request_options(request_header)
+
+            http_res = client.request(method.to_s.upcase,
+                                      url.to_s,
+                                      query: nil,
+                                      body: body,
+                                      header: request_header,
+                                      follow_redirect: true)
+            logger.debug { http_res.status }
+            logger.debug { http_res.inspect }
+            response = process_response(http_res.status.to_i, http_res.header, http_res.body)
             success(response)
           rescue => e
             logger.debug { sprintf('Caught error %s', e) }
@@ -292,18 +305,16 @@ module Google
         end
 
         # Update the request with any specified options.
-        # @param [Hurley::Request] req
-        #  HTTP request
+        # @param [Hash] header
+        #  HTTP headers
         # @return [void]
-        def apply_request_options(req)
+        def apply_request_options(req_header)
           if options.authorization.respond_to?(:apply!)
-            options.authorization.apply!(req.header)
+            options.authorization.apply!(req_header)
           elsif options.authorization.is_a?(String)
-            req.header[:authorization] = sprintf('Bearer %s', options.authorization)
+            req_header['Authorization'] = sprintf('Bearer %s', options.authorization)
           end
-          req.header.update(header)
-          req.options.timeout = options.timeout_sec
-          req.options.open_timeout = options.open_timeout_sec
+          req_header.update(header)
         end
 
         def allow_form_encoding?