odysseus-core 0.1.0

data/lib/odysseus/deployer/executor.rb

@@ -0,0 +1,389 @@
+# lib/odysseus/deployer/executor.rb
+
+module Odysseus
+  module Deployer
+    class Executor
+      WEB_ROLE = :web
+
+      # @param config_path [String] path to deploy.yml
+      # @param verbose [Boolean] show commands being executed
+      def initialize(config_path, verbose: false)
+        @config_path = config_path
+        @config_dir = File.dirname(config_path)
+        parser = Odysseus::Config::Parser.new(config_path)
+        @config = parser.parse
+        @verbose = verbose
+        @secrets_loader = Odysseus::Secrets::Loader.new(@config, config_dir: @config_dir)
+      end
+
+      # Build Docker image
+      # @param image_tag [String] docker image tag (e.g., "v1.0.0")
+      # @param push [Boolean] push to registry after build
+      # @param context_path [String] path to build context (defaults to config directory)
+      # @return [Hash] build result
+      def build(image_tag:, push: false, context_path: nil)
+        context = context_path || resolve_build_context
+        full_image = "#{@config[:image]}:#{image_tag}"
+
+        builder = build_builder
+
+        if push
+          builder.build_and_push(
+            context_path: context,
+            image: full_image,
+            registry: @config[:registry]
+          )
+        else
+          builder.build(context_path: context, image: full_image)
+        end
+      end
+
+      # Build and deploy in one step
+      # @param image_tag [String] docker image tag
+      # @param context_path [String] path to build context
+      # @param dry_run [Boolean] if true, don't actually deploy
+      # @return [Hash] results
+      def build_and_deploy(image_tag:, context_path: nil, dry_run: false)
+        # First, build the image
+        build_result = build(image_tag: image_tag, push: true, context_path: context_path)
+
+        unless build_result[:success]
+          return { build: build_result, deploy: nil, success: false }
+        end
+
+        # Then deploy
+        deploy_results = deploy_all(image_tag: image_tag, dry_run: dry_run)
+
+        {
+          build: build_result,
+          deploy: deploy_results,
+          success: deploy_results.values.all? { |r| r[:success] }
+        }
+      end
+
+      # Push image to all configured hosts via SSH (using docker pussh)
+      # @param image_tag [String] docker image tag
+      # @return [Hash] pussh results
+      def pussh(image_tag:)
+        full_image = "#{@config[:image]}:#{image_tag}"
+        hosts = collect_all_hosts
+
+        if hosts.empty?
+          return { success: false, error: "No hosts configured" }
+        end
+
+        builder = build_builder
+        builder.pussh_to_hosts(
+          image: full_image,
+          hosts: hosts,
+          user: @config[:ssh][:user]
+        )
+      end
+
+      # Build and pussh to all hosts (no registry needed)
+      # @param image_tag [String] docker image tag
+      # @param context_path [String] path to build context
+      # @return [Hash] build and pussh results
+      def build_and_pussh(image_tag:, context_path: nil)
+        # First, build the image locally
+        build_result = build(image_tag: image_tag, push: false, context_path: context_path)
+
+        unless build_result[:success]
+          return { build: build_result, pussh: nil, success: false }
+        end
+
+        # Then pussh to all hosts
+        pussh_result = pussh(image_tag: image_tag)
+
+        {
+          build: build_result,
+          pussh: pussh_result,
+          success: pussh_result[:success]
+        }
+      end
+
+      # Build and distribute image based on config
+      # Uses registry if configured, otherwise pussh to hosts
+      # @param image_tag [String] docker image tag
+      # @param context_path [String] path to build context
+      # @return [Hash] build and distribution results
+      def build_and_distribute(image_tag:, context_path: nil)
+        if uses_registry?
+          build_and_push_to_registry(image_tag: image_tag, context_path: context_path)
+        else
+          build_and_pussh(image_tag: image_tag, context_path: context_path)
+        end
+      end
+
+      # Check if config uses a registry for image distribution
+      # @return [Boolean]
+      def uses_registry?
+        @config[:registry] && @config[:registry][:server]
+      end
+
+      # Build and push to registry
+      # @param image_tag [String] docker image tag
+      # @param context_path [String] path to build context
+      # @return [Hash] build and push results
+      def build_and_push_to_registry(image_tag:, context_path: nil)
+        build_result = build(image_tag: image_tag, push: true, context_path: context_path)
+
+        {
+          build: build_result,
+          push: build_result[:pushed] ? { success: true } : { success: false },
+          success: build_result[:success] && build_result[:pushed]
+        }
+      end
+
+      # Deploy all roles to their configured hosts
+      # @param image_tag [String] docker image tag
+      # @param dry_run [Boolean] if true, don't actually deploy
+      def deploy_all(image_tag:, dry_run: false)
+        results = {}
+
+        @config[:servers].each do |role, role_config|
+          hosts = resolve_hosts(role_config)
+          hosts.each do |host|
+            puts "\n=== Deploying #{role} to #{host} ==="
+            results["#{role}@#{host}"] = deploy_role(host: host, image_tag: image_tag, dry_run: dry_run, role: role)
+          end
+        end
+
+        results
+      end
+
+      # Deploy a single role to a specific host
+      # @param host [String] target host (from config)
+      # @param image_tag [String] docker image tag (e.g., "v1.2.3")
+      # @param dry_run [Boolean] if true, don't actually deploy
+      # @param role [Symbol] server role
+      def deploy_role(host:, image_tag:, dry_run: false, role:)
+        if dry_run
+          puts "Dry run - would deploy #{@config[:image]}:#{image_tag} to #{host}"
+          puts "Service: #{@config[:service]}"
+          puts "Role: #{role}"
+          if role == WEB_ROLE
+            puts "Proxy hosts: #{@config[:proxy][:hosts].join(', ')}"
+          end
+          return { success: true, dry_run: true }
+        end
+
+        ssh = connect_to_server(host)
+
+        begin
+          orchestrator = build_orchestrator(ssh, role)
+          orchestrator.deploy(image_tag: image_tag, role: role)
+        ensure
+          ssh.close
+        end
+      end
+
+      # Deploy an accessory to all its configured hosts
+      # @param name [Symbol] accessory name
+      def deploy_accessory(name:)
+        acc_config = get_accessory_config(name)
+        hosts = acc_config[:hosts] || []
+
+        raise Odysseus::ConfigError, "No hosts configured for accessory #{name}" if hosts.empty?
+
+        results = {}
+        hosts.each do |host|
+          puts "Deploying accessory #{name} to #{host}..."
+          ssh = connect_to_server(host)
+
+          begin
+            orchestrator = Odysseus::Orchestrator::AccessoryDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+            results[host] = orchestrator.deploy(name: name.to_sym)
+          ensure
+            ssh.close
+          end
+        end
+        results
+      end
+
+      # Remove an accessory from all its configured hosts
+      # @param name [Symbol] accessory name
+      def remove_accessory(name:)
+        acc_config = get_accessory_config(name)
+        hosts = acc_config[:hosts] || []
+
+        raise Odysseus::ConfigError, "No hosts configured for accessory #{name}" if hosts.empty?
+
+        results = {}
+        hosts.each do |host|
+          puts "Removing accessory #{name} from #{host}..."
+          ssh = connect_to_server(host)
+
+          begin
+            orchestrator = Odysseus::Orchestrator::AccessoryDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+            results[host] = orchestrator.remove(name: name.to_sym)
+          ensure
+            ssh.close
+          end
+        end
+        results
+      end
+
+      # Restart an accessory on all its configured hosts
+      # @param name [Symbol] accessory name
+      def restart_accessory(name:)
+        acc_config = get_accessory_config(name)
+        hosts = acc_config[:hosts] || []
+
+        raise Odysseus::ConfigError, "No hosts configured for accessory #{name}" if hosts.empty?
+
+        results = {}
+        hosts.each do |host|
+          puts "Restarting accessory #{name} on #{host}..."
+          ssh = connect_to_server(host)
+
+          begin
+            orchestrator = Odysseus::Orchestrator::AccessoryDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+            results[host] = orchestrator.restart(name: name.to_sym)
+          ensure
+            ssh.close
+          end
+        end
+        results
+      end
+
+      # Upgrade an accessory to a new image version on all its configured hosts
+      # @param name [Symbol] accessory name
+      def upgrade_accessory(name:)
+        acc_config = get_accessory_config(name)
+        hosts = acc_config[:hosts] || []
+
+        raise Odysseus::ConfigError, "No hosts configured for accessory #{name}" if hosts.empty?
+
+        results = {}
+        hosts.each do |host|
+          puts "Upgrading accessory #{name} on #{host}..."
+          ssh = connect_to_server(host)
+
+          begin
+            orchestrator = Odysseus::Orchestrator::AccessoryDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+            results[host] = orchestrator.upgrade(name: name.to_sym)
+          ensure
+            ssh.close
+          end
+        end
+        results
+      end
+
+      # List accessory status on all configured hosts
+      def accessory_status
+        return [] unless @config[:accessories]&.any?
+
+        all_statuses = []
+        @config[:accessories].each do |name, acc_config|
+          hosts = acc_config[:hosts] || []
+          hosts.each do |host|
+            ssh = connect_to_server(host)
+            begin
+              orchestrator = Odysseus::Orchestrator::AccessoryDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+              status = orchestrator.get_status(name: name.to_sym)
+              status[:host] = host
+              all_statuses << status
+            ensure
+              ssh.close
+            end
+          end
+        end
+        all_statuses
+      end
+
+      # Boot all accessories to their configured hosts
+      def boot_accessories
+        return {} unless @config[:accessories]&.any?
+
+        results = {}
+        @config[:accessories].each_key do |name|
+          puts "\n=== Booting accessory: #{name} ==="
+          results[name] = deploy_accessory(name: name)
+        end
+        results
+      end
+
+      private
+
+      def get_accessory_config(name)
+        name_sym = name.to_sym
+        acc_config = @config[:accessories]&.[](name_sym)
+        raise Odysseus::ConfigError, "Accessory '#{name}' not found in config" unless acc_config
+        acc_config
+      end
+
+      def build_orchestrator(ssh, role)
+        logger = build_logger
+        if role == WEB_ROLE
+          Odysseus::Orchestrator::WebDeploy.new(
+            ssh: ssh, config: @config, logger: logger, secrets_loader: @secrets_loader
+          )
+        else
+          Odysseus::Orchestrator::JobDeploy.new(
+            ssh: ssh, config: @config, logger: logger, secrets_loader: @secrets_loader
+          )
+        end
+      end
+
+      def build_logger
+        verbose = @verbose
+        Object.new.tap do |l|
+          l.define_singleton_method(:info) { |msg| puts msg }
+          l.define_singleton_method(:warn) { |msg| puts "[WARN] #{msg}" }
+          l.define_singleton_method(:error) { |msg| puts "[ERROR] #{msg}" }
+          l.define_singleton_method(:debug) { |msg| puts "  > #{msg}" if verbose }
+          l.define_singleton_method(:verbose?) { verbose }
+        end
+      end
+
+      def connect_to_server(server)
+        Odysseus::Deployer::SSH.new(
+          host: server,
+          user: @config[:ssh][:user],
+          keys: @config[:ssh][:keys],
+          use_tailscale: true,
+          verbose: @verbose
+        )
+      end
+
+      def build_builder
+        Odysseus::Builder::Client.new(
+          config: @config[:builder],
+          ssh_config: @config[:ssh],
+          logger: build_logger,
+          verbose: @verbose
+        )
+      end
+
+      def resolve_build_context
+        builder_config = @config[:builder]
+        context = builder_config[:context] || '.'
+
+        if context.start_with?('/')
+          context
+        else
+          File.join(@config_dir, context)
+        end
+      end
+
+      def collect_all_hosts
+        hosts = []
+
+        @config[:servers].each do |_role, role_config|
+          role_hosts = resolve_hosts(role_config)
+          hosts.concat(role_hosts)
+        end
+
+        hosts.uniq
+      end
+
+      # Resolve hosts for a role using the appropriate provider
+      # @param role_config [Hash] role configuration
+      # @return [Array<String>] list of hosts
+      def resolve_hosts(role_config)
+        Odysseus::HostProviders.resolve(role_config)
+      end
+    end
+  end
+end

data/lib/odysseus/deployer/ssh.rb

@@ -0,0 +1,143 @@
+# lib/odysseus/deployer/ssh.rb
+
+require 'net/ssh'
+require 'net/scp'
+
+module Odysseus
+  module Deployer
+    class SSH
+      # @param host [String] hostname or IP
+      # @param user [String] SSH username (default: root)
+      # @param port [Integer] SSH port (default: 22)
+      # @param keys [Array<String>] SSH key paths
+      # @param use_tailscale [Boolean] if true, assume Tailscale hostname
+      # @param verbose [Boolean] log commands being executed
+      def initialize(host:, user: 'root', port: 22, keys: [], use_tailscale: true, verbose: false)
+        @host = host
+        @user = user
+        @port = port
+        @keys = keys.map { |k| File.expand_path(k) }
+        @use_tailscale = use_tailscale
+        @verbose = verbose
+        @session = nil
+      end
+
+      # Execute remote command
+      # @param command [String] command to execute
+      # @return [String] command output
+      # @raise [Odysseus::SSHError] if command fails
+      def execute(command)
+        puts "  > #{command}" if @verbose
+        with_connection do |session|
+          output = ""
+          session.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise Odysseus::SSHCommandError, "Failed to execute: #{command}" unless success
+
+              channel.on_data { |_, data| output += data }
+              channel.on_extended_data { |_, _, data| output += data }
+            end
+          end
+          session.loop
+          output
+        end
+      end
+
+      # Upload file to remote server
+      # @param local_path [String] local file path
+      # @param remote_path [String] remote file path
+      def upload(local_path, remote_path)
+        with_connection do |session|
+          session.scp.upload!(local_path, remote_path, recursive: true)
+        end
+      end
+
+      # Download file from remote server
+      # @param remote_path [String] remote file path
+      # @param local_path [String] local file path
+      def download(remote_path, local_path)
+        with_connection do |session|
+          session.scp.download!(remote_path, local_path, recursive: true)
+        end
+      end
+
+      # Upload string content to remote file
+      # @param content [String] content to write
+      # @param remote_path [String] remote file path
+      def upload_string(content, remote_path)
+        with_connection do |session|
+          session.scp.upload!(StringIO.new(content), remote_path)
+        end
+      end
+
+      # Stream command output (for long-running commands like logs --follow)
+      # @param command [String] command to execute
+      # @yield [String] yields each line of output
+      def stream(command, &block)
+        with_connection do |session|
+          session.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise Odysseus::SSHCommandError, "Failed to execute: #{command}" unless success
+
+              channel.on_data do |_, data|
+                data.each_line { |line| block.call(line) }
+              end
+
+              channel.on_extended_data do |_, _, data|
+                data.each_line { |line| block.call(line) }
+              end
+            end
+          end
+          session.loop
+        end
+      end
+
+      # Check if connected
+      # @return [Boolean]
+      def connected?
+        @session&.closed? == false
+      end
+
+      # Close connection
+      def close
+        @session&.close
+      end
+
+      private
+
+      def with_connection
+        connect unless connected?
+        yield(@session)
+      rescue Errno::ECONNREFUSED => e
+        raise Odysseus::SSHConnectionError, "Connection refused to #{@host}. Is the server running and accepting SSH connections?"
+      rescue SocketError => e
+        raise Odysseus::SSHConnectionError, "Could not resolve hostname '#{@host}'. Check your DNS or /etc/hosts."
+      rescue Net::SSH::AuthenticationFailed => e
+        raise Odysseus::SSHConnectionError, "SSH authentication failed for #{@user}@#{@host}. Check your SSH keys."
+      rescue Errno::ETIMEDOUT, Net::SSH::ConnectionTimeout, Errno::EHOSTUNREACH => e
+        error_msg = "Connection to #{@host} timed out."
+        if @use_tailscale
+          error_msg += "\n\nThis looks like a Tailscale hostname. Please check:\n"
+          error_msg += "  1. Tailscale is running: tailscale status\n"
+          error_msg += "  2. You're authenticated: tailscale login\n"
+          error_msg += "  3. The host is online: tailscale ping #{@host}"
+        end
+        raise Odysseus::SSHConnectionError, error_msg
+      end
+
+      def connect
+        puts "Connecting to #{@user}@#{@host}:#{@port}..." if @verbose
+        options = {
+          port: @port,
+          non_interactive: true,
+          verify_host_key: :never,
+          timeout: 10  # Connection timeout in seconds
+        }
+        options[:keys] = @keys if @keys.any?
+
+        @session = Net::SSH.start(@host, @user, options)
+        puts "Connected to #{@host}" if @verbose
+      end
+    end
+  end
+end