igniter 0.5.1 → 0.5.2

data/packages/igniter-app/lib/igniter/ignite/bootstrap_agent.rb

@@ -1,334 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "shellwords"
-require "igniter/agent"
-require "igniter/cluster/replication"
-
-module Igniter
-  module Ignite
-    class BootstrapAgent < Igniter::Agent
-      DEFAULT_REMOTE_STRATEGY = :tarball
-      DEFAULT_TARGET_PATH = "/opt/igniter"
-      BootstrapResult = ::Data.define(
-        :status,
-        :action,
-        :admission,
-        :join,
-        :bootstrap,
-        :bootstrap_error,
-        :host,
-        :port
-      )
-      DecommissionResult = ::Data.define(
-        :status,
-        :action,
-        :transport,
-        :acknowledged,
-        :error
-      )
-
-      on :bootstrap do |payload:, **|
-        intent = payload.fetch(:intent)
-        root_dir = File.expand_path(payload.fetch(:root_dir))
-        session_factory = payload[:session_factory]
-        bootstrapper_factory = payload[:bootstrapper_factory]
-
-        raise ArgumentError, "bootstrap requires an Igniter::Ignite::DeploymentIntent" unless intent.is_a?(DeploymentIntent)
-        raise ArgumentError, "bootstrap only supports ssh_server targets" unless intent.ssh_server?
-
-        config_path = resolve_config_path(root_dir, intent.target.locator.fetch("config_path"))
-        target_config = load_target_config(config_path)
-        session = build_session(target_config, session_factory)
-        raise Igniter::Cluster::Replication::SSHSession::SSHError, "SSH connectivity test failed" unless session.test_connection
-
-        strategy = normalize_strategy(target_config, intent)
-        bootstrapper = build_bootstrapper(strategy, target_config, bootstrapper_factory)
-        target_path = target_config["target_path"] || DEFAULT_TARGET_PATH
-        manifest = Igniter::Cluster::Replication::Manifest.current
-        environment = build_remote_environment(intent, target_config)
-
-        bootstrapper.install(
-          session: session,
-          manifest: manifest,
-          env: environment,
-          target_path: target_path
-        )
-        bootstrapper.start(
-          session: session,
-          manifest: manifest,
-          target_path: target_path
-        )
-
-        verified = bootstrapper.verify(session: session, target_path: target_path)
-        raise Igniter::Cluster::Replication::Bootstrapper::BootstrapError, "remote bootstrap verification failed" unless verified
-
-        BootstrapResult.new(
-          status: :bootstrapped,
-          action: :await_remote_join,
-          bootstrap: {
-            strategy: strategy,
-            target_path: target_path,
-            host: target_config.fetch("host"),
-            user: target_config.fetch("user"),
-            port: target_config.fetch("port", 22),
-            config_path: config_path,
-            verified: verified
-          },
-          host: target_config.fetch("host"),
-          port: target_config.fetch("port", 22),
-          admission: nil,
-          join: {
-            required: true,
-            status: :awaiting_join
-          },
-          bootstrap_error: nil
-        )
-      rescue Igniter::Cluster::Replication::SSHSession::SSHError,
-             Igniter::Cluster::Replication::Bootstrapper::BootstrapError,
-             ArgumentError,
-             Errno::ENOENT,
-             Psych::SyntaxError => e
-        BootstrapResult.new(
-          status: :blocked,
-          action: :remote_bootstrap_failed,
-          admission: {
-            required: true,
-            status: :blocked
-          },
-          join: {
-            required: true,
-            status: :blocked
-          },
-          bootstrap_error: "#{e.class}: #{e.message}",
-          bootstrap: nil,
-          host: nil,
-          port: nil
-        )
-      end
-
-      on :detach do |payload:, **|
-        decommission(payload, mode: :detach)
-      end
-
-      on :teardown do |payload:, **|
-        decommission(payload, mode: :teardown)
-      end
-
-      class << self
-        private
-
-        def decommission(payload, mode:)
-          entry = Hash(payload.fetch(:entry))
-          root_dir = payload[:root_dir] && File.expand_path(payload[:root_dir])
-          session_factory = payload[:session_factory]
-
-          raise ArgumentError, "#{mode} only supports ssh_server targets" unless entry.fetch(:kind).to_sym == :ssh_server
-
-          config_path = resolve_target_config_path(entry, root_dir)
-          target_config = load_target_config(config_path)
-          session = build_session(target_config, session_factory)
-          raise Igniter::Cluster::Replication::SSHSession::SSHError, "SSH connectivity test failed" unless session.test_connection
-
-          target_path = entry.dig(:bootstrap, :target_path) || target_config["target_path"] || DEFAULT_TARGET_PATH
-          drain_command = decommission_drain_command(mode, target_path, target_config)
-          command = decommission_command(mode, target_path, target_config)
-          verification_command = decommission_verification_command(target_path, target_config)
-          run_drain!(session, drain_command) if drain_command
-          session.exec!(command)
-          acknowledged = wait_for_shutdown_ack!(
-            session,
-            verification_command,
-            timeout: target_config.fetch("shutdown_timeout", 10),
-            poll_interval: target_config.fetch("shutdown_poll_interval", 0.5)
-          )
-
-          DecommissionResult.new(
-            status: mode == :detach ? :detached : :torn_down,
-            action: mode == :detach ? :remote_detached : :remote_torn_down,
-            transport: {
-              host: target_config.fetch("host"),
-              port: target_config.fetch("port", 22),
-              config_path: config_path,
-              target_path: target_path,
-              drain_command: drain_command,
-              command: command,
-              verification_command: verification_command,
-              verified_shutdown: acknowledged
-            },
-            acknowledged: acknowledged,
-            error: nil
-          )
-        rescue Igniter::Cluster::Replication::SSHSession::SSHError,
-               ArgumentError,
-               Errno::ENOENT,
-               Psych::SyntaxError => e
-          DecommissionResult.new(
-            status: :blocked,
-            action: mode == :detach ? :remote_detach_failed : :remote_teardown_failed,
-            transport: nil,
-            acknowledged: false,
-            error: "#{e.class}: #{e.message}"
-          )
-        end
-
-        def resolve_config_path(root_dir, config_path)
-          candidate = File.expand_path(config_path.to_s, root_dir)
-          return candidate if File.exist?(candidate)
-
-          raise Errno::ENOENT, candidate
-        end
-
-        def resolve_target_config_path(entry, root_dir)
-          bootstrap_path = entry.dig(:bootstrap, :config_path)
-          return bootstrap_path if bootstrap_path && File.exist?(bootstrap_path)
-
-          locator_path = entry.dig(:locator, "config_path") || entry.dig(:locator, :config_path)
-          raise ArgumentError, "remote ignition target does not have a config_path" unless locator_path
-          raise ArgumentError, "remote ignition target requires root_dir to resolve config_path" unless root_dir
-
-          resolve_config_path(root_dir, locator_path)
-        end
-
-        def load_target_config(path)
-          config = YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
-          hash = Hash(config)
-
-          {
-            "host" => hash.fetch("host"),
-            "user" => hash.fetch("user"),
-            "port" => hash.fetch("port", 22),
-            "key" => hash["key"],
-            "strategy" => hash["strategy"],
-            "target_path" => hash["target_path"],
-            "detach_command" => hash["detach_command"],
-            "teardown_command" => hash["teardown_command"],
-            "drain_command" => hash["drain_command"],
-            "shutdown_check_command" => hash["shutdown_check_command"],
-            "shutdown_timeout" => hash["shutdown_timeout"],
-            "shutdown_poll_interval" => hash["shutdown_poll_interval"],
-            "env" => Hash(hash["env"] || {}),
-            "bootstrapper_options" => Hash(hash["bootstrapper_options"] || {})
-          }
-        end
-
-        def build_session(target_config, session_factory)
-          factory = session_factory || method(:default_session_factory)
-          factory.call(
-            host: target_config.fetch("host"),
-            user: target_config.fetch("user"),
-            key: target_config["key"],
-            port: target_config.fetch("port", 22)
-          )
-        end
-
-        def default_session_factory(host:, user:, key:, port:)
-          Igniter::Cluster::Replication::SSHSession.new(
-            host: host,
-            user: user,
-            key: key,
-            port: port
-          )
-        end
-
-        def normalize_strategy(target_config, intent)
-          (target_config["strategy"] ||
-            intent.target.bootstrap_requirements["strategy"] ||
-            DEFAULT_REMOTE_STRATEGY).to_sym
-        end
-
-        def build_bootstrapper(strategy, target_config, bootstrapper_factory)
-          factory = bootstrapper_factory || method(:default_bootstrapper_factory)
-          factory.call(strategy, **Hash(target_config["bootstrapper_options"] || {}))
-        end
-
-        def default_bootstrapper_factory(strategy, **options)
-          Igniter::Cluster::Replication.bootstrapper_for(strategy, **options)
-        end
-
-        def build_remote_environment(intent, target_config)
-          env = Hash(target_config["env"] || {}).each_with_object({}) do |(key, value), result|
-            result[key.to_s] = value.to_s
-          end
-
-          env["IGNITER_IGNITE_TARGET"] = intent.target.id
-          env["IGNITER_IGNITE_INTENT"] = intent.id
-          env["IGNITER_IGNITE_MODE"] = intent.ignite_mode.to_s
-          env["IGNITER_ENV"] ||= intent.requested_from["environment"].to_s unless intent.requested_from["environment"].to_s.empty?
-          env["PORT"] ||= intent.target.base_server["port"].to_s if intent.target.base_server["port"]
-
-          seed_host = intent.seed_node["host"]
-          seed_port = intent.seed_node["port"]
-          if seed_host && seed_port
-            env["IGNITER_CLUSTER_SEED_URL"] ||= "http://#{seed_host}:#{seed_port}"
-          end
-
-          env
-        end
-
-        def decommission_command(mode, target_path, target_config)
-          configured =
-            case mode
-            when :detach
-              target_config["detach_command"]
-            when :teardown
-              target_config["teardown_command"]
-            end
-          return configured if configured && !configured.to_s.empty?
-
-          pid_path = Shellwords.escape("#{target_path}/igniter.pid")
-          escaped_target = Shellwords.escape(target_path)
-          stop_clause = "if [ -f #{pid_path} ]; then kill $(cat #{pid_path}) 2>/dev/null || true; rm -f #{pid_path}; else pkill -f #{escaped_target} 2>/dev/null || pkill -f \"igniter-stack|ruby stack.rb\" 2>/dev/null || true; fi"
-
-          case mode
-          when :detach
-            "sh -lc '#{stop_clause}'"
-          when :teardown
-            "sh -lc '#{stop_clause}; rm -rf #{escaped_target}'"
-          else
-            raise ArgumentError, "unsupported decommission mode #{mode.inspect}"
-          end
-        end
-
-        def decommission_drain_command(_mode, _target_path, target_config)
-          configured = target_config["drain_command"]
-          return nil unless configured && !configured.to_s.empty?
-
-          configured
-        end
-
-        def decommission_verification_command(target_path, target_config)
-          configured = target_config["shutdown_check_command"]
-          return configured if configured && !configured.to_s.empty?
-
-          pid_path = Shellwords.escape("#{target_path}/igniter.pid")
-          escaped_target = Shellwords.escape(target_path)
-          "sh -lc 'if [ -f #{pid_path} ]; then pid=$(cat #{pid_path} 2>/dev/null || true); if [ -n \"$pid\" ] && kill -0 \"$pid\" 2>/dev/null; then exit 1; fi; fi; pgrep -f #{escaped_target} >/dev/null 2>&1 && exit 1; exit 0'"
-        end
-
-        def run_drain!(session, command)
-          session.exec!(command)
-        end
-
-        def wait_for_shutdown_ack!(session, verification_command, timeout:, poll_interval:)
-          deadline = Time.now + timeout.to_f
-          interval = [poll_interval.to_f, 0.01].max
-
-          loop do
-            result =
-              if session.respond_to?(:exec)
-                session.exec(verification_command)
-              else
-                { success: true, stdout: "", stderr: "", exit_code: 0 }
-              end
-
-            return true if result[:success]
-            raise Igniter::Cluster::Replication::SSHSession::SSHError, "remote shutdown verification failed: #{result[:stderr]}".strip if Time.now >= deadline
-
-            sleep interval
-          end
-        end
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/ignite/bootstrap_target.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Ignite
-    class BootstrapTarget
-      KINDS = %i[local_replica ssh_server].freeze
-
-      attr_reader :id, :kind, :locator, :base_server, :capability_intent, :bootstrap_requirements, :metadata
-
-      def initialize(id:, kind:, locator:, base_server:, capability_intent: [], bootstrap_requirements: {}, metadata: {})
-        @id = id.to_s.strip
-        @kind = kind.to_sym
-        @locator = immutable_hash(locator)
-        @base_server = immutable_hash(base_server)
-        @capability_intent = Array(capability_intent).map(&:to_sym).freeze
-        @bootstrap_requirements = immutable_hash(bootstrap_requirements)
-        @metadata = immutable_hash(metadata)
-
-        validate!
-        freeze
-      end
-
-      def local_replica?
-        kind == :local_replica
-      end
-
-      def ssh_server?
-        kind == :ssh_server
-      end
-
-      def server_settings
-        return base_server unless local_replica?
-
-        base_server.merge(extract_server_overrides(locator)).freeze
-      end
-
-      def to_h
-        {
-          id: id,
-          kind: kind,
-          locator: locator,
-          base_server: base_server,
-          capability_intent: capability_intent,
-          bootstrap_requirements: bootstrap_requirements,
-          metadata: metadata
-        }
-      end
-
-      private
-
-      def validate!
-        raise ArgumentError, "bootstrap target id cannot be empty" if id.empty?
-        raise ArgumentError, "unknown bootstrap target kind #{kind.inspect}" unless KINDS.include?(kind)
-      end
-
-      def extract_server_overrides(hash)
-        hash.each_with_object({}) do |(key, value), result|
-          next unless %w[host port].include?(key)
-
-          result[key] = value
-        end
-      end
-
-      def immutable_hash(hash)
-        Hash(hash).each_with_object({}) do |(key, value), result|
-          result[key.to_s] =
-            case value
-            when Hash
-              immutable_hash(value)
-            when Array
-              value.map { |item| item.is_a?(Hash) ? immutable_hash(item) : item }.freeze
-            else
-              value
-            end
-        end.freeze
-      end
-    end
-  end
-end

data/packages/igniter-app/lib/igniter/ignite/deployment_intent.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Ignite
-    class DeploymentIntent
-      IGNITE_MODES = %i[cold_start expand].freeze
-      STRATEGIES = %i[serial parallel].freeze
-      APPROVAL_MODES = %i[required auto].freeze
-
-      attr_reader :id, :ignite_mode, :strategy, :approval_mode, :target, :requested_capabilities,
-                  :requested_by, :requested_from, :seed_node, :join_policy, :correlation, :metadata
-
-      def initialize(id:, ignite_mode:, strategy:, approval_mode:, target:, requested_capabilities: [],
-                     requested_by:, requested_from:, seed_node:, join_policy:, correlation:, metadata: {})
-        @id = id.to_s.strip
-        @ignite_mode = ignite_mode.to_sym
-        @strategy = strategy.to_sym
-        @approval_mode = approval_mode.to_sym
-        @target = target
-        @requested_capabilities = Array(requested_capabilities).map(&:to_sym).freeze
-        @requested_by = immutable_hash(requested_by)
-        @requested_from = immutable_hash(requested_from)
-        @seed_node = immutable_hash(seed_node)
-        @join_policy = immutable_hash(join_policy)
-        @correlation = immutable_hash(correlation)
-        @metadata = immutable_hash(metadata)
-
-        validate!
-        freeze
-      end
-
-      def local_replica?
-        target.local_replica?
-      end
-
-      def ssh_server?
-        target.ssh_server?
-      end
-
-      def to_h
-        {
-          id: id,
-          ignite_mode: ignite_mode,
-          strategy: strategy,
-          approval_mode: approval_mode,
-          target: target.to_h,
-          requested_capabilities: requested_capabilities,
-          requested_by: requested_by,
-          requested_from: requested_from,
-          seed_node: seed_node,
-          join_policy: join_policy,
-          correlation: correlation,
-          metadata: metadata
-        }
-      end
-
-      private
-
-      def validate!
-        raise ArgumentError, "deployment intent id cannot be empty" if id.empty?
-        raise ArgumentError, "unknown ignite mode #{ignite_mode.inspect}" unless IGNITE_MODES.include?(ignite_mode)
-        raise ArgumentError, "unknown ignite strategy #{strategy.inspect}" unless STRATEGIES.include?(strategy)
-        raise ArgumentError, "unknown approval mode #{approval_mode.inspect}" unless APPROVAL_MODES.include?(approval_mode)
-        raise ArgumentError, "deployment intent target must be an Igniter::Ignite::BootstrapTarget" unless target.is_a?(BootstrapTarget)
-      end
-
-      def immutable_hash(hash)
-        Hash(hash).each_with_object({}) do |(key, value), result|
-          result[key.to_s] =
-            case value
-            when Hash
-              immutable_hash(value)
-            when Array
-              value.map { |item| item.is_a?(Hash) ? immutable_hash(item) : item }.freeze
-            else
-              value
-            end
-        end.freeze
-      end
-    end
-  end
-end