lex-node 0.2.0 → 0.3.0

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 heartbeat'
+            messages::Beat.new(status: status).publish
+            { success: true, status: status, version: defined?(Legion::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/node.rb

@@ -1,61 +1,141 @@
-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
+
+require 'base64'
+
+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: Base64.encode64(Legion::Crypt.public_key),
+                             **Legion::Settings[:client] }
+            Legion::Extensions::Node::Transport::Messages::PublicKey.new(message_hash).publish
+            {}
+          end
+
+          def update_public_key(name:, public_key:, **_opts)
+            log.debug 'update_public_key'
+            Legion::Settings[:cluster][:public_keys][name] = public_key
+            {}
+          end
 
-    include Legion::Extensions::Helpers::Lex
+          def delete_public_key(name:, **_opts)
+            log.debug 'delete_public_key'
+            Legion::Settings[:cluster][:public_keys].delete(name)
+            {}
+          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 request_cluster_secret(**_opts)
+            log.debug 'request_cluster_secret'
+            Legion::Extensions::Node::Transport::Messages::RequestClusterSecret.new.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 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
+
+          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,56 @@
-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: nil, token: nil, cluster_name: nil, **opts)
+            return { success: false, already_connected: true } if Legion::Settings[:crypt][:vault][:connected]
+
+            token ||= Legion::Crypt.decrypt_from_keypair(message: message)
+            clusters = Legion::Settings[:crypt][:vault][:clusters]
+            if cluster_name && clusters.is_a?(Hash) && clusters[cluster_name.to_sym]
+              clusters[cluster_name.to_sym][:token] = token
+              clusters[cluster_name.to_sym][:connected] = true
+              return { success: true }
+            end
+
+            Legion::Settings[:crypt][:vault][:token] = token
+            %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,91 @@
-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
+            BOOT_TIME = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            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][:name],
+                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 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

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

@@ -1,21 +1,31 @@
-module Legion::Extensions::Node::Transport::Messages
-  class PublicKey < Legion::Transport::Message
-    def routing_key
-      'node.crypt.update_public_key'
-    end
+# frozen_string_literal: true
 
-    def type
-      'task'
-    end
+module Legion
+  module Extensions
+    module Node
+      module Transport
+        module Messages
+          class PublicKey < Legion::Transport::Message
+            def routing_key
+              'node.crypt.update_public_key'
+            end
 
-    def encrypt?
-      false
-    end
+            def type
+              'task'
+            end
+
+            def encrypt?
+              false
+            end
 
-    def validate
-      raise 'public_key should be a string' unless @options[:public_key].is_a?(String)
+            def validate
+              raise 'public_key should be a string' unless @options[:public_key].is_a?(String)
 
-      @valid = true
+              @valid = true
+            end
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,32 +1,42 @@
-module Legion::Extensions::Node::Transport::Messages
-  class PushClusterSecret < Legion::Transport::Message
-    def routing_key
-      @options[:queue_name]
-    end
+# frozen_string_literal: true
 
-    def exchange
-      Legion::Transport::Exchanges::Node
-    end
+module Legion
+  module Extensions
+    module Node
+      module Transport
+        module Messages
+          class PushClusterSecret < Legion::Transport::Message
+            def routing_key
+              @options[:queue_name]
+            end
 
-    def message
-      { function: 'receive_cluster_secret',
-        runner_class: 'Legion::Extensions::Node::Runners::Crypt',
-        message: @options[:message],
-        validation_string: @options[:validation_string] || nil,
-        encrypted_string: @options[:encrypted_string] || nil,
-        public_key: Base64.encode64(Legion::Crypt.public_key) }
-    end
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
 
-    def type
-      'task'
-    end
+            def message
+              { function:          'receive_cluster_secret',
+                runner_class:      'Legion::Extensions::Node::Runners::Crypt',
+                message:           @options[:message],
+                validation_string: @options[:validation_string],
+                encrypted_string:  @options[:encrypted_string],
+                public_key:        Base64.encode64(Legion::Crypt.public_key) }
+            end
 
-    def encrypt?
-      false
-    end
+            def type
+              'task'
+            end
+
+            def encrypt?
+              false
+            end
 
-    def validate
-      @valid = true
+            def validate
+              @valid = true
+            end
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,32 +1,42 @@
-module Legion::Extensions::Node::Transport::Messages
-  class PushVaultToken < Legion::Transport::Message
-    def routing_key
-      "node.#{@options[:queue_name]}"
-    end
+# frozen_string_literal: true
 
-    def exchange
-      Legion::Transport::Exchanges::Node
-    end
+module Legion
+  module Extensions
+    module Node
+      module Transport
+        module Messages
+          class PushVaultToken < Legion::Transport::Message
+            def routing_key
+              "node.#{@options[:queue_name]}"
+            end
 
-    def message
-        {
-          function: 'receive_vault_token',
-          runner_class: 'Legion::Extensions::Node::Runners::Vault',
-          message: @options[:token],
-          public_key: Base64.encode64(Legion::Crypt.public_key)
-        }
-    end
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
 
-    def type
-      'task'
-    end
+            def message
+              {
+                function:     'receive_vault_token',
+                runner_class: 'Legion::Extensions::Node::Runners::Vault',
+                message:      @options[:token],
+                public_key:   Base64.encode64(Legion::Crypt.public_key)
+              }
+            end
 
-    def encrypt?
-      false
-    end
+            def type
+              'task'
+            end
+
+            def encrypt?
+              false
+            end
 
-    def validate
-      @valid = true
+            def validate
+              @valid = true
+            end
+          end
+        end
+      end
     end
   end
 end