Class: Gruf::Client

Inherits:
SimpleDelegator
  • Object
show all
Includes:
Loggable
Defined in:
lib/gruf/client.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.

Defined Under Namespace

Classes: Error

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Loggable

#logger

Constructor Details

#initialize(service:, 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

Options Hash (options:):

  • :password (String) —

    The password for basic authentication for the service.

  • :hostname (String) —

    The hostname of the service. Defaults to linkerd.



70
71
72
73
74
75
76
77
78
 
# File 'lib/gruf/client.rb', line 70

def initialize(service:, 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)
  client = "#{service}::Stub".constantize.new(@opts[:hostname], build_ssl_credentials)
  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



56
57
58
 
# File 'lib/gruf/client.rb', line 56

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



60
61
62
 
# File 'lib/gruf/client.rb', line 60

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



58
59
60
 
# File 'lib/gruf/client.rb', line 58

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



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/gruf/client.rb', line 91

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 = execute(call_sig, req, md, opts, &block)

  Gruf::Response.new(resp.result, resp.time)
rescue GRPC::BadStatus => e
  emk = Gruf.error_metadata_key.to_s
  raise Gruf::Client::Error, error_deserializer_class.new(e.metadata[emk]).deserialize if e.respond_to?(:metadata) && e.metadata.key?(emk)
  raise # passthrough
rescue StandardError => e
  Gruf.logger.error e.message
  raise
end