Class: Gruf::Client

Inherits:
SimpleDelegator
  • Object
show all
Includes:
Loggable
Defined in:
lib/gruf/client.rb,
lib/gruf/client/error.rb,
lib/gruf/client/error_factory.rb

Overview

Abstracts out the calling interface for interacting with gRPC clients. Streamlines calling and provides instrumented response objects that also can contain deserialized error messages via serialized objects transported via the service’s trailing metadata.

begin
  client = ::Gruf::Client.new(service: ::Demo::ThingService)
  response = client.call(:GetMyThing, id: 123)
  puts response.message.inspect
rescue Gruf::Client::Error => e
  puts e.error.inspect
end

Utilizes SimpleDelegator to wrap the given service that the client is connecting to, which allows a clean interface to the underlying RPC descriptors and methods.

Direct Known Subclasses

SynchronizedClient

Defined Under Namespace

Modules: Errors Classes: Error, ErrorFactory

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Loggable

#logger

Constructor Details

#initialize(service:, options: {}, client_options: {}) ⇒ Client

Initialize the client and setup the stub

Parameters:

  • service (Module) —

    The namespace of the client Stub that is desired to load

  • options (Hash) (defaults to: {}) —

    A hash of options for the client

  • client_options (Hash) (defaults to: {}) —

    A hash of options to pass to the gRPC client stub

Options Hash (options:):

  • :password (String) —

    The password for basic authentication for the service.

  • :hostname (String) —

    The hostname of the service. Defaults to linkerd.



55
56
57
58
59
60
61
62
63
64
 
# File 'lib/gruf/client.rb', line 55

def initialize(service:, options: {}, client_options: {})
  @base_klass = service
  @service_klass = "#{base_klass}::Service".constantize
  @opts = options || {}
  @opts[:password] = options.fetch(:password, '').to_s
  @opts[:hostname] = options.fetch(:hostname, Gruf.default_client_host)
  @error_factory = Gruf::Client::ErrorFactory.new
  client = "#{service}::Stub".constantize.new(@opts[:hostname], build_ssl_credentials, client_options)
  super(client)
end

Instance Attribute Details

#base_klass ⇒ Class (readonly)

Returns The base, friendly name of the service being requested.

Returns:

  • (Class) —

    The base, friendly name of the service being requested



40
41
42
 
# File 'lib/gruf/client.rb', line 40

def base_klass
  @base_klass
end

#opts ⇒ Hash (readonly)

Returns A hash of options for the client.

Returns:

  • (Hash) —

    A hash of options for the client



44
45
46
 
# File 'lib/gruf/client.rb', line 44

def opts
  @opts
end

#service_klass ⇒ Class (readonly)

Returns The class name of the gRPC service being requested.

Returns:

  • (Class) —

    The class name of the gRPC service being requested



42
43
44
 
# File 'lib/gruf/client.rb', line 42

def service_klass
  @service_klass
end

Instance Method Details

#call(request_method, params = {}, metadata = {}, opts = {}, &block) ⇒ Gruf::Response

Call the client’s method with given params

for the given above call error type that was returned

Parameters:

  • request_method (String|Symbol) —

    The method that is being requested on the service

  • params (Hash) (defaults to: {}) —

    (Optional) A hash of parameters that will be inserted into the gRPC request message that is required

  • metadata (Hash) (defaults to: {}) —

    (Optional) A hash of metadata key/values that are transported with the client request

  • opts (Hash) (defaults to: {}) —

    (Optional) A hash of options to send to the gRPC request_response method

Returns:

Raises:

  • (Gruf::Client::Error|GRPC::BadStatus) —

    If an error occurs, an exception will be raised according to the



78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/gruf/client.rb', line 78

def call(request_method, params = {}, metadata = {}, opts = {}, &block)
  request_method = request_method.to_sym
  req = streaming_request?(request_method) ? params : request_object(request_method, params)
  md = build_metadata(metadata)
  call_sig = call_signature(request_method)

  raise NotImplementedError, "The method #{request_method} has not been implemented in this service." unless call_sig

  resp, operation = execute(call_sig, req, md, opts, &block)

  raise @error_factory.from_exception(resp.result) unless resp.success?

  Gruf::Response.new(operation: operation, message: resp.result, execution_time: resp.time)
end

#timeout ⇒ Integer|NilClass

Returns the currently set timeout on the client stub

Returns:

  • (Integer|NilClass) 


98
99
100
 
# File 'lib/gruf/client.rb', line 98

def timeout
  __getobj__.instance_variable_get(:@timeout)
end