google-apis-core 0.1.0

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

@@ -0,0 +1,153 @@
+# Copyright 2020 Google LLC
+#
+# 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

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

@@ -0,0 +1,30 @@
+# Copyright 2020 Google LLC
+#
+# 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'
+
+module Google
+  module Apis
+    module Core
+      # Logging support
+      module Logging
+        # Get the logger instance
+        # @return [Logger]
+        def logger
+          Google::Apis.logger
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# Copyright 2020 Google LLC
+#
+# 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
+      # Part of a multipart request for holding JSON data
+      #
+      # @private
+      class JsonPart
+
+        # @param [String] value
+        #   JSON content
+        # @param [Hash] header
+        #   Additional headers
+        def initialize(value, header = {})
+          @value = value
+          @header = header
+        end
+
+        def to_io(boundary)
+          part = ''
+          part << "--#{boundary}\r\n"
+          part << "Content-Type: application/json\r\n"
+          @header.each do |(k, v)|
+            part << "#{k}: #{v}\r\n"
+          end
+          part << "\r\n"
+          part << "#{@value}\r\n"
+          StringIO.new(part)
+        end
+
+      end
+
+      # Part of a multipart request for holding arbitrary content.
+      #
+      # @private
+      class FilePart
+        # @param [IO] io
+        #   IO stream
+        # @param [Hash] header
+        #   Additional headers
+        def initialize(io, header = {})
+          @io = io
+          @header = header
+          @length = io.respond_to?(:size) ? io.size : nil
+        end
+
+        def to_io(boundary)
+          head = ''
+          head << "--#{boundary}\r\n"
+          @header.each do |(k, v)|
+            head << "#{k}: #{v}\r\n"
+          end
+          head << "Content-Length: #{@length}\r\n" unless @length.nil?
+          head << "Content-Transfer-Encoding: binary\r\n"
+          head << "\r\n"
+          Google::Apis::Core::CompositeIO.new(StringIO.new(head), @io, StringIO.new("\r\n"))
+        end
+      end
+
+      # Helper for building multipart requests
+      class Multipart
+        MULTIPART_RELATED = 'multipart/related'
+
+        # @return [String]
+        #  Content type header
+        attr_reader :content_type
+
+        # @param [String] content_type
+        #  Content type for the multipart request
+        # @param [String] boundary
+        #  Part delimiter
+
+        def initialize(content_type: MULTIPART_RELATED, boundary: nil)
+          @parts = []
+          @boundary = boundary || Digest::SHA1.hexdigest(SecureRandom.random_bytes(8))
+          @content_type = "#{content_type}; boundary=#{@boundary}"
+        end
+
+        # Append JSON data part
+        #
+        # @param [String] body
+        #   JSON text
+        # @param [String] content_id
+        #   Optional unique ID of this part
+        # @return [self]
+        def add_json(body, content_id: nil)
+          header = {}
+          header['Content-ID'] = content_id unless content_id.nil?
+          @parts << Google::Apis::Core::JsonPart.new(body, header).to_io(@boundary)
+          self
+        end
+
+        # Append arbitrary data as a part
+        #
+        # @param [IO] upload_io
+        #   IO stream
+        # @param [String] content_id
+        #   Optional unique ID of this part
+        # @return [self]
+        def add_upload(upload_io, content_type: nil, content_id: nil)
+          header = {
+              'Content-Type' => content_type || 'application/octet-stream'
+          }
+          header['Content-Id'] = content_id unless content_id.nil?
+          @parts << Google::Apis::Core::FilePart.new(upload_io,
+                                                     header).to_io(@boundary)
+          self
+        end
+
+        # Assemble the multipart requests
+        #
+        # @return [IO]
+        #  IO stream
+        def assemble
+          @parts <<  StringIO.new("--#{@boundary}--\r\n\r\n")
+          Google::Apis::Core::CompositeIO.new(*@parts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+# Copyright 2020 Google LLC
+#
+# 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/http_command'
+require 'google/apis/core/api_command'
+require 'google/apis/errors'
+require 'addressable/uri'
+require 'tempfile'
+require 'mini_mime'
+
+module Google
+  module Apis
+    module Core
+      # Base upload command. Not intended to be used directly
+      # @private
+      class BaseUploadCommand < ApiCommand
+        UPLOAD_PROTOCOL_HEADER = 'X-Goog-Upload-Protocol'
+        UPLOAD_CONTENT_TYPE_HEADER = 'X-Goog-Upload-Header-Content-Type'
+        UPLOAD_CONTENT_LENGTH = 'X-Goog-Upload-Header-Content-Length'
+        CONTENT_TYPE_HEADER = 'Content-Type'
+
+        # File name or IO containing the content to upload
+        # @return [String, File, #read]
+        attr_accessor :upload_source
+
+        # Content type of the upload material
+        # @return [String]
+        attr_accessor :upload_content_type
+
+        # Content, as UploadIO
+        # @return [Google::Apis::Core::UploadIO]
+        attr_accessor :upload_io
+
+        # Ensure the content is readable and wrapped in an IO instance.
+        #
+        # @return [void]
+        # @raise [Google::Apis::ClientError] if upload source is invalid
+        def prepare!
+          super
+          if streamable?(upload_source)
+            self.upload_io = upload_source
+            @close_io_on_finish = false
+          elsif self.upload_source.is_a?(String)
+            self.upload_io = File.new(upload_source, 'r')
+            if self.upload_content_type.nil?
+              type = MiniMime.lookup_by_filename(upload_source)
+              self.upload_content_type = type && type.content_type
+            end
+            @close_io_on_finish = true
+          else
+            fail Google::Apis::ClientError, 'Invalid upload source'
+          end
+          if self.upload_content_type.nil? || self.upload_content_type.empty?
+            self.upload_content_type = 'application/octet-stream'
+          end
+        end
+
+        # Close IO stream when command done. Only closes the stream if it was opened by the command.
+        def release!
+          upload_io.close if @close_io_on_finish
+        end
+
+        private
+
+        def streamable?(upload_source)
+          upload_source.is_a?(IO) || upload_source.is_a?(StringIO) || upload_source.is_a?(Tempfile)
+        end
+      end
+
+      # Implementation of the raw upload protocol
+      class RawUploadCommand < BaseUploadCommand
+        RAW_PROTOCOL = 'raw'
+
+        # Ensure the content is readable and wrapped in an {{Google::Apis::Core::UploadIO}} instance.
+        #
+        # @return [void]
+        # @raise [Google::Apis::ClientError] if upload source is invalid
+        def prepare!
+          super
+          self.body = upload_io
+          header[UPLOAD_PROTOCOL_HEADER] = RAW_PROTOCOL
+          header[UPLOAD_CONTENT_TYPE_HEADER] = upload_content_type
+        end
+      end
+
+      # Implementation of the multipart upload protocol
+      class MultipartUploadCommand < BaseUploadCommand
+        MULTIPART_PROTOCOL = 'multipart'
+        MULTIPART_RELATED = 'multipart/related'
+
+        # Encode the multipart request
+        #
+        # @return [void]
+        # @raise [Google::Apis::ClientError] if upload source is invalid
+        def prepare!
+          super
+          multipart = Multipart.new
+          multipart.add_json(body)
+          multipart.add_upload(upload_io, content_type: upload_content_type)
+          self.body = multipart.assemble
+          header['Content-Type'] = multipart.content_type
+          header[UPLOAD_PROTOCOL_HEADER] = MULTIPART_PROTOCOL
+        end
+      end
+
+      # Implementation of the resumable upload protocol
+      class ResumableUploadCommand < BaseUploadCommand
+        UPLOAD_COMMAND_HEADER = 'X-Goog-Upload-Command'
+        UPLOAD_OFFSET_HEADER = 'X-Goog-Upload-Offset'
+        BYTES_RECEIVED_HEADER = 'X-Goog-Upload-Size-Received'
+        UPLOAD_URL_HEADER = 'X-Goog-Upload-URL'
+        UPLOAD_STATUS_HEADER = 'X-Goog-Upload-Status'
+        STATUS_ACTIVE = 'active'
+        STATUS_FINAL = 'final'
+        STATUS_CANCELLED = 'cancelled'
+        RESUMABLE = 'resumable'
+        START_COMMAND = 'start'
+        QUERY_COMMAND = 'query'
+        UPLOAD_COMMAND = 'upload, finalize'
+
+        # Reset upload to initial state.
+        #
+        # @return [void]
+        # @raise [Google::Apis::ClientError] if upload source is invalid
+        def prepare!
+          @state = :start
+          @upload_url = nil
+          @offset = 0
+          # Prevent the command from populating the body with form encoding, by
+          # asserting that it already has a body. Form encoding is never used
+          # by upload requests.
+          self.body = '' unless self.body
+          super
+        end
+
+        # Check the to see if the upload is complete or needs to be resumed.
+        #
+        # @param [Fixnum] status
+        #   HTTP status code of response
+        # @param [HTTP::Message::Headers] 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)
+          @offset = Integer(header[BYTES_RECEIVED_HEADER].first) unless header[BYTES_RECEIVED_HEADER].empty?
+          @upload_url = header[UPLOAD_URL_HEADER].first unless header[UPLOAD_URL_HEADER].empty?
+          upload_status = header[UPLOAD_STATUS_HEADER].first
+          logger.debug { sprintf('Upload status %s', upload_status) }
+          if upload_status == STATUS_ACTIVE
+            @state = :active
+          elsif upload_status == STATUS_FINAL
+            @state = :final
+          elsif upload_status == STATUS_CANCELLED
+            @state = :cancelled
+            fail Google::Apis::ClientError, body
+          end
+          super(status, header, body)
+        end
+
+        def send_start_command(client)
+          logger.debug { sprintf('Sending upload start command to %s', url) }
+
+          request_header = header.dup
+          apply_request_options(request_header)
+          request_header[UPLOAD_PROTOCOL_HEADER] = RESUMABLE
+          request_header[UPLOAD_COMMAND_HEADER] = START_COMMAND
+          request_header[UPLOAD_CONTENT_LENGTH] = upload_io.size.to_s
+          request_header[UPLOAD_CONTENT_TYPE_HEADER] = upload_content_type
+
+          client.request(method.to_s.upcase,
+                         url.to_s, query: nil,
+                         body: body,
+                         header: request_header,
+                         follow_redirect: true)
+        rescue => e
+          raise Google::Apis::ServerError, e.message
+        end
+
+        # Query for the status of an incomplete upload
+        #
+        # @param [HTTPClient] client
+        #   HTTP client
+        # @return [HTTP::Message]
+        # @raise [Google::Apis::ServerError] Unable to send the request
+        def send_query_command(client)
+          logger.debug { sprintf('Sending upload query command to %s', @upload_url) }
+
+          request_header = header.dup
+          apply_request_options(request_header)
+          request_header[UPLOAD_COMMAND_HEADER] = QUERY_COMMAND
+
+          client.post(@upload_url, body: '', header: request_header, follow_redirect: true)
+        end
+
+
+        # Send the actual content
+        #
+        # @param [HTTPClient] client
+        #   HTTP client
+        # @return [HTTP::Message]
+        # @raise [Google::Apis::ServerError] Unable to send the request
+        def send_upload_command(client)
+          logger.debug { sprintf('Sending upload command to %s', @upload_url) }
+
+          content = upload_io
+          content.pos = @offset
+
+          request_header = header.dup
+          apply_request_options(request_header)
+          request_header[UPLOAD_COMMAND_HEADER] = QUERY_COMMAND
+          request_header[UPLOAD_COMMAND_HEADER] = UPLOAD_COMMAND
+          request_header[UPLOAD_OFFSET_HEADER] = @offset.to_s
+          request_header[CONTENT_TYPE_HEADER] = upload_content_type
+
+          client.post(@upload_url, body: content, header: request_header, follow_redirect: true)
+        end
+
+        # Execute the upload request once. This will typically perform two HTTP requests -- one to initiate or query
+        # for the status of the upload, the second to send the (remaining) content.
+        #
+        # @private
+        # @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_once(client, &block)
+          case @state
+          when :start
+            response = send_start_command(client)
+            result = process_response(response.status_code, response.header, response.body)
+          when :active
+            response = send_query_command(client)
+            result = process_response(response.status_code, response.header, response.body)
+          when :cancelled, :final
+            error(@last_error, rethrow: true, &block)
+          end
+          if @state == :active
+            response = send_upload_command(client)
+            result = process_response(response.status_code, response.header, response.body)
+          end
+
+          success(result, &block) if @state == :final
+        rescue => e
+          # Some APIs like Youtube generate non-retriable 401 errors and mark
+          # the upload as finalized. Save the error just in case we get
+          # retried.
+          @last_error = e
+          error(e, rethrow: true, &block)
+        end
+      end
+    end
+  end
+end