lex-node 0.1.7 → 0.2.3

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

@@ -1,27 +1,35 @@
-module Legion::Extensions::Node::Actor
-  class PushKey < Legion::Extensions::Actors::Once
-    def function
-      'request_public_keys'
-    end
+# frozen_string_literal: true
 
-    def runner_class
-      Legion::Extensions::Node::Runners::Crypt
-    end
+module Legion
+  module Extensions
+    module Node
+      module Actor
+        class PushKey < Legion::Extensions::Actors::Once
+          def function
+            'request_public_keys'
+          end
 
-    def disabled?
-      false
-    end
+          def runner_class
+            Legion::Extensions::Node::Runners::Crypt
+          end
 
-    def use_runner?
-      true
-    end
+          def disabled?
+            false
+          end
 
-    def check_subtask?
-      false
-    end
+          def use_runner?
+            true
+          end
+
+          def check_subtask?
+            false
+          end
 
-    def generate_task?
-      false
+          def generate_task?
+            false
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,27 +1,35 @@
-module Legion::Extensions::Node::Actor
-  class Vault < Legion::Extensions::Actors::Subscription
-    # def delay_start
-    #   2
-    # end
+# frozen_string_literal: true
 
-    def runner_class
-      Legion::Extensions::Node::Runners::Vault
-    end
+module Legion
+  module Extensions
+    module Node
+      module Actor
+        class Vault < Legion::Extensions::Actors::Subscription
+          # def delay_start
+          #   2
+          # end
 
-    def disabled?
-      false
-    end
+          def runner_class
+            Legion::Extensions::Node::Runners::Vault
+          end
 
-    def use_runner?
-      true
-    end
+          def disabled?
+            false
+          end
 
-    def check_subtask?
-      false
-    end
+          def use_runner?
+            true
+          end
+
+          def check_subtask?
+            false
+          end
 
-    def generate_task?
-      false
+          def generate_task?
+            false
+          end
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    run "CREATE TABLE `nodes` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `name` varchar(128) NOT NULL DEFAULT '',
+  `datacenter_id` int(11) unsigned DEFAULT NULL,
+  `environment_id` int(11) unsigned DEFAULT NULL,
+  `status` varchar(255) NOT NULL DEFAULT 'unknown',
+  `active` tinyint(1) unsigned NOT NULL DEFAULT '1',
+  `created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `name` (`name`),
+  KEY `active` (`active`),
+  KEY `status` (`status`),
+  KEY `node_datacenter_id` (`datacenter_id`),
+  KEY `node_environment_id` (`environment_id`),
+  CONSTRAINT `node_datacenter_id` FOREIGN KEY (`datacenter_id`) REFERENCES `datacenters` (`id`) ON DELETE SET NULL ON UPDATE CASCADE,
+  CONSTRAINT `node_environment_id` FOREIGN KEY (`environment_id`) REFERENCES `environments` (`id`) ON DELETE SET NULL ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;"
+  end
+
+  down do
+    drop_table :nodes
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    run "
+    create table node_history
+    (
+      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+      node_id int(11) unsigned not null,
+      previous_staus varchar(255) null,
+      status varchar(255) default active not null,
+      `modified_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      `record_created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      modified_by varchar(255) default 'node' not null,
+      PRIMARY KEY (`id`),
+      KEY `node_id` (`node_id`),
+      KEY `status` (`status`),
+      KEY `status` (`previous_status`),
+      CONSTRAINT `node_id` FOREIGN KEY (`nodes`) REFERENCES `nodes` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+    );
+    "
+  end
+
+  down do
+    drop_table :node_history
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    alter_table(:nodes) do
+      add_column :version, String, null: true
+      add_index :nodes_version, :version
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    run "
+    create table node_extensions
+    (
+      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+      node_id int(11) unsigned not null,
+      extension_id int(11) unsigned not null,
+      `record_created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (`id`),
+      KEY `node_id` (`node_id`),
+      KEY `version` (`version`),
+      CONSTRAINT `node_id` FOREIGN KEY (`nodes`) REFERENCES `nodes` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+      CONSTRAINT `extension_id` FOREIGN KEY (`extensions`) REFERENCES `extensions` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+    );
+    "
+  end
+
+  down 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: 'healthy', **opts)
-      log.debug 'sending hearbeat'
-      messages::Beat.new(status: status).publish
-      { success: true, status: status, **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