google-gax 0.10.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 042b5b8369bf9dd8599b15f142f6608fbd7d2eb2
-  data.tar.gz: 1982637288109d3c84bd27d531f0736a8060ce27
+  metadata.gz: 87b2e27818073928a99f7edc7a49ab31a1ff05a6
+  data.tar.gz: bbe86ff3f6584127ace5d22509c59bb1be0b7e60
 SHA512:
-  metadata.gz: f0cd057e35054c328494dab34bad86eeb47b90cbe762489be0e3f37598a52bed9097572d9b77a46ccc587fbdf35148a9e4e66e7a671571754a360063e55c5b6f
-  data.tar.gz: 619f3cea1620d36159a1cc51f15899f4b7c608a6cb4a20044c8472ef9ccb84d0cc4c352d4b6b5e69e187907d9dcdc52720f6c4c8ddd6523b8bd48fc5909456b8
+  metadata.gz: 108eb512cbf772cb7b0fd1196b9676ef594bb7ecbdab2038f4e307e9e1d20289b7a108d4031a28545c8110468adc23c2ffbccdafa57e311a00f152a6afe32db6
+  data.tar.gz: 37fb30807ae24551812160303d18ead970587dacb30c53e1a01708eee42ac77e6b4ff5c68b322470c34f0e8a0f04ac98505c4ecb1aab00632bdd31a274cbdd08

data/lib/google/gax/api_callable.rb

@@ -168,7 +168,7 @@ module Google
       # @yield [Page] Gives the pages in the stream.
       # @raise [GaxError] if it's not started yet.
       def each_page
-        raise GaxError, 'not started!' unless started?
+        raise GaxError.new('not started!') unless started?
         yield @page
         loop do
           break unless next_page?
@@ -254,8 +254,9 @@ module Google
                    end
         begin
           api_caller.call(api_call, request, this_settings)
-        rescue *settings.errors
-          raise GaxError, 'RPC failed'
+        rescue *settings.errors => e
+          error_class = Google::Gax.from_error e
+          raise error_class.new('RPC failed')
         end
       end
     end
@@ -348,15 +349,15 @@ module Google
         rescue => exception
           unless exception.respond_to?(:code) &&
                  retry_options.retry_codes.include?(exception.code)
-            raise RetryError, 'Exception occurred in retry method that ' \
-              'was not classified as transient'
+            raise RetryError.new('Exception occurred in retry method that ' \
+              'was not classified as transient')
           end
           sleep(rand(delay) / MILLIS_PER_SECOND)
           now = Time.now
           delay = [delay * delay_mult, max_delay].min
           timeout = [timeout * timeout_mult, max_timeout, deadline - now].min
           if now >= deadline
-            raise RetryError, 'Retry total timeout exceeded with exception'
+            raise RetryError.new('Retry total timeout exceeded with exception')
           end
           retry
         end

data/lib/google/gax/errors.rb

@@ -71,8 +71,81 @@ module Google
       end
     end
 
+    def from_error(error)
+      if error.respond_to? :code
+        grpc_error_class_for error.code
+      else
+        GaxError
+      end
+    end
+
     # Indicates an error during automatic GAX retrying.
     class RetryError < GaxError
     end
+
+    # Errors corresponding to standard HTTP/gRPC statuses.
+    class CanceledError < GaxError
+    end
+
+    class UnknownError < GaxError
+    end
+
+    class InvalidArgumentError < GaxError
+    end
+
+    class DeadlineExceededError < GaxError
+    end
+
+    class NotFoundError < GaxError
+    end
+
+    class AlreadyExistsError < GaxError
+    end
+
+    class PermissionDeniedError < GaxError
+    end
+
+    class ResourceExhaustedError < GaxError
+    end
+
+    class FailedPreconditionError < GaxError
+    end
+
+    class AbortedError < GaxError
+    end
+
+    class OutOfRangeError < GaxError
+    end
+
+    class UnimplementedError < GaxError
+    end
+
+    class InternalError < GaxError
+    end
+
+    class UnavailableError < GaxError
+    end
+
+    class DataLossError < GaxError
+    end
+
+    class UnauthenticatedError < GaxError
+    end
+
+    # @private Identify the subclass for a gRPC error
+    # Note: ported from
+    # https:/g/github.com/GoogleCloudPlatform/google-cloud-ruby/blob/master/google-cloud-core/lib/google/cloud/errors.rb
+    def self.grpc_error_class_for(grpc_error_code)
+      # The gRPC status code 0 is for a successful response.
+      # So there is no error subclass for a 0 status code, use current class.
+      [GaxError, CanceledError, UnknownError, InvalidArgumentError,
+       DeadlineExceededError, NotFoundError, AlreadyExistsError,
+       PermissionDeniedError, ResourceExhaustedError, FailedPreconditionError,
+       AbortedError, OutOfRangeError, UnimplementedError, InternalError,
+       UnavailableError, DataLossError,
+       UnauthenticatedError][grpc_error_code] || GaxError
+    end
+
+    module_function :from_error
   end
 end

data/lib/google/gax/grpc.rb

@@ -136,9 +136,9 @@ module Google
         if (channel && chan_creds) ||
            (channel && updater_proc) ||
            (chan_creds && updater_proc)
-          raise ArgumentError, 'Only one of channel, chan_creds, and ' \
+          raise ArgumentError.new('Only one of channel, chan_creds, and ' \
               'updater_proc should be passed into ' \
-              'Google::Gax::Grpc#create_stub.'
+              'Google::Gax::Grpc#create_stub.')
         end
       end
 

data/lib/google/gax/operation.rb

@@ -254,7 +254,7 @@ module Google
         until done?
           sleep(delay)
           if Time.now >= deadline
-            raise RetryError, 'Retry total timeout exceeded with exception'
+            raise RetryError.new('Retry total timeout exceeded with exception')
           end
           delay = [delay * delay_multiplier, max_delay].min
           reload!

data/lib/google/gax/path_template.rb

@@ -175,7 +175,7 @@ module Google
             literal_sym = segment.literal.to_sym
             unless bindings.key?(literal_sym)
               msg = "Value for key #{segment.literal} is not provided"
-              raise(ArgumentError, msg)
+              raise ArgumentError.new(msg)
             end
             out.concat(PathTemplate.new(bindings[literal_sym]).segments)
             binding = true

data/lib/google/gax/util.rb

@@ -27,6 +27,8 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+require 'google/protobuf/timestamp_pb'
+
 module Google
   # Gax defines Google API extensions
   module Gax
@@ -54,8 +56,9 @@ module Google
 
       # Sanity check: input must be a Hash
       unless hash.is_a? Hash
-        raise ArgumentError,
-              "Value #{hash} must be a Hash or a #{message_class.name}"
+        raise ArgumentError.new(
+          "Value #{hash} must be a Hash or a #{message_class.name}"
+        )
       end
       hash = coerce_submessages(hash, message_class)
       message_class.new(hash)
@@ -79,6 +82,9 @@ module Google
         field_descriptor = message_descriptor.lookup(key.to_s)
         if field_descriptor && field_descriptor.type == :message
           coerced[key] = coerce_submessage(val, field_descriptor)
+        elsif field_descriptor && field_descriptor.type == :bytes &&
+              (val.is_a?(IO) || val.is_a?(StringIO))
+          coerced[key] = val.binmode.read
         else
           # `google/protobuf` should throw an error if no field descriptor is
           # found. Simply pass through.
@@ -101,6 +107,9 @@ module Google
     def coerce_submessage(val, field_descriptor)
       if (field_descriptor.label == :repeated) && !(map_field? field_descriptor)
         coerce_array(val, field_descriptor)
+      elsif field_descriptor.subtype.msgclass == Google::Protobuf::Timestamp &&
+            val.is_a?(Time)
+        time_to_timestamp(val)
       else
         coerce(val, field_descriptor)
       end
@@ -118,7 +127,7 @@ module Google
     # @return [Array<Object>] The coerced version of the given values.
     def coerce_array(array, field_descriptor)
       unless array.is_a? Array
-        raise ArgumentError, 'Value ' + array.to_s + ' must be an array'
+        raise ArgumentError.new('Value ' + array.to_s + ' must be an array')
       end
       array.map do |val|
         coerce(val, field_descriptor)
@@ -150,8 +159,31 @@ module Google
       to_proto(val, field_descriptor.subtype.msgclass)
     end
 
+    # Utility for converting a Google::Protobuf::Timestamp instance to a Ruby
+    # time.
+    #
+    # @param timestamp [Google::Protobuf::Timestamp] The timestamp to be
+    #   converted.
+    #
+    # @return [Time] The converted Time.
+    def timestamp_to_time(timestamp)
+      Time.at(timestamp.nanos * 10**-9 + timestamp.seconds)
+    end
+
+    # Utility for converting a Ruby Time instance to a
+    # Google::Protobuf::Timestamp.
+    #
+    # @param time [Time] The Time to be converted.
+    #
+    # @return [Google::Protobuf::Timestamp] The converted
+    #   Google::Protobuf::Timestamp.
+    def time_to_timestamp(time)
+      Google::Protobuf::Timestamp.new(seconds: time.to_i, nanos: time.nsec)
+    end
+
     module_function :to_proto, :coerce_submessages, :coerce_submessage,
-                    :coerce_array, :coerce, :map_field?
+                    :coerce_array, :coerce, :map_field?, :timestamp_to_time,
+                    :time_to_timestamp
     private_class_method :coerce_submessages, :coerce_submessage, :coerce_array,
                          :coerce, :map_field?
   end

data/lib/google/gax/version.rb

@@ -29,6 +29,6 @@
 
 module Google
   module Gax
-    VERSION = '0.10.2'.freeze
+    VERSION = '1.0.0'.freeze
   end
 end

data/lib/google/longrunning/operations_client.rb

@@ -1,4 +1,4 @@
-# Copyright 2017, Google Inc. All rights reserved.
+# Copyright 2017, Google LLC All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@
 # copyright notice, this list of conditions and the following disclaimer
 # in the documentation and/or other materials provided with the
 # distribution.
-#     * Neither the name of Google Inc. nor the names of its
+#     * Neither the name of Google LLC nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
@@ -83,6 +83,7 @@ module Google
       ALL_SCOPES = [
       ].freeze
 
+
       # @param credentials [Google::Auth::Credentials, String, Hash, GRPC::Core::Channel, GRPC::Core::ChannelCredentials, Proc]
       #   Provides the means for authenticating requests made by the client. This parameter can
       #   be many types.
@@ -108,11 +109,6 @@ module Google
       # @param timeout [Numeric]
       #   The default timeout, in seconds, for calls made through this client.
       def initialize \
-          service_path: self.class::SERVICE_ADDRESS,
-          port: self.class::DEFAULT_SERVICE_PORT,
-          channel: nil,
-          chan_creds: nil,
-          updater_proc: nil,
           credentials: nil,
           scopes: ALL_SCOPES,
           client_config: {},
@@ -125,17 +121,6 @@ module Google
         require "google/gax/grpc"
         require "google/longrunning/operations_services_pb"
 
-        if channel || chan_creds || updater_proc
-          warn "The `channel`, `chan_creds`, and `updater_proc` parameters will be removed " \
-            "on 2017/09/08"
-          credentials ||= channel
-          credentials ||= chan_creds
-          credentials ||= updater_proc
-        end
-        if port != DEFAULT_SERVICE_PORT
-          warn "the `port` parameter is deprecated and will be removed"
-        end
-
         credentials ||= Google::Auth::Credentials.default(scopes: scopes)
 
         if credentials.is_a?(String) || credentials.is_a?(Hash)
@@ -154,9 +139,11 @@ module Google
           updater_proc = credentials.updater_proc
         end
 
+        package_version = Gem.loaded_specs['google-gax'].version.version
+
         google_api_client = "gl-ruby/#{RUBY_VERSION}"
         google_api_client << " #{lib_name}/#{lib_version}" if lib_name
-        google_api_client << " gapic/0.6.8 gax/#{Google::Gax::VERSION}"
+        google_api_client << " gapic/#{package_version} gax/#{Google::Gax::VERSION}"
         google_api_client << " grpc/#{GRPC::VERSION}"
         google_api_client.freeze
 
@@ -176,6 +163,10 @@ module Google
             kwargs: headers
           )
         end
+
+        # Allow overriding the service path/port in subclasses.
+        service_path = self.class::SERVICE_ADDRESS
+        port = self.class::DEFAULT_SERVICE_PORT
         @operations_stub = Google::Gax::Grpc.create_stub(
           service_path,
           port,

data/spec/fixtures/fixture.proto

@@ -15,6 +15,8 @@ syntax = "proto3";
 
 package google.protobuf;
 
+import "google/protobuf/timestamp.proto";
+
 message Request {
   string name = 1;
   User user = 2;
@@ -29,6 +31,8 @@ message User {
   UserType type = 2;
   repeated Post posts = 3;
   map<string, string> map_field = 4;
+  bytes bytes_field = 5;
+  google.protobuf.Timestamp timestamp = 6;
 }
 
 message Post {

data/spec/fixtures/fixture_file.txt

@@ -0,0 +1 @@
+This is a text file.

data/spec/fixtures/fixture_pb.rb

@@ -3,6 +3,7 @@
 
 require 'google/protobuf'
 
+require 'google/protobuf/timestamp_pb'
 Google::Protobuf::DescriptorPool.generated_pool.build do
   add_message "google.protobuf.Request" do
     optional :name, :string, 1
@@ -13,6 +14,8 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :type, :enum, 2, "google.protobuf.User.UserType"
     repeated :posts, :message, 3, "google.protobuf.Post"
     map :map_field, :string, :string, 4
+    optional :bytes_field, :bytes, 5
+    optional :timestamp, :message, 6, "google.protobuf.Timestamp"
   end
   add_enum "google.protobuf.User.UserType" do
     value :UNSPECIFIED, 0

data/spec/google/gax/api_callable_spec.rb

@@ -39,8 +39,8 @@ class CustomException < StandardError
   end
 end
 
-FAKE_STATUS_CODE_1 = :FAKE_STATUS_CODE_1
-FAKE_STATUS_CODE_2 = :FAKE_STATUS_CODE_2
+FAKE_STATUS_CODE_1 = 1
+FAKE_STATUS_CODE_2 = 2
 
 # Google::Gax::CallSettings is private, only accessible in the module context.
 # For testing purpose, this makes a toplevel ::CallSettings point to the same

data/spec/google/gax/bundling_spec.rb

@@ -158,7 +158,7 @@ describe Google::Gax do
   # A dummy api call that raises an exception
   def raise_exc
     proc do |_|
-      raise Google::Gax::GaxError, 'Raised in a test'
+      raise Google::Gax::GaxError.new('Raised in a test')
     end
   end
 

data/spec/google/gax/error_spec.rb

@@ -67,7 +67,7 @@ describe Google::Gax::GaxError do
     it 'presents GRPC::BadStatus values' do
       error = wrapped_badstatus(3, 'invalid')
 
-      expect(error).to be_an_instance_of(Google::Gax::GaxError)
+      expect(error).to be_a_kind_of(Google::Gax::GaxError)
       expect(error.message).to eq('GaxError 3:invalid, caused by 3:invalid')
       expect(error.code).to eq(3)
       expect(error.details).to eq('invalid')
@@ -93,7 +93,7 @@ describe Google::Gax::GaxError do
                    'grpc-status-details-bin' => encoded_status_detail }
       error = wrapped_badstatus(1, 'cancelled', metadata)
 
-      expect(error).to be_an_instance_of(Google::Gax::GaxError)
+      expect(error).to be_a_kind_of(Google::Gax::GaxError)
       expect(error.message).to eq('GaxError 1:cancelled, caused by 1:cancelled')
       expect(error.code).to eq(1)
       expect(error.details).to eq('cancelled')
@@ -108,10 +108,107 @@ describe Google::Gax::GaxError do
     end
   end
 
+  describe '#from_error' do
+    it 'identifies CanceledError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(1, 'cancelled')
+      expect(mapped_error).to eq Google::Gax::CanceledError
+    end
+
+    it 'identifies UnknownError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(2, 'unknown')
+      expect(mapped_error).to eq Google::Gax::UnknownError
+    end
+
+    it 'identifies InvalidArgumentError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(3, 'invalid')
+      expect(mapped_error).to eq Google::Gax::InvalidArgumentError
+    end
+
+    it 'identifies DeadlineExceededError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(4, 'exceeded')
+      expect(mapped_error).to eq Google::Gax::DeadlineExceededError
+    end
+
+    it 'identifies NotFoundError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(5, 'not found')
+      expect(mapped_error).to eq Google::Gax::NotFoundError
+    end
+
+    it 'identifies AlreadyExistsError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(6, 'exists')
+      expect(mapped_error).to eq Google::Gax::AlreadyExistsError
+    end
+
+    it 'identifies PermissionDeniedError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(7, 'denied')
+      expect(mapped_error).to eq Google::Gax::PermissionDeniedError
+    end
+
+    it 'identifies ResourceExhaustedError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(8, 'exhausted')
+      expect(mapped_error).to eq Google::Gax::ResourceExhaustedError
+    end
+
+    it 'identifies FailedPreconditionError' do
+      mapped_error =
+        Google::Gax.from_error GRPC::BadStatus.new(9, 'precondition')
+      expect(mapped_error).to eq Google::Gax::FailedPreconditionError
+    end
+
+    it 'identifies AbortedError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(10, 'aborted')
+      expect(mapped_error).to eq Google::Gax::AbortedError
+    end
+
+    it 'identifies OutOfRangeError' do
+      mapped_error =
+        Google::Gax.from_error GRPC::BadStatus.new(11, 'out of range')
+      expect(mapped_error).to eq Google::Gax::OutOfRangeError
+    end
+
+    it 'identifies UnimplementedError' do
+      mapped_error =
+        Google::Gax.from_error GRPC::BadStatus.new(12, 'unimplemented')
+      expect(mapped_error).to eq Google::Gax::UnimplementedError
+    end
+
+    it 'identifies InternalError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(13, 'internal')
+      expect(mapped_error).to eq Google::Gax::InternalError
+    end
+
+    it 'identifies UnavailableError' do
+      mapped_error =
+        Google::Gax.from_error GRPC::BadStatus.new(14, 'unavailable')
+      expect(mapped_error).to eq Google::Gax::UnavailableError
+    end
+
+    it 'identifies DataLossError' do
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(15, 'data loss')
+      expect(mapped_error).to eq Google::Gax::DataLossError
+    end
+
+    it 'identifies UnauthenticatedError' do
+      mapped_error =
+        Google::Gax.from_error GRPC::BadStatus.new(16, 'unauthenticated')
+      expect(mapped_error).to eq Google::Gax::UnauthenticatedError
+    end
+
+    it 'identifies unknown error' do
+      # We don't know what to map this error case to
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(0, 'unknown')
+      expect(mapped_error).to eq Google::Gax::GaxError
+
+      mapped_error = Google::Gax.from_error GRPC::BadStatus.new(17, 'unknown')
+      expect(mapped_error).to eq Google::Gax::GaxError
+    end
+  end
+
   def wrap_with_gax_error(err)
     raise err
   rescue => e
-    raise Google::Gax::GaxError, e.message
+    klass = Google::Gax.from_error(e)
+    raise klass.new(e.message)
   end
 
   def wrapped_error(msg)

data/spec/google/gax/util_spec.rb

@@ -29,7 +29,9 @@
 
 require 'google/gax'
 require 'google/protobuf/any_pb'
+require 'google/protobuf/timestamp_pb'
 require 'spec/fixtures/fixture_pb'
+require 'stringio'
 
 describe Google::Gax do
   describe '#to_proto' do
@@ -110,6 +112,38 @@ describe Google::Gax do
       end
     end
 
+    it 'handles IO instances' do
+      file = File.new('spec/fixtures/fixture_file.txt')
+      request_hash = {
+        bytes_field: file
+      }
+      user = Google::Gax.to_proto(request_hash, Google::Protobuf::User)
+      expect(user.bytes_field).to eq("This is a text file.\n")
+    end
+
+    it 'handles StringIO instances' do
+      expected = 'This is a StringIO.'
+      string_io = StringIO.new(expected)
+      request_hash = {
+        bytes_field: string_io
+      }
+      user = Google::Gax.to_proto(request_hash, Google::Protobuf::User)
+      expect(user.bytes_field).to eq(expected)
+    end
+
+    it 'auto-coerces Time' do
+      seconds = 271_828_182
+      nanos = 845_904_523
+      # Fixnum, not float, for precision
+      sometime = seconds + nanos * 10**-9
+      request_hash = {
+        timestamp: Time.at(sometime)
+      }
+      user = Google::Gax.to_proto(request_hash, Google::Protobuf::User)
+      expected = Google::Protobuf::Timestamp.new(seconds: seconds, nanos: nanos)
+      expect(user.timestamp).to eq(expected)
+    end
+
     it 'fails if a key does not exist in the target message type' do
       user_hash = {
         name: USER_NAME,
@@ -135,4 +169,31 @@ describe Google::Gax do
       end.to raise_error(ArgumentError)
     end
   end
+
+  describe 'time-timestamp conversion' do
+    SECONDS = 271_828_182
+    NANOS = 845_904_523
+    A_TIME = Time.at(SECONDS + NANOS * 10**-9)
+    A_TIMESTAMP =
+      Google::Protobuf::Timestamp.new(seconds: SECONDS, nanos: NANOS)
+
+    it 'converts time to timestamp' do
+      expect(Google::Gax.time_to_timestamp(A_TIME)).to eq A_TIMESTAMP
+    end
+
+    it 'converts timestamp to time' do
+      expect(Google::Gax.timestamp_to_time(A_TIMESTAMP)).to eq A_TIME
+    end
+
+    it 'is an identity when conversion is a round trip' do
+      expect(
+        Google::Gax.timestamp_to_time(Google::Gax.time_to_timestamp(A_TIME))
+      ).to eq A_TIME
+      expect(
+        Google::Gax.time_to_timestamp(
+          Google::Gax.timestamp_to_time(A_TIMESTAMP)
+        )
+      ).to eq A_TIMESTAMP
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-gax
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Google API Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-01 00:00:00.000000000 Z
+date: 2017-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: googleauth
@@ -184,6 +184,7 @@ files:
 - lib/google/longrunning/operations_client.rb
 - lib/google/longrunning/operations_client_config.json
 - spec/fixtures/fixture.proto
+- spec/fixtures/fixture_file.txt
 - spec/fixtures/fixture_pb.rb
 - spec/google/gax/api_callable_spec.rb
 - spec/google/gax/bundling_spec.rb
@@ -214,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Aids the development of APIs for clients and servers based on GRPC and Google