Module: Legion::MCP::PatternGossip

Extended by:
Logging::Helper
Defined in:
lib/legion/mcp/pattern_gossip.rb

Constant Summary collapse

EXCHANGE_NAME = 
'tbi.patterns'
ANNOUNCE_TTL = 
86_400

Class Method Summary collapse

Class Method Details

.announce(pattern) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/legion/mcp/pattern_gossip.rb', line 16

def announce(pattern)
  log.info('Starting legion.mcp.pattern_gossip.announce')
  return nil unless transport_available?

  exported = PatternSchema.export(pattern)
  message = {
    action:     'announce',
    pattern_id: exported[:pattern_id],
    pattern:    exported,
    origin:     { instance_id: instance_id },
    ttl:        ANNOUNCE_TTL,
    version:    1
  }

  Legion::Transport::Messages::Dynamic.new(
    function: "#{EXCHANGE_NAME}.announce",
    data:     message
  ).publish

  { published: true, pattern_id: exported[:pattern_id] }
rescue StandardError => e
  handle_exception(e, level: :warn, operation: 'legion.mcp.pattern_gossip.announce')
  log.warn("PatternGossip#announce failed: #{e.message}")
  nil
end

.instance_id ⇒ Object 



59
60
61
 
# File 'lib/legion/mcp/pattern_gossip.rb', line 59

def instance_id
  @instance_id ||= SecureRandom.uuid
end

.receive(message) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
 
# File 'lib/legion/mcp/pattern_gossip.rb', line 42

def receive(message)
  log.info('Starting legion.mcp.pattern_gossip.receive')
  return nil unless message.is_a?(Hash) && message[:pattern]

  PatternSchema.import(message[:pattern], trust_level: :org)
rescue StandardError => e
  handle_exception(e, level: :warn, operation: 'legion.mcp.pattern_gossip.receive')
  log.warn("PatternGossip#receive failed: #{e.message}")
  nil
end

.reset! ⇒ Object 



63
64
65
 
# File 'lib/legion/mcp/pattern_gossip.rb', line 63

def reset!
  @instance_id = nil
end

.transport_available? ⇒ Boolean

Returns:

  • (Boolean) 


53
54
55
56
57
 
# File 'lib/legion/mcp/pattern_gossip.rb', line 53

def transport_available?
  defined?(Legion::Transport) &&
    Legion::Transport.respond_to?(:connected?) &&
    Legion::Transport.connected?
end