Class: Igniter::LedgerClient::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/igniter/ledger_client/client.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(transport:) ⇒ Client

Returns a new instance of Client.



13
14
15
 
# File 'lib/igniter/ledger_client/client.rb', line 13

def initialize(transport:)
  @transport = transport
end

Instance Attribute Details

#transport ⇒ Object (readonly)

Returns the value of attribute transport.



11
12
13
 
# File 'lib/igniter/ledger_client/client.rb', line 11

def transport
  @transport
end

Instance Method Details

#append(history:, event:, key: nil, partition_key: nil, **metadata) ⇒ Object 



25
26
27
28
29
30
 
# File 'lib/igniter/ledger_client/client.rb', line 25

def append(history:, event:, key: nil, partition_key: nil, **metadata)
  packet = metadata.merge(history: history, event: event)
  packet[:key] = key if key
  packet[:partition_key] = partition_key if partition_key
  Results.wrap(:append, dispatch(:append, packet))
end

#causation_chain(store:, key:) ⇒ Object 



67
68
69
 
# File 'lib/igniter/ledger_client/client.rb', line 67

def causation_chain(store:, key:)
  Results.wrap(:causation_chain, dispatch(:causation_chain, { store: store, key: key }))
end

#close ⇒ Object 



113
114
115
 
# File 'lib/igniter/ledger_client/client.rb', line 113

def close
  transport.close if transport.respond_to?(:close)
end

#compaction_activity(store: nil, kind: nil, since: nil, limit: nil) ⇒ Object 



85
86
87
88
89
90
91
92
 
# File 'lib/igniter/ledger_client/client.rb', line 85

def compaction_activity(store: nil, kind: nil, since: nil, limit: nil)
  packet = {}
  packet[:store] = store if store
  packet[:kind] = kind if kind
  packet[:since] = since if since
  packet[:limit] = limit if limit
  dispatch(:compaction_activity, packet)
end

#descriptor_snapshot ⇒ Object 



81
 
# File 'lib/igniter/ledger_client/client.rb', line 81

def descriptor_snapshot = dispatch(:descriptor_snapshot)

#dispatch(operation, packet = {}, request_id: nil) ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/igniter/ledger_client/client.rb', line 104

def dispatch(operation, packet = {}, request_id: nil)
  request = Envelope.request(operation: operation, packet: packet, request_id: request_id)
  Envelope.result_or_raise(transport.dispatch(request))
rescue Error
  raise
rescue StandardError => e
  raise TransportError.new(e.message, request_id: request&.fetch(:request_id, nil))
end

#fact_ref(fact_id) ⇒ Object 



75
76
77
 
# File 'lib/igniter/ledger_client/client.rb', line 75

def fact_ref(fact_id)
  Results.wrap(:fact_ref, dispatch(:fact_ref, { fact_id: fact_id }))
end

#lineage(store:, key:) ⇒ Object 



71
72
73
 
# File 'lib/igniter/ledger_client/client.rb', line 71

def lineage(store:, key:)
  Results.wrap(:lineage, dispatch(:lineage, { store: store, key: key }))
end

#metadata_snapshot ⇒ Object 



79
 
# File 'lib/igniter/ledger_client/client.rb', line 79

def metadata_snapshot = dispatch(:metadata_snapshot)

#observability_snapshot ⇒ Object 



83
 
# File 'lib/igniter/ledger_client/client.rb', line 83

def observability_snapshot = dispatch(:observability_snapshot)

#query(store:, where:, limit: nil, as_of: nil, order: nil) ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/igniter/ledger_client/client.rb', line 38

def query(store:, where:, limit: nil, as_of: nil, order: nil)
  packet = { store: store, where: where }
  packet[:limit] = limit if limit
  packet[:as_of] = as_of if as_of
  packet[:order] = order if order
  Results.wrap(:query, dispatch(:query, packet))
end

#read(store:, key:, as_of: nil) ⇒ Object 



32
33
34
35
36
 
# File 'lib/igniter/ledger_client/client.rb', line 32

def read(store:, key:, as_of: nil)
  packet = { store: store, key: key }
  packet[:as_of] = as_of if as_of
  Results.wrap(:read, dispatch(:read, packet))
end

#register_descriptor(descriptor = nil, **fields) ⇒ Object 



17
18
19
 
# File 'lib/igniter/ledger_client/client.rb', line 17

def register_descriptor(descriptor = nil, **fields)
  Results.wrap(:register_descriptor, dispatch(:register_descriptor, (descriptor || {}).merge(fields)))
end

#replay(store: nil, from: nil, to: nil, key: nil, partition_key: nil, partition_value: nil, filter: nil) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/igniter/ledger_client/client.rb', line 46

def replay(store: nil, from: nil, to: nil, key: nil, partition_key: nil, partition_value: nil, filter: nil)
  packet = {}
  packet[:from] = from if from
  packet[:to] = to if to
  filter_packet = replay_filter(
    store: store,
    key: key,
    partition_key: partition_key,
    partition_value: partition_value,
    filter: filter
  )
  packet[:filter] = filter_packet if filter_packet
  Results.wrap(:replay, dispatch(:replay, packet))
end

#resolve(relation:, from:, as_of: nil) ⇒ Object 



61
62
63
64
65
 
# File 'lib/igniter/ledger_client/client.rb', line 61

def resolve(relation:, from:, as_of: nil)
  packet = { relation: relation, from: from }
  packet[:as_of] = as_of if as_of
  Results.wrap(:resolve, dispatch(:resolve, packet))
end

#subscribe(stores:, cursor: nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


94
95
96
97
98
99
100
101
102
 
# File 'lib/igniter/ledger_client/client.rb', line 94

def subscribe(stores:, cursor: nil, &block)
  raise ArgumentError, "subscribe requires a block" unless block

  raise NotImplementedError, "ledger client transport does not support subscriptions" unless transport.respond_to?(:subscribe)

  transport.subscribe(stores: stores, cursor: cursor) do |event|
    block.call(Results::ChangeEventResult.new(event))
  end
end

#write(store:, key:, value:, **metadata) ⇒ Object 



21
22
23
 
# File 'lib/igniter/ledger_client/client.rb', line 21

def write(store:, key:, value:, **metadata)
  Results.wrap(:write, dispatch(:write, metadata.merge(store: store, key: key, value: value)))
end