Class: Restate::VirtualObject

Inherits:
Object
  • Object
show all
Extended by:
ServiceDSL
Defined in:
lib/restate/virtual_object.rb

Overview

A keyed virtual object with durable state.

Examples:

class Counter < Restate::VirtualObject
  handler def add(ctx, addend)
    old = ctx.get("count") || 0
    ctx.set("count", old + addend)
    old + addend
  end

  shared def get(ctx)
    ctx.get("count") || 0
  end
end

Class Method Summary collapse

Methods included from ServiceDSL

abort_timeout, description, enable_lazy_state, handlers, idempotency_retention, inactivity_timeout, ingress_private, inherited, invocation_retry_policy, journal_retention, lazy_state?, metadata, service_name, service_tag, state, svc_abort_timeout, svc_idempotency_retention, svc_inactivity_timeout, svc_ingress_private, svc_invocation_retry_policy, svc_journal_retention

Class Method Details

._service_kind ⇒ Object 



75
76
77
 
# File 'lib/restate/virtual_object.rb', line 75

def self._service_kind
  'object'
end

.call(key) ⇒ ServiceCallProxy

Returns a call proxy for fluent durable calls to this virtual object.

Examples:

Counter.call("my-key").add(5).await

Parameters:

  • key (String) —

    the object key

Returns:

  • (ServiceCallProxy) 


58
59
60
 
# File 'lib/restate/virtual_object.rb', line 58

def self.call(key)
  ServiceCallProxy.new(self, key: key, call_method: :object_call)
end

.handler(method_name = nil, kind: :exclusive, **opts) ⇒ Symbol

Register an exclusive handler. Use as: handler def my_method(ctx, arg)

Parameters:

  • method_name (Symbol) (defaults to: nil) —

    name of the method to register

  • kind (Symbol) (defaults to: :exclusive) —

    concurrency mode (:exclusive or :shared)

  • opts (Hash) —

    handler options (input:, output:, accept:, content_type:)

Returns:

  • (Symbol) —

    the method name



28
29
30
31
32
33
34
35
36
 
# File 'lib/restate/virtual_object.rb', line 28

def self.handler(method_name = nil, kind: :exclusive, **opts)
  if method_name.is_a?(String)
    raise ArgumentError,
          "handler expects a Symbol (use `handler def #{method_name}(...)` or `handler :#{method_name}`)"
  end
  return method_name unless method_name.is_a?(Symbol)

  _register_handler(method_name, kind: kind.to_s, **opts)
end

.send!(key, delay: nil) ⇒ ServiceSendProxy

Returns a send proxy for fluent fire-and-forget sends to this virtual object.

Examples:

Counter.send!("my-key").add(5)
Counter.send!("my-key", delay: 60).add(5)

Parameters:

  • key (String) —

    the object key

  • delay (Numeric, nil) (defaults to: nil) —

    optional delay in seconds

Returns:

  • (ServiceSendProxy) 


71
72
73
 
# File 'lib/restate/virtual_object.rb', line 71

def self.send!(key, delay: nil)
  ServiceSendProxy.new(self, key: key, send_method: :object_send, delay: delay)
end

.shared(method_name, **opts) ⇒ Symbol

Register a shared (concurrent-access) handler.

Parameters:

  • method_name (Symbol) —

    name of the method to register

Returns:

  • (Symbol) —

    the method name



42
43
44
45
46
47
48
49
 
# File 'lib/restate/virtual_object.rb', line 42

def self.shared(method_name, **opts)
  if method_name.is_a?(String)
    raise ArgumentError,
          "handler expects a Symbol (use `shared def #{method_name}(...)` or `shared :#{method_name}`)"
  end

  _register_handler(method_name, kind: 'shared', **opts)
end