lex-node 0.2.0 → 0.2.3

data/lib/legion/extensions/node/actors/vault_token_request.rb

@@ -1,27 +1,35 @@
-module Legion::Extensions::Node::Actor
-  class VaultTokenRequest < Legion::Extensions::Actors::Once
-    def runner_function
-      'request_token'
-    end
+# frozen_string_literal: true
 
-    def runner_class
-      Legion::Extensions::Node::Runners::Vault
-    end
+module Legion
+  module Extensions
+    module Node
+      module Actor
+        class VaultTokenRequest < Legion::Extensions::Actors::Once
+          def runner_function
+            'request_token'
+          end
 
-    def use_runner?
-      false
-    end
+          def runner_class
+            Legion::Extensions::Node::Runners::Vault
+          end
 
-    def check_subtask?
-      false
-    end
+          def use_runner?
+            false
+          end
 
-    def generate_task?
-      false
-    end
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
 
-    def delay
-      0
+          def delay
+            0
+          end
+        end
+      end
     end
   end
 end

data/lib/legion/extensions/node/data_test/migrations/001_nodes_table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Sequel.migration do
   up do
     run "CREATE TABLE `nodes` (

data/lib/legion/extensions/node/data_test/migrations/002_node_history_table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Sequel.migration do
   up do
     run "
@@ -23,4 +25,3 @@ Sequel.migration do
     drop_table :node_history
   end
 end
-

data/lib/legion/extensions/node/data_test/migrations/003_legion_version_colume.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Sequel.migration do
   change do
     alter_table(:nodes) do

data/lib/legion/extensions/node/data_test/migrations/004_node_extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Sequel.migration do
   up do
     run "
@@ -20,4 +22,3 @@ Sequel.migration do
     drop_table :node_extensions
   end
 end
-

data/lib/legion/extensions/node/runners/beat.rb

@@ -1,13 +1,21 @@
-module Legion::Extensions::Node::Runners
-  module Beat
-    include Legion::Extensions::Helpers::Transport
+# frozen_string_literal: true
 
-    def beat(status: 'active', **opts)
-      log.debug 'sending hearbeat'
-      messages::Beat.new(status: status).publish
-      { success: true, status: status, version: Legion::VERSION || nil, **opts }
-    end
+module Legion
+  module Extensions
+    module Node
+      module Runners
+        module Beat
+          include Legion::Extensions::Helpers::Transport
+
+          def beat(status: 'active', **opts)
+            log.debug 'sending hearbeat'
+            messages::Beat.new(status: status).publish
+            { success: true, status: status, version: Legion::VERSION || nil, **opts }
+          end
 
-    include Legion::Extensions::Helpers::Lex
+          include Legion::Extensions::Helpers::Lex
+        end
+      end
+    end
   end
 end

data/lib/legion/extensions/node/runners/crypt.rb

@@ -1,61 +1,69 @@
-module Legion::Extensions::Node::Runners
-  module Crypt
-    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
+# frozen_string_literal: true
 
-    def self.update_public_key(name:, public_key:, **_opts)
-      log.debug 'update_public_key'
-      Legion::Settings[:cluster][:public_keys][name] = public_key
-      {}
-    end
+module Legion
+  module Extensions
+    module Node
+      module Runners
+        module Crypt
+          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
 
-    def delete_public_key(name:, **_opts)
-      log.debug 'delete_public_key'
-      Legion::Settings[:cluster][:public_keys].delete(name)
-      {}
-    end
+          def self.update_public_key(name:, public_key:, **_opts)
+            log.debug 'update_public_key'
+            Legion::Settings[:cluster][:public_keys][name] = public_key
+            {}
+          end
 
-    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
+          def delete_public_key(name:, **_opts)
+            log.debug 'delete_public_key'
+            Legion::Settings[:cluster][:public_keys].delete(name)
+            {}
+          end
 
-    def request_cluster_secret(**_opts)
-      log.debug 'request_cluster_secret'
-      Legion::Transport::Messages::RequestClusterSecret.new.publish
-      {}
-    end
+          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
 
-    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
+          def request_cluster_secret(**_opts)
+            log.debug 'request_cluster_secret'
+            Legion::Transport::Messages::RequestClusterSecret.new.publish
+            {}
+          end
 
-    def receive_cluster_secret(message:, **opts)
-      log.debug 'receive_cluster_secret'
-      Legion::Settings[:crypt][:cluster_secret] = Legion::Crypt.decrypt_from_keypair(message)
-      Legion::Settings[:crypt][:encrypted_string] = opts[:encrypted_string]
-      Legion::Settings[:crypt][:validation_string] = opts[:validation_string]
-      {}
-    end
+          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
 
-    include Legion::Extensions::Helpers::Lex
+          def receive_cluster_secret(message:, **opts)
+            log.debug 'receive_cluster_secret'
+            Legion::Settings[:crypt][:cluster_secret] = Legion::Crypt.decrypt_from_keypair(message)
+            Legion::Settings[:crypt][:encrypted_string] = opts[:encrypted_string]
+            Legion::Settings[:crypt][:validation_string] = opts[:validation_string]
+            {}
+          end
+
+          include Legion::Extensions::Helpers::Lex
+        end
+      end
+    end
   end
 end

data/lib/legion/extensions/node/runners/node.rb

@@ -1,61 +1,118 @@
-module Legion::Extensions::Node::Runners
-  module Node
-    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
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Node
+      module Runners
+        module Node
+          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
-        end
-      end
-    end
 
-    def push_public_key(**_opts)
-      log.debug 'push_public_key'
-      message_hash = { function: 'update_public_key',
-                       public_key: Legion::Crypt.public_key.to_s,
-                       **Legion::Settings[:client] }
-      Legion::Extensions::Node::Transport::Messages::PublicKey.new(**message_hash).publish
-      {}
-    end
+          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'}"
 
-    def update_public_key(name:, public_key:, **_opts)
-      log.debug 'update_public_key'
-      Legion::Settings[:cluster][:public_keys][name] = public_key
-      {}
-    end
+            Gem.install(gem_name, version)
+            Legion.reload if reload
 
-    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
+            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
 
-    def receive_cluster_secret(message:, **_opts)
-      log.debug 'receive_cluster_secret'
-      Legion::Settings[:crypt][:cluster_secret] = Legion::Crypt.decrypt_from_keypair(message: message)
-      {}
-    end
+          def update_settings(settings:, restart: false, **_opts)
+            log.debug "update_settings: merging #{settings.keys.join(', ')}"
 
-    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
+            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
+
+          def push_public_key(**_opts)
+            log.debug 'push_public_key'
+            message_hash = { function:   'update_public_key',
+                             public_key: Legion::Crypt.public_key.to_s,
+                             **Legion::Settings[:client] }
+            Legion::Extensions::Node::Transport::Messages::PublicKey.new(**message_hash).publish
+            {}
+          end
 
-    include Legion::Extensions::Helpers::Lex
+          def update_public_key(name:, public_key:, **_opts)
+            log.debug 'update_public_key'
+            Legion::Settings[:cluster][:public_keys][name] = public_key
+            {}
+          end
+
+          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
+
+          def receive_cluster_secret(message:, **_opts)
+            log.debug 'receive_cluster_secret'
+            Legion::Settings[:crypt][:cluster_secret] = Legion::Crypt.decrypt_from_keypair(message: message)
+            {}
+          end
+
+          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
+
+          private
+
+          def publish_update_result(action:, status:, detail: nil, error: nil)
+            Legion::Extensions::Node::Transport::Messages::UpdateResult.new(
+              action:    action,
+              status:    status,
+              detail:    detail,
+              error:     error,
+              node:      Legion::Settings[:client][:name],
+              timestamp: Time.now.utc.iso8601
+            ).publish
+          end
+
+          include Legion::Extensions::Helpers::Lex
+        end
+      end
+    end
   end
 end

data/lib/legion/extensions/node/runners/vault.rb

@@ -1,40 +1,48 @@
-module Legion::Extensions::Node::Runners
-  module Vault
-    def request_token(**)
-      return {} if Legion::Settings[:crypt][:vault][:connected]
-      return {} unless Legion::Settings[:crypt][:vault][:enabled]
-
-      request_vault_token
-    end
-
-    def request_vault_token(**)
-      Legion::Extensions::Node::Transport::Messages::RequestVaultToken.new.publish
-      {}
-    end
-
-    def receive_vault_token(message:, **opts) # rubocop:disable Metrics/AbcSize
-      return if Legion::Settings[:crypt][:vault][:connected]
-
-      Legion::Settings[:crypt][:vault][:token] = Legion::Crypt.decrypt_from_keypair(message: message)
-      %i[protocol address port].each do |setting|
-        next unless opts.key? setting
-        next unless Legion::Settings[:crypt][:vault][setting].nil?
-
-        Legion::Settings[:crypt][:vault][setting] = opts[setting]
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Node
+      module Runners
+        module Vault
+          def request_token(**)
+            return {} if Legion::Settings[:crypt][:vault][:connected]
+            return {} unless Legion::Settings[:crypt][:vault][:enabled]
+
+            request_vault_token
+          end
+
+          def request_vault_token(**)
+            Legion::Extensions::Node::Transport::Messages::RequestVaultToken.new.publish
+            {}
+          end
+
+          def receive_vault_token(message:, **opts)
+            return if Legion::Settings[:crypt][:vault][:connected]
+
+            Legion::Settings[:crypt][:vault][:token] = Legion::Crypt.decrypt_from_keypair(message: message)
+            %i[protocol address port].each do |setting|
+              next unless opts.key? setting
+              next unless Legion::Settings[:crypt][:vault][setting].nil?
+
+              Legion::Settings[:crypt][:vault][setting] = opts[setting]
+            end
+            Legion::Crypt.connect_vault
+            {}
+          end
+
+          def push_vault_token(public_key:, node_name:, **)
+            return {} unless Legion::Settings[:crypt][:vault][:token]
+
+            encrypted = Legion::Crypt.encrypt_from_keypair(message: Legion::Settings[:crypt][:vault][:token],
+                                                           pub_key: public_key)
+            Legion::Extensions::Node::Transport::Messages::PushVaultToken.new(token: encrypted, queue_name: node_name).publish
+            {}
+          end
+
+          include Legion::Extensions::Helpers::Lex
+        end
       end
-      Legion::Crypt.connect_vault
-      {}
     end
-
-    def push_vault_token(public_key:, node_name:, **)
-      return {} unless Legion::Settings[:crypt][:vault][:token]
-
-      encrypted = Legion::Crypt.encrypt_from_keypair(message: Legion::Settings[:crypt][:vault][:token],
-                                                     pub_key: public_key)
-      Legion::Extensions::Node::Transport::Messages::PushVaultToken.new(token: encrypted, queue_name: node_name).publish
-      {}
-    end
-
-    include Legion::Extensions::Helpers::Lex
   end
 end

data/lib/legion/extensions/node/transport/exchanges/node.rb

@@ -1,11 +1,17 @@
+# frozen_string_literal: true
+
 require 'legion/transport/exchanges/node'
 
-module Legion::Extensions::Node
-  module Transport
-    module Exchanges
-      class Node < Legion::Transport::Exchanges::Node
-        def exchange_name
-          'node'
+module Legion
+  module Extensions
+    module Node
+      module Transport
+        module Exchanges
+          class Node < Legion::Transport::Exchanges::Node
+            def exchange_name
+              'node'
+            end
+          end
         end
       end
     end

data/lib/legion/extensions/node/transport/messages/beat.rb

@@ -1,31 +1,94 @@
-module Legion::Extensions::Node::Transport::Messages
-  class Beat < Legion::Transport::Message
-    def routing_key
-      'status'
-    end
+# frozen_string_literal: true
 
-    def type
-      'heartbeat'
-    end
+module Legion
+  module Extensions
+    module Node
+      module Transport
+        module Messages
+          class Beat < Legion::Transport::Message
+            def routing_key
+              'status'
+            end
 
-    def expiration
-      5000
-    end
+            def type
+              'heartbeat'
+            end
 
-    def encrypt?
-      false
-    end
+            def expiration
+              5000
+            end
 
-    def message
-      hash = { name: Legion::Settings[:client][:hostname], pid: Process.pid, timestamp: Time.now }
-      hash[:status] = @options[:status].nil? ? 'healthy' : @options[:status]
-      hash
-    end
+            def encrypt?
+              false
+            end
+
+            def message
+              hash = {
+                name:      Legion::Settings[:client][:hostname],
+                pid:       ::Process.pid,
+                timestamp: Time.now,
+                status:    @options[:status].nil? ? 'healthy' : @options[:status]
+              }
+              hash[:version] = Legion::VERSION if defined?(Legion::VERSION)
+              hash[:metrics] = collect_metrics
+              hash[:hosted_worker_ids] = collect_worker_ids
+              hash
+            end
+
+            def validate
+              raise 'status should be a string' unless @options[:status].is_a?(String) || @options[:status].nil?
+
+              @valid = true
+            end
+
+            private
+
+            def collect_metrics
+              times = ::Process.times
+              {
+                memory_rss_mb:      rss_mb,
+                cpu_user_seconds:   times.utime.round(2),
+                cpu_system_seconds: times.stime.round(2),
+                thread_count:       Thread.list.count,
+                loaded_extensions:  loaded_extension_count,
+                uptime_seconds:     uptime_seconds
+              }
+            end
+
+            def rss_mb
+              if RUBY_PLATFORM.include?('darwin')
+                `ps -o rss= -p #{::Process.pid}`.strip.to_i / 1024.0
+              else
+                File.read("/proc/#{::Process.pid}/statm").split[1].to_i * (4096.0 / 1_048_576)
+              end
+            rescue StandardError
+              0.0
+            end
+
+            def loaded_extension_count
+              return 0 unless defined?(Legion::Extensions)
+
+              Legion::Extensions.respond_to?(:loaded_extensions) ? Legion::Extensions.loaded_extensions.count : 0
+            end
+
+            def uptime_seconds
+              (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - boot_time).round(0)
+            end
+
+            def boot_time
+              @boot_time ||= ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            end
 
-    def validate
-      raise 'status should be a string' unless @options[:status].is_a?(String) || @options[:status].nil?
+            def collect_worker_ids
+              return [] unless defined?(Legion::DigitalWorker)
 
-      @valid = true
+              Legion::DigitalWorker.active_local_ids
+            rescue StandardError
+              []
+            end
+          end
+        end
+      end
     end
   end
 end