google-api-client 0.50.0 → 0.53.0

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

@@ -1,447 +0,0 @@
-# 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 '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]
-
-        begin
-          require 'opencensus'
-          OPENCENSUS_AVAILABLE = true
-        rescue LoadError
-          OPENCENSUS_AVAILABLE = false
-        end
-
-        # Request options
-        # @return [Google::Apis::RequestOptions]
-        attr_accessor :options
-
-        # HTTP request URL
-        # @return [String, Addressable::URI]
-        attr_accessor :url
-
-        # HTTP headers
-        # @return [Hash]
-        attr_accessor :header
-
-        # Request body
-        # @return [#read]
-        attr_accessor :body
-
-        # HTTP method
-        # @return [symbol]
-        attr_accessor :method
-
-        # HTTP Client
-        # @return [HTTPClient]
-        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 = Hash.new
-          self.body = body
-          self.query = {}
-          self.params = {}
-          @opencensus_span = nil
-        end
-
-        # Execute the command, retrying as necessary
-        #
-        # @param [HTTPClient] 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!
-          opencensus_begin_span
-          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, Signet::AuthorizationError, Signet::RemoteServerError, Signet::UnexpectedStatusError],
-                                  on_retry: proc { |*| refresh_authorization } do
-                execute_once(client).tap do |result|
-                  if block_given?
-                    yield result, nil
-                  end
-                end
-              end
-            end
-          rescue => e
-            if block_given?
-              yield nil, e
-            else
-              raise e
-            end
-          end
-        ensure
-          opencensus_end_span
-          @http_res = nil
-          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, add query params, serialize data, etc) before sending
-        #
-        # @private
-        # @return [void]
-        def prepare!
-          normalize_unicode = true
-          if options
-            header.update(options.header) if options.header
-            query.update(options.query) if options.query
-            normalize_unicode = options.normalize_unicode
-          end
-          self.url = url.expand(params, nil, normalize_unicode) if url.is_a?(Addressable::Template)
-          url.query_values = normalize_query_values(query).merge(url.query_values || {})
-
-          if allow_form_encoding?
-            @form_encoded = true
-            self.body = Addressable::URI.form_encode(url.query_values(Array))
-            self.header['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8'
-            self.url.query_values = {}
-          else
-            @form_encoded = false
-          end
-
-          self.body = '' unless self.body
-        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 [Hash] 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, header, body)
-          decode_response_body(header['Content-Type'].first, body)
-        end
-
-        # Check the response and raise error if needed
-        #
-        # @param [Fixnum] status
-        #   HTTP status code of response
-        # @param [Hash] header
-        #   HTTP response headers
-        # @param [String] body
-        #   HTTP response body
-        # @param [String] message
-        #   Error message text
-        # @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, header = nil, body = nil, message = nil)
-          # TODO: 304 Not Modified depends on context...
-          case status
-          when 200...300
-            nil
-          when 301, 302, 303, 307
-            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)
-          when 500...600
-            message ||= 'Server error'
-            raise Google::Apis::ServerError.new(message, status_code: status, header: header, body: body)
-          else
-            logger.warn(sprintf('Encountered unexpected status code %s', status))
-            message ||= 'Unknown error'
-            raise Google::Apis::TransmissionError.new(message, status_code: status, header: header, body: 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', safe_object_representation(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, '')) }
-          if err.is_a?(HTTPClient::BadResponseError)
-            begin
-              res = err.res
-              raise Google::Apis::TransmissionError.new(err) if res.nil?
-              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
-
-        # Execute the command once.
-        #
-        # @private
-        # @param [HTTPClient] client
-        #   HTTP client
-        # @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)
-          body.rewind if body.respond_to?(:rewind)
-          begin
-            logger.debug { sprintf('Sending HTTP %s %s', method, url) }
-            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 { safe_response_representation @http_res }
-            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) }
-            error(e, rethrow: true)
-          end
-        end
-
-        # Update the request with any specified options.
-        # @param [Hash] req_header
-        #  HTTP headers
-        # @return [void]
-        def apply_request_options(req_header)
-          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)
-        end
-
-        def allow_form_encoding?
-          [:post, :put].include?(method) && body.nil?
-        end
-
-        private
-
-        UNSAFE_CLASS_NAMES = [
-          "Google::Apis::CloudkmsV1::DecryptResponse"
-        ]
-
-        def safe_object_representation obj
-          name = obj.class.name
-          if UNSAFE_CLASS_NAMES.include? name
-            "#<#{name} (fields redacted)>"
-          else
-            PP.pp(obj, "")
-          end
-        end
-
-        def safe_response_representation http_res
-          if respond_to?(:response_class) && response_class.is_a?(Class) &&
-             UNSAFE_CLASS_NAMES.include?(response_class.name)
-            return "#<#{http_res.class.name} (fields redacted)>"
-          end
-          http_res.inspect
-        end
-
-        def opencensus_begin_span
-          return unless OPENCENSUS_AVAILABLE && options.use_opencensus
-          return if @opencensus_span
-          return unless OpenCensus::Trace.span_context
-
-          @opencensus_span = OpenCensus::Trace.start_span url.path.to_s
-          @opencensus_span.kind = OpenCensus::Trace::SpanBuilder::CLIENT
-          @opencensus_span.put_attribute "http.host", url.host.to_s
-          @opencensus_span.put_attribute "http.method", method.to_s.upcase
-          @opencensus_span.put_attribute "http.path", url.path.to_s
-          if body.respond_to? :bytesize
-            @opencensus_span.put_message_event \
-              OpenCensus::Trace::SpanBuilder::SENT, 1, body.bytesize
-          end
-
-          formatter = OpenCensus::Trace.config.http_formatter
-          if formatter.respond_to? :header_name
-            header[formatter.header_name] = formatter.serialize @opencensus_span.context.trace_context
-          end
-        rescue StandardError => e
-          # Log exceptions and continue, so opencensus failures don't cause
-          # the entire request to fail.
-          logger.debug { sprintf('Error opening OpenCensus span: %s', e) }
-        end
-
-        def opencensus_end_span
-          return unless OPENCENSUS_AVAILABLE
-          return unless @opencensus_span
-          return unless OpenCensus::Trace.span_context
-
-          if @http_res
-            if @http_res.body.respond_to? :bytesize
-              @opencensus_span.put_message_event \
-                OpenCensus::Trace::SpanBuilder::RECEIVED, 1, @http_res.body.bytesize
-            end
-            status = @http_res.status.to_i
-            if status > 0
-              @opencensus_span.set_status map_http_status status
-              @opencensus_span.put_attribute "http.status_code", status
-            end
-          end
-
-          OpenCensus::Trace.end_span @opencensus_span
-          @opencensus_span = nil
-        rescue StandardError => e
-          # Log exceptions and continue, so failures don't cause leaks by
-          # aborting cleanup.
-          logger.debug { sprintf('Error finishing OpenCensus span: %s', e) }
-        end
-
-        def form_encoded?
-          @form_encoded
-        end
-
-        def map_http_status http_status
-          case http_status
-          when 200..399 then 0 # OK
-          when 400 then 3 # INVALID_ARGUMENT
-          when 401 then 16 # UNAUTHENTICATED
-          when 403 then 7 # PERMISSION_DENIED
-          when 404 then 5 # NOT_FOUND
-          when 429 then 8 # RESOURCE_EXHAUSTED
-          when 501 then 12 # UNIMPLEMENTED
-          when 503 then 14 # UNAVAILABLE
-          when 504 then 4 # DEADLINE_EXCEEDED
-          else 2 # UNKNOWN
-          end
-        end
-
-        def normalize_query_values(input)
-          input.inject({}) do |h, (k, v)|
-            h[k] = normalize_query_value(v)
-            h
-          end
-        end
-
-        def normalize_query_value(v)
-          case v
-          when Array
-            v.map { |v2| normalize_query_value(v2) }
-          when nil
-            nil
-          else
-            v.to_s
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# 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 'representable/json'
-require 'representable/json/hash'
-require 'base64'
-require 'date'
-
-module Google
-  module Apis
-    module Core
-      # Support for serializing hashes + property value/nil/unset tracking
-      # To be included in representers as a feature.
-      # @private
-      module JsonRepresentationSupport
-        def self.included(base)
-          base.extend(JsonSupport)
-        end
-
-        # @private
-        module JsonSupport
-          # Returns a customized getter function for Representable. Allows
-          # indifferent hash/attribute access.
-          #
-          # @param [String] name Property name
-          # @return [Proc]
-          def getter_fn(name)
-            ivar_name = "@#{name}".to_sym
-            lambda do |_|
-              if respond_to?(:fetch)
-                fetch(name, instance_variable_get(ivar_name))
-              else
-                instance_variable_get(ivar_name)
-              end
-            end
-          end
-
-          # Returns a customized function for Representable that checks whether or not
-          # an attribute should be serialized. Allows proper patch semantics by distinguishing
-          # between nil & unset values
-          #
-          # @param [String] name Property name
-          # @return [Proc]
-          def if_fn(name)
-            ivar_name = "@#{name}".to_sym
-            lambda do |opts|
-              if opts[:user_options] && opts[:user_options][:skip_undefined]
-                if respond_to?(:key?)
-                  self.key?(name) || instance_variable_defined?(ivar_name)
-                else
-                  instance_variable_defined?(ivar_name)
-                end
-              else
-                true
-              end
-            end
-          end
-
-          def set_default_options(name, options)
-            if options[:base64]
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : Base64.urlsafe_encode64(value) }
-              options[:parse_filter] = ->(fragment, _doc, *_args) { Base64.urlsafe_decode64(fragment) }
-            end
-            if options[:numeric_string]
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.to_s}
-              options[:parse_filter] = ->(fragment, _doc, *_args) { fragment.to_i }
-            end
-            if options[:type] == DateTime
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.is_a?(DateTime) ? value.rfc3339(3) : value.to_s }
-              options[:parse_filter] = ->(fragment, _doc, *_args) { DateTime.parse(fragment) }
-            end
-            if options[:type] == Date
-              options[:render_filter] = ->(value, _doc, *_args) { value.nil? ? nil : value.to_s}
-              options[:parse_filter] = ->(fragment, _doc, *_args) { Date.parse(fragment) }
-            end
-
-            options[:render_nil] = true
-            options[:getter] = getter_fn(name)
-            options[:if] = if_fn(name)
-          end
-
-          # Define a single value property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def property(name, options = {})
-            set_default_options(name, options)
-            super(name, options)
-          end
-
-          # Define a collection property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def collection(name, options = {})
-            set_default_options(name, options)
-            super(name, options)
-          end
-
-          # Define a hash property
-          #
-          # @param [String] name
-          #  Property name
-          # @param [Hash] options
-          def hash(name = nil, options = nil)
-            return super() unless name # Allow Object.hash
-            set_default_options(name, options)
-            super(name, options)
-          end
-        end
-      end
-
-      # Base decorator for JSON representers
-      #
-      # @see https://github.com/apotonick/representable
-      class JsonRepresentation < Representable::Decorator
-        include Representable::JSON
-        feature JsonRepresentationSupport
-      end
-
-      module JsonObjectSupport
-        def self.included(base)
-          base.extend(ClassMethods)
-        end
-
-        module ClassMethods
-          def from_json(json)
-            representation = self.const_get(:Representation)
-            representation.new(self.new).from_json(json, unwrap: self)
-          end
-        end
-
-        def to_json(*a)
-          representation = self.class.const_get(:Representation)
-          representation.new(self).to_hash(user_options: { skip_undefined: true }).to_json(*a)
-        end
-      end
-    end
-  end
-end