Module: Legion::Extensions::Node::Runners::Node

Includes:
Helpers::Lex
Defined in:
lib/legion/extensions/node/runners/node.rb

Instance Method Summary collapse

Instance Method Details

#broadcast_settings(settings:, routing_key: 'settings', restart: false, **_opts) ⇒ Object 



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/legion/extensions/node/runners/node.rb', line 125

def broadcast_settings(settings:, routing_key: 'settings', restart: false, **_opts)
  log.debug "broadcast_settings: routing_key=#{routing_key} keys=#{settings.keys.join(', ')}"
  Legion::Extensions::Node::Transport::Messages::ClusterSettings.new(
    settings:    settings,
    routing_key: routing_key,
    restart:     restart
  ).publish
  {}
rescue StandardError => e
  log.error "broadcast_settings failed: #{e.message}"
  {}
end

#delete_public_key(name:, **_opts) ⇒ Object 



79
80
81
82
83
 
# File 'lib/legion/extensions/node/runners/node.rb', line 79

def delete_public_key(name:, **_opts)
  log.debug 'delete_public_key'
  Legion::Settings[:cluster][:public_keys].delete(name)
  {}
end

#killswitch(extension:, **_opts) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
 
# File 'lib/legion/extensions/node/runners/node.rb', line 138

def killswitch(extension:, **_opts)
  log.debug "killswitch: blocking extension #{extension} cluster-wide"
  Legion::Extensions::Node::Transport::Messages::ClusterKillswitch.new(
    extension: extension.to_s.delete_prefix('lex-')
  ).publish
  {}
rescue StandardError => e
  log.error "killswitch failed: #{e.message}"
  {}
end

#message(_options = {}, **hash) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/legion/extensions/node/runners/node.rb', line 10

def message(_options = {}, **hash)
  log.debug 'message'
  hash.each do |k, v|
    raise 'Cannot override base setting that doesn\'t exist' if Legion::Settings[k].nil?

    case v
    when String
      Legion::Settings[k] = v
    when Hash
      v.each do |key, value|
        Legion::Settings[k][key] = value
      end
    end
  end
end

#push_cluster_secret(public_key:, queue_name:, **_opts) ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/legion/extensions/node/runners/node.rb', line 98

def push_cluster_secret(public_key:, queue_name:, **_opts)
  log.debug 'push_cluster_secret'
  return {} unless Legion::Settings[:crypt][:cs_encrypt_ready]

  encrypted = Legion::Crypt.encrypt_from_keypair(pub_key: public_key,
                                                 message: Legion::Settings[:crypt][:cluster_secret].to_s)
  legion = Legion::Crypt.encrypt('legion')
  Legion::Extensions::Node::Transport::Messages::PushClusterSecret.new(message:           encrypted,
                                                                       queue_name:        queue_name,
                                                                       validation_string: 'legion',
                                                                       encrypted_string:  legion).publish
  {}
end

#push_public_key(**_opts) ⇒ Object 



64
65
66
67
68
69
70
71
 
# File 'lib/legion/extensions/node/runners/node.rb', line 64

def push_public_key(**_opts)
  log.debug 'push_public_key'
  message_hash = { function:   'update_public_key',
                   public_key: Base64.encode64(Legion::Crypt.public_key),
                   **Legion::Settings[:client] }
  Legion::Extensions::Node::Transport::Messages::PublicKey.new(message_hash).publish
  {}
end

#receive_cluster_secret(message:, **opts) ⇒ Object 



112
113
114
115
116
117
118
 
# File 'lib/legion/extensions/node/runners/node.rb', line 112

def receive_cluster_secret(message:, **opts)
  log.debug 'receive_cluster_secret'
  Legion::Settings[:crypt][:cluster_secret] = Legion::Crypt.decrypt_from_keypair(message: message)
  Legion::Settings[:crypt][:encrypted_string] = opts[:encrypted_string]
  Legion::Settings[:crypt][:validation_string] = opts[:validation_string]
  {}
end

#receive_vault_token(message:, routing_key:, public_key:) ⇒ Object 



120
121
122
123
 
# File 'lib/legion/extensions/node/runners/node.rb', line 120

def receive_vault_token(message:, routing_key:, public_key:, **)
  Legion::Extensions::Node::Runners::Vault.receive_vault_token(message: message, routing_key: routing_key,
                                                               public_key: public_key)
end

#request_cluster_secret(**_opts) ⇒ Object 



92
93
94
95
96
 
# File 'lib/legion/extensions/node/runners/node.rb', line 92

def request_cluster_secret(**_opts)
  log.debug 'request_cluster_secret'
  Legion::Extensions::Node::Transport::Messages::RequestClusterSecret.new.publish
  {}
end

#request_public_keys(**_opts) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/legion/extensions/node/runners/node.rb', line 85

def request_public_keys(**_opts)
  log.debug 'request_public_keys'
  message_hash = { function: 'push_public_key' }
  Legion::Extensions::Node::Transport::Messages::RequestPublicKeys.new(**message_hash).publish
  {}
end

#update_gem(extension:, version: nil, reload: true, **_opts) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/legion/extensions/node/runners/node.rb', line 26

def update_gem(extension:, version: nil, reload: true, **_opts)
  name = extension.to_s.delete_prefix('lex-')
  gem_name = "lex-#{name}"
  log.debug "update_gem: installing #{gem_name} #{version || 'latest'}"

  install_result = install_extension_gem(gem_name, version)
  raise Gem::InstallError, install_result[:output].to_s unless install_result[:success]

  reload_extension(gem_name) if reload

  publish_update_result(action: 'update_gem', status: 'success', detail: "#{gem_name} #{version || 'latest'}")
rescue StandardError => e
  log.error "update_gem failed: #{e.message}"
  publish_update_result(action: 'update_gem', status: 'failed', detail: gem_name, error: e.message)
end

#update_public_key(name:, public_key:, **_opts) ⇒ Object 



73
74
75
76
77
 
# File 'lib/legion/extensions/node/runners/node.rb', line 73

def update_public_key(name:, public_key:, **_opts)
  log.debug 'update_public_key'
  Legion::Settings[:cluster][:public_keys][name] = public_key
  {}
end

#update_settings(settings:, restart: false, **_opts) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/legion/extensions/node/runners/node.rb', line 42

def update_settings(settings:, restart: false, **_opts)
  log.debug "update_settings: merging #{settings.keys.join(', ')}"

  settings.each do |k, v|
    case v
    when Hash
      Legion::Settings[k] ||= {}
      v.each { |key, value| Legion::Settings[k][key] = value }
    else
      Legion::Settings[k] = v
    end
  end

  Legion.reload if restart

  publish_update_result(action: 'update_settings', status: 'success',
                        detail: "keys: #{settings.keys.join(', ')}")
rescue StandardError => e
  log.error "update_settings failed: #{e.message}"
  publish_update_result(action: 'update_settings', status: 'failed', error: e.message)
end