arvados-google-api-client 0.8.7.2

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

@@ -0,0 +1,117 @@
+# Copyright 2010 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 'time'
+require 'multi_json'
+require 'compat/multi_json'
+require 'base64'
+require 'autoparse'
+require 'addressable/uri'
+require 'addressable/template'
+
+require 'active_support/inflector'
+require 'google/api_client/errors'
+
+
+module Google
+  class APIClient
+    ##
+    # @api private
+    module Schema
+      def self.parse(api, schema_data)
+        # This method is super-long, but hard to break up due to the
+        # unavoidable dependence on closures and execution context.
+        schema_name = schema_data['id']
+
+        # Due to an oversight, schema IDs may not be URI references.
+        # TODO(bobaman): Remove this code once this has been resolved.
+        schema_uri = (
+          api.document_base +
+          (schema_name[0..0] != '#' ? '#' + schema_name : schema_name)
+        )
+
+        # Due to an oversight, schema IDs may not be URI references.
+        # TODO(bobaman): Remove this whole lambda once this has been resolved.
+        reformat_references = lambda do |data|
+          # This code is not particularly efficient due to recursive traversal
+          # and excess object creation, but this hopefully shouldn't be an
+          # issue since it should only be called only once per schema per
+          # process.
+          if data.kind_of?(Hash) &&
+              data['$ref'] && !data['$ref'].kind_of?(Hash)
+            if data['$ref'].respond_to?(:to_str)
+              reference = data['$ref'].to_str
+            else
+              raise TypeError, "Expected String, got #{data['$ref'].class}"
+            end
+            reference = '#' + reference if reference[0..0] != '#'
+            data.merge({
+              '$ref' => reference
+            })
+          elsif data.kind_of?(Hash)
+            data.inject({}) do |accu, (key, value)|
+              if value.kind_of?(Hash)
+                accu[key] = reformat_references.call(value)
+              else
+                accu[key] = value
+              end
+              accu
+            end
+          else
+            data
+          end
+        end
+        schema_data = reformat_references.call(schema_data)
+
+        if schema_name
+          api_name_string = ActiveSupport::Inflector.camelize(api.name)
+          api_version_string = ActiveSupport::Inflector.camelize(api.version).gsub('.', '_')
+          # This is for compatibility with Ruby 1.8.7.
+          # TODO(bobaman) Remove this when we eventually stop supporting 1.8.7.
+          args = []
+          args << false if Class.method(:const_defined?).arity != 1
+          if Google::APIClient::Schema.const_defined?(api_name_string, *args)
+            api_name = Google::APIClient::Schema.const_get(
+              api_name_string, *args
+            )
+          else
+            api_name = Google::APIClient::Schema.const_set(
+              api_name_string, Module.new
+            )
+          end
+          if api_name.const_defined?(api_version_string, *args)
+            api_version = api_name.const_get(api_version_string, *args)
+          else
+            api_version = api_name.const_set(api_version_string, Module.new)
+          end
+          if api_version.const_defined?(schema_name, *args)
+            schema_class = api_version.const_get(schema_name, *args)
+          end
+        end
+
+        # It's possible the schema has already been defined. If so, don't
+        # redefine it. This means that reloading a schema which has already
+        # been loaded into memory is not possible.
+        unless schema_class
+          schema_class = AutoParse.generate(schema_data, :uri => schema_uri)
+          if schema_name
+            api_version.const_set(schema_name, schema_class)
+          end
+        end
+        return schema_class
+      end
+    end
+  end
+end

data/lib/google/api_client/environment.rb

@@ -0,0 +1,42 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  class APIClient
+    module ENV
+      OS_VERSION = begin
+        if RUBY_PLATFORM =~ /mswin|win32|mingw|bccwin|cygwin/
+          # TODO(bobaman)
+          # Confirm that all of these Windows environments actually have access
+          # to the `ver` command.
+          `ver`.sub(/\s*\[Version\s*/, '/').sub(']', '').strip
+        elsif RUBY_PLATFORM =~ /darwin/i
+          "Mac OS X/#{`sw_vers -productVersion`}"
+        elsif RUBY_PLATFORM == 'java'
+          # Get the information from java system properties to avoid spawning a
+          # sub-process, which is not friendly in some contexts (web servers).
+          require 'java'
+          name = java.lang.System.getProperty('os.name')
+          version = java.lang.System.getProperty('os.version')
+          "#{name}/#{version}"
+        else
+          `uname -sr`.sub(' ', '/')
+        end
+      rescue Exception
+        RUBY_PLATFORM
+      end
+    end
+  end
+end

data/lib/google/api_client/errors.rb

@@ -0,0 +1,65 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  class APIClient
+    ##
+    # An error which is raised when there is an unexpected response or other
+    # transport error that prevents an operation from succeeding.
+    class TransmissionError < StandardError
+      attr_reader :result
+      def initialize(message = nil, result = nil)
+        super(message)
+        @result = result
+      end
+    end
+
+    ##
+    # An exception that is raised if a redirect is required
+    #
+    class RedirectError < TransmissionError
+    end
+
+    ##
+    # An exception that is raised if a method is called with missing or
+    # invalid parameter values.
+    class ValidationError < StandardError
+    end
+
+    ##
+    # A 4xx class HTTP error occurred.
+    class ClientError < TransmissionError
+    end
+
+    ##
+    # A 401 HTTP error occurred.
+    class AuthorizationError < ClientError
+    end
+
+    ##
+    # A 5xx class HTTP error occurred.
+    class ServerError < TransmissionError
+    end
+
+    ##
+    # An exception that is raised if an ID token could not be validated.
+    class InvalidIDTokenError < StandardError
+    end
+
+    # Error class for problems in batch requests.
+    class BatchError < StandardError
+    end
+  end
+end

data/lib/google/api_client/gzip.rb

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

data/lib/google/api_client/logging.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module Google
+  class APIClient
+    
+    class << self
+      ##
+      # Logger for the API client
+      #
+      # @return [Logger] logger instance.
+      attr_accessor :logger
+    end
+
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::WARN  
+
+    ##
+    # Module to make accessing the logger simpler
+    module Logging
+      ##
+      # Logger for the API client
+      #
+      # @return [Logger] logger instance.
+      def logger
+        Google::APIClient.logger
+      end
+    end
+
+  end
+  
+  
+end

data/lib/google/api_client/media.rb

@@ -0,0 +1,259 @@
+# Copyright 2010 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require 'google/api_client/reference'
+
+module Google
+  class APIClient
+    ##
+    # Uploadable media support.  Holds an IO stream & content type.
+    #
+    # @see Faraday::UploadIO
+    # @example
+    #   media = Google::APIClient::UploadIO.new('mymovie.m4v', 'video/mp4')
+    class UploadIO < Faraday::UploadIO
+      
+      # @return [Fixnum] Size of chunks to upload. Default is nil, meaning upload the entire file in a single request
+      attr_accessor :chunk_size
+            
+      ##
+      # Get the length of the stream
+      #
+      # @return [Fixnum]
+      #   Length of stream, in bytes
+      def length
+        io.respond_to?(:length) ? io.length : File.size(local_path)
+      end
+    end
+    
+    ##
+    # Wraps an input stream and limits data to a given range
+    #
+    # @example
+    #   chunk = Google::APIClient::RangedIO.new(io, 0, 1000)
+    class RangedIO 
+      ##
+      # Bind an input stream to a specific range.
+      #
+      # @param [IO] io
+      #   Source input stream
+      # @param [Fixnum] offset
+      #   Starting offset of the range
+      # @param [Fixnum] length
+      #   Length of range
+      def initialize(io, offset, length)
+        @io = io
+        @offset = offset
+        @length = length
+        self.rewind
+      end
+      
+      ##
+      # @see IO#read
+      def read(amount = nil, buf = nil)
+        buffer = buf || ''
+        if amount.nil?
+          size = @length - @pos
+          done = ''
+        elsif amount == 0
+          size = 0
+          done = ''
+        else 
+          size = [@length - @pos, amount].min
+          done = nil
+        end
+
+        if size > 0
+          result = @io.read(size)
+          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+          buffer << result if result
+          @pos = @pos + size
+        end
+
+        if buffer.length > 0
+          buffer
+        else
+          done
+        end
+      end
+
+      ##
+      # @see IO#rewind
+      def rewind
+        self.pos = 0
+      end
+
+      ##
+      # @see IO#pos
+      def pos
+        @pos
+      end
+
+      ##
+      # @see IO#pos=
+      def pos=(pos)
+        @pos = pos
+        @io.pos = @offset + pos
+      end
+    end
+    
+    ##
+    # Resumable uploader.
+    #
+    class ResumableUpload < Request
+      # @return [Fixnum] Max bytes to send in a single request
+      attr_accessor :chunk_size
+  
+      ##
+      # Creates a new uploader.
+      #
+      # @param [Hash] options
+      #   Request options
+      def initialize(options={})
+        super options
+        self.uri = options[:uri]
+        self.http_method = :put
+        @offset = options[:offset] || 0
+        @complete = false
+        @expired = false
+      end
+      
+      ##
+      # Sends all remaining chunks to the server
+      #
+      # @deprecated Pass the instance to {Google::APIClient#execute} instead
+      #
+      # @param [Google::APIClient] api_client
+      #   API Client instance to use for sending
+      def send_all(api_client)
+        result = nil
+        until complete?
+          result = send_chunk(api_client)
+          break unless result.status == 308
+        end
+        return result
+      end
+      
+      
+      ##
+      # Sends the next chunk to the server
+      #
+      # @deprecated Pass the instance to {Google::APIClient#execute} instead
+      #
+      # @param [Google::APIClient] api_client
+      #   API Client instance to use for sending
+      def send_chunk(api_client)
+        return api_client.execute(self)
+      end
+
+      ##
+      # Check if upload is complete
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not the upload complete successfully
+      def complete?
+        return @complete
+      end
+
+      ##
+      # Check if the upload URL expired (upload not completed in alotted time.)
+      # Expired uploads must be restarted from the beginning
+      #
+      # @return [TrueClass, FalseClass]
+      #   Whether or not the upload has expired and can not be resumed
+      def expired?
+        return @expired
+      end
+      
+      ##
+      # Check if upload is resumable. That is, neither complete nor expired
+      #
+      # @return [TrueClass, FalseClass] True if upload can be resumed
+      def resumable?
+        return !(self.complete? or self.expired?)
+      end
+      
+      ##
+      # Convert to an HTTP request. Returns components in order of method, URI,
+      # request headers, and body
+      #
+      # @api private
+      #
+      # @return [Array<(Symbol, Addressable::URI, Hash, [#read,#to_str])>]
+      def to_http_request
+        if @complete
+          raise Google::APIClient::ClientError, "Upload already complete"
+        elsif @offset.nil?
+          self.headers.update({ 
+            'Content-Length' => "0", 
+            'Content-Range' => "bytes */#{media.length}" })
+        else
+          start_offset = @offset
+          remaining = self.media.length - start_offset
+          chunk_size = self.media.chunk_size || self.chunk_size || self.media.length
+          content_length = [remaining, chunk_size].min
+          chunk = RangedIO.new(self.media.io, start_offset, content_length)
+          end_offset = start_offset + content_length - 1
+          self.headers.update({
+            'Content-Length' => "#{content_length}",
+            'Content-Type' => self.media.content_type, 
+            'Content-Range' => "bytes #{start_offset}-#{end_offset}/#{media.length}" })
+          self.body = chunk
+        end
+        super
+      end
+      
+      ##
+      # Check the result from the server, updating the offset and/or location
+      # if available.
+      #
+      # @api private
+      #
+      # @param [Faraday::Response] response
+      #   HTTP response
+      #
+      # @return [Google::APIClient::Result]
+      #   Processed API response
+      def process_http_response(response)
+        case response.status
+        when 200...299
+          @complete = true
+        when 308
+          range = response.headers['range']
+          if range
+            @offset = range.scan(/\d+/).collect{|x| Integer(x)}.last + 1
+          end
+          if response.headers['location']
+            self.uri = response.headers['location']
+          end
+        when 400...499
+          @expired = true
+        when 500...599
+          # Invalidate the offset to mark it needs to be queried on the
+          # next request
+          @offset = nil
+        end
+        return Google::APIClient::Result.new(self, response)
+      end
+      
+      ##
+      # Hashified verison of the API request
+      #
+      # @return [Hash]
+      def to_hash
+        super.merge(:offset => @offset)
+      end
+      
+    end
+  end
+end