odysseus-core 0.3.2 → 0.10.0

data/lib/odysseus/deployer/executor.rb

@@ -16,14 +16,27 @@ module Odysseus
         @secrets_loader = Odysseus::Secrets::Loader.new(@config, config_dir: @config_dir)
       end
 
+      # The identity of the deploy: version, ref and deployer.
+      #
+      # Resolved once per tag so a multi-role, multi-host deploy cannot end up
+      # with two versions, and so the git commands run once rather than per host.
+      #
+      # @param image_tag [String, nil] explicit tag, or nil to resolve from git
+      # @return [Odysseus::DeployVersion]
+      def deploy_version(image_tag = nil)
+        @deploy_versions ||= {}
+        @deploy_versions[image_tag] ||= version_resolver.resolve(image_tag: image_tag)
+      end
+
       # Build Docker image
-      # @param image_tag [String] docker image tag (e.g., "v1.0.0")
+      # @param image_tag [String, nil] docker image tag (e.g., "v1.0.0"), or nil to resolve from git
       # @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)
+      def build(image_tag: nil, push: false, context_path: nil)
+        resolved = deploy_version(image_tag)
         context = context_path || resolve_build_context
-        full_image = "#{@config[:image]}:#{image_tag}"
+        full_image = "#{@config[:image]}:#{resolved.version}"
 
         builder = build_builder
 
@@ -39,17 +52,15 @@ module Odysseus
       end
 
       # Build and deploy in one step
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @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)
+      def build_and_deploy(image_tag: nil, 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
+        return { build: build_result, deploy: nil, success: false } unless build_result[:success]
 
         # Then deploy
         deploy_results = deploy_all(image_tag: image_tag, dry_run: dry_run)
@@ -62,15 +73,14 @@ module Odysseus
       end
 
       # Push image to all configured hosts via SSH (using docker pussh)
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @return [Hash] pussh results
-      def pussh(image_tag:)
-        full_image = "#{@config[:image]}:#{image_tag}"
+      def pussh(image_tag: nil)
+        resolved = deploy_version(image_tag)
+        full_image = "#{@config[:image]}:#{resolved.version}"
         hosts = collect_all_hosts
 
-        if hosts.empty?
-          return { success: false, error: "No hosts configured" }
-        end
+        return { success: false, error: 'No hosts configured' } if hosts.empty?
 
         builder = build_builder
         builder.pussh_to_hosts(
@@ -81,16 +91,14 @@ module Odysseus
       end
 
       # Build and pussh to all hosts (no registry needed)
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @param context_path [String] path to build context
       # @return [Hash] build and pussh results
-      def build_and_pussh(image_tag:, context_path: nil)
+      def build_and_pussh(image_tag: nil, 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
+        return { build: build_result, pussh: nil, success: false } unless build_result[:success]
 
         # Then pussh to all hosts
         pussh_result = pussh(image_tag: image_tag)
@@ -104,10 +112,10 @@ module Odysseus
 
       # Build and distribute image based on config
       # Uses registry if configured, otherwise pussh to hosts
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @param context_path [String] path to build context
       # @return [Hash] build and distribution results
-      def build_and_distribute(image_tag:, context_path: nil)
+      def build_and_distribute(image_tag: nil, context_path: nil)
         if uses_registry?
           build_and_push_to_registry(image_tag: image_tag, context_path: context_path)
         else
@@ -122,10 +130,10 @@ module Odysseus
       end
 
       # Build and push to registry
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @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)
+      def build_and_push_to_registry(image_tag: nil, context_path: nil)
         build_result = build(image_tag: image_tag, push: true, context_path: context_path)
 
         {
@@ -136,9 +144,9 @@ module Odysseus
       end
 
       # Deploy all roles to their configured hosts
-      # @param image_tag [String] docker image tag
+      # @param image_tag [String, nil] docker image tag, or nil to resolve from git
       # @param dry_run [Boolean] if true, don't actually deploy
-      def deploy_all(image_tag:, dry_run: false)
+      def deploy_all(image_tag: nil, dry_run: false)
         results = {}
 
         @config[:servers].each do |role, role_config|
@@ -149,188 +157,239 @@ module Odysseus
           end
         end
 
-        results
-      end
+        prune_old_images unless dry_run
 
-      # 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
+        results
       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}..."
+      # What every host reports about this service's versions.
+      #
+      # One entry per unique host across all roles, so a host serving two roles
+      # is surveyed once. Connections are opened and closed per host.
+      #
+      # @return [Array<Odysseus::HostVersions>]
+      def version_survey
+        host_roles.map do |host, roles|
           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)
+            Odysseus::HostVersions.read(
+              host: host, ssh: ssh, service: @config[:service], image: @config[:image], roles: roles
+            )
           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?
+      # Decide what a rollback would do, without doing it.
+      #
+      # Surveys the fleet and returns the plan, or raises RollbackError with a
+      # message naming the hosts at fault. Separate from rollback_all so the
+      # caller can show the target — and any approximate-ordering warning —
+      # before anything is touched, and so the survey runs once.
+      #
+      # @param version [String, nil] explicit target, or nil for the previous one
+      # @return [Odysseus::RollbackPlan]
+      def rollback_plan(version: nil)
+        Odysseus::RollbackPlanner.new(version_survey).plan(version: version)
+      end
 
+      # Roll every role on every host back to the planned version.
+      #
+      # Reuses the deploy path unchanged, so health gating, proxy handling and
+      # zero-downtime behaviour are shared with deploy rather than
+      # reimplemented. Sequential, and inheriting deploy's partial-failure
+      # semantics: the plan's pre-flight rules out the common cause of a
+      # half-rolled-back fleet — a missing image — but does not make the roll
+      # atomic.
+      #
+      # @param plan [Odysseus::RollbackPlan] from #rollback_plan
+      # @return [Hash] results keyed "role@host"
+      def rollback_all(plan)
+        resolved = Odysseus::DeployVersion.new(
+          version: plan.version, ref: plan.ref, deployer: version_resolver.deployer
+        )
         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
+        @config[:servers].each do |role, role_config|
+          resolve_hosts(role_config).each do |host|
+            puts "\n=== Rolling back #{role} on #{host} to #{plan.version} ==="
+            results["#{role}@#{host}"] = run_deploy(
+              host: host, role: role, resolved: resolved,
+              kind: 'rolled-back', from: plan.from_for(host)
+            )
           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?
+      # Delete a service's images that no host needs any more.
+      #
+      # @return [Hash{String => Array<String>}] versions removed, keyed by host
+      def prune_old_images
+        retention_sweeper.sweep(host_roles)
+      end
 
-        results = {}
-        hosts.each do |host|
-          puts "Restarting accessory #{name} on #{host}..."
-          ssh = connect_to_server(host)
+      # Deploy a single role to a specific host
+      # @param host [String] target host (from config)
+      # @param image_tag [String, nil] docker image tag (e.g., "v1.2.3"), or nil to resolve from git
+      # @param dry_run [Boolean] if true, don't actually deploy
+      # @param role [Symbol] server role
+      def deploy_role(host:, role:, image_tag: nil, dry_run: false)
+        resolved = deploy_version(image_tag)
 
-          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
+        if dry_run
+          puts "Dry run - would deploy #{@config[:image]}:#{resolved.version} to #{host}"
+          puts "Service: #{@config[:service]}"
+          puts "Role: #{role}"
+          puts "Proxy hosts: #{@config[:proxy][:hosts].join(', ')}" if role == WEB_ROLE
+          return { success: true, dry_run: true }
         end
-        results
+
+        run_deploy(host: host, role: role, resolved: resolved)
       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] || []
+      # Deploy an dependency to all its configured hosts
+      # @param name [Symbol] dependency name
+      def deploy_dependency(name:)
+        dependency_manager.deploy(name: name)
+      end
 
-        raise Odysseus::ConfigError, "No hosts configured for accessory #{name}" if hosts.empty?
+      # Remove an dependency from all its configured hosts
+      # @param name [Symbol] dependency name
+      def remove_dependency(name:)
+        dependency_manager.remove(name: name)
+      end
 
-        results = {}
-        hosts.each do |host|
-          puts "Upgrading accessory #{name} on #{host}..."
-          ssh = connect_to_server(host)
+      # Restart an dependency on all its configured hosts
+      # @param name [Symbol] dependency name
+      def restart_dependency(name:)
+        dependency_manager.restart(name: name)
+      end
 
-          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
+      # Upgrade an dependency to a new image version on all its configured hosts
+      # @param name [Symbol] dependency name
+      def upgrade_dependency(name:)
+        dependency_manager.upgrade(name: name)
       end
 
-      # List accessory status on all configured hosts
-      def accessory_status
-        return [] unless @config[:accessories]&.any?
+      # List dependency status on all configured hosts
+      def dependency_status
+        dependency_manager.status
+      end
 
-        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
+      # Boot all dependencies to their configured hosts
+      def boot_dependencies
+        dependency_manager.boot_all
       end
 
-      # Boot all accessories to their configured hosts
-      def boot_accessories
-        return {} unless @config[:accessories]&.any?
+      # Every configured host mapped to the roles it serves, each in config
+      # order. A host serving two roles (e.g. web and cron on the same box)
+      # gets both, in the order its roles are declared in deploy.yml — the
+      # order #version_survey depends on to know which role's containers to
+      # look for first.
+      #
+      # Public API, not just an internal helper: the CLI asks this exact
+      # question too — which hosts does this config target, and which roles
+      # on each — to visit every host once regardless of how many roles it
+      # serves. `odysseus doctor` depends on it.
+      #
+      # @return [Hash{String => Array<Symbol>}]
+      def host_roles
+        roles_by_host = {}
 
-        results = {}
-        @config[:accessories].each_key do |name|
-          puts "\n=== Booting accessory: #{name} ==="
-          results[name] = deploy_accessory(name: name)
+        @config[:servers].each do |role, role_config|
+          resolve_hosts(role_config).each { |host| (roles_by_host[host] ||= []) << role }
         end
-        results
+
+        roles_by_host
       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
+      # Dependency verbs are a distinct concern from deploy/rollback; see
+      # Odysseus::Deployer::DependencyManager.
+      def dependency_manager
+        @dependency_manager ||= Odysseus::Deployer::DependencyManager.new(
+          config: @config, secrets_loader: @secrets_loader, connector: method(:connect_to_server)
+        )
+      end
+
+      def version_resolver
+        @version_resolver ||= Odysseus::VersionResolver.new(config_dir: @config_dir, logger: build_logger)
+      end
+
+      # Image retention is a distinct concern from deploy/rollback; see
+      # Odysseus::Deployer::RetentionSweeper.
+      def retention_sweeper
+        @retention_sweeper ||= Odysseus::Deployer::RetentionSweeper.new(
+          config: @config, connector: method(:connect_to_server), logger: build_logger
+        )
+      end
+
+      # Sails are constructed with a fixed keyword set, so version metadata
+      # travels in the config hash rather than as a new keyword argument.
+      def orchestrator_config(resolved)
+        @config.merge(deploy_version: resolved)
+      end
+
+      # One role on one host: connect, hand off to the orchestrator, record the
+      # outcome on the host, close. Shared by deploy and rollback so both get
+      # identical health gating, proxy handling and audit trail.
+      #
+      # @param kind [String] 'deployed' or 'rolled-back'
+      # @param from [String, nil] the version being replaced, for a rollback
+      def run_deploy(host:, role:, resolved:, kind: 'deployed', from: nil)
+        ssh = connect_to_server(host)
+
+        begin
+          orchestrator = build_orchestrator(ssh, role, resolved)
+          result = orchestrator.deploy(image_tag: resolved.version, role: role)
+          record_deploy(ssh: ssh, host: host, role: role, resolved: resolved, kind: kind, from: from)
+          result
+        ensure
+          ssh.close
+        end
       end
 
-      def build_orchestrator(ssh, role)
+      # The host's own record of what it is running, written only after the
+      # orchestrator reports success.
+      #
+      # Best effort, and deliberately rescuing StandardError rather than
+      # Odysseus::Error: SSH#execute can also raise Net::SSH::Disconnect,
+      # IOError or Net::SSH::ChannelOpenFailed, none of which with_connection
+      # translates. Traffic has already switched by this point, so any of them
+      # escaping here would turn a completed deploy into a reported failure.
+      def record_deploy(ssh:, host:, role:, resolved:, kind:, from:)
+        Odysseus::DeployLog.new(ssh: ssh, service: @config[:service]).append(
+          version: resolved.version, role: role, ref: resolved.ref,
+          deployer: resolved.deployer, kind: kind, from: from
+        )
+      rescue StandardError => e
+        build_logger.warn("Could not record the deploy on #{host}: #{e.message}")
+      end
+
+      def build_orchestrator(ssh, role, resolved)
         logger = build_logger
         role_config = @config[:servers][role] || {}
         strategy = role_config.dig(:deploy, :strategy)
+        config = orchestrator_config(resolved)
 
         # Check if a sail plugin provides this strategy
         if strategy && Odysseus::Sails.registered?(strategy)
           sail_klass = Odysseus::Sails.resolve(strategy)
           sail_klass.new(
-            ssh: ssh, config: @config, logger: logger, secrets_loader: @secrets_loader
+            ssh: ssh, config: config, logger: logger, secrets_loader: @secrets_loader
           )
         elsif role == WEB_ROLE
           Odysseus::Orchestrator::WebDeploy.new(
-            ssh: ssh, config: @config, logger: logger, secrets_loader: @secrets_loader
+            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
+            ssh: ssh, config: config, logger: logger, secrets_loader: @secrets_loader
           )
         end
       end
@@ -341,7 +400,7 @@ module Odysseus
           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(:debug) { |msg| puts "  > #{Odysseus::CommandRedaction.redact(msg)}" if verbose }
           l.define_singleton_method(:verbose?) { verbose }
         end
       end
@@ -377,14 +436,7 @@ module Odysseus
       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
+        host_roles.keys
       end
 
       # Resolve hosts for a role using the appropriate provider

data/lib/odysseus/deployer/retention_sweeper.rb

@@ -0,0 +1,94 @@
+# lib/odysseus/deployer/retention_sweeper.rb
+
+module Odysseus
+  module Deployer
+    # Removes a service's images that no host needs any more, split out of
+    # Executor for the same reason DependencyManager was: it is a distinct
+    # concern, sharing only the config and a way to open a connection.
+    #
+    # Best effort throughout. This runs after a deploy has already succeeded and
+    # switched traffic, so nothing here may raise into the caller: every removal
+    # is attempted on its own, and a host that cannot be read at all is skipped
+    # with a warning.
+    class RetentionSweeper
+      # @param config [Hash] parsed deploy.yml
+      # @param connector [#call] returns an open SSH connection for a host
+      # @param logger [Object] responds to #info and #warn
+      def initialize(config:, connector:, logger:)
+        @config = config
+        @connector = connector
+        @logger = logger
+      end
+
+      # @param host_roles [Hash{String => Array<Symbol>}] hosts and the roles each serves
+      # @return [Hash{String => Array<String>}] versions removed, keyed by host
+      def sweep(host_roles)
+        host_roles.to_h { |host, roles| [host, sweep_host(host, roles)] }
+      end
+
+      private
+
+      def sweep_host(host, roles)
+        ssh = @connector.call(host)
+
+        begin
+          docker = Odysseus::Docker::Client.new(ssh)
+          plan = retention_plan(ssh, docker, host, roles)
+          return [] if plan.nil?
+
+          @logger.info("  Keeping #{plan.keep.join(', ')} on #{host}")
+          plan.remove.select { |version| prune_image(docker, host, version) }
+        rescue StandardError => e
+          @logger.warn("Could not prune images on #{host}: #{e.message}")
+          []
+        ensure
+          ssh.close
+        end
+      end
+
+      # nil when the host has no deploy log to authorise removals. Falling back
+      # to image creation time would risk deleting a version someone still
+      # wants: creation time is *build* time, and images can reach a host out of
+      # order.
+      def retention_plan(ssh, docker, host, roles)
+        history = Odysseus::DeployLog.new(ssh: ssh, service: @config[:service]).entries
+
+        if history.empty?
+          @logger.info("  No deploy log on #{host} yet, so nothing is pruned")
+          return nil
+        end
+
+        Odysseus::RetentionPlanner.new(
+          history: history,
+          available: docker.image_tags(@config[:image]),
+          in_use: docker.versions_in_use(container_labels(roles)),
+          retain: @config[:retain_versions]
+        ).plan
+      end
+
+      # The odysseus.service label values this host's containers carry — one per
+      # role. Built with Labels.service_for so reading them back cannot disagree
+      # with how WebDeploy and JobDeploy write them.
+      def container_labels(roles)
+        roles.map { |role| Odysseus::Docker::Labels.service_for(service: @config[:service], role: role) }
+      end
+
+      # True when the image is gone. Named prune_image, not remove_image, so it
+      # cannot be misread as Docker::Client#remove_image, which it calls.
+      #
+      # Rescues StandardError rather than Odysseus::Error: docker refuses to
+      # remove an image a container still references, and SSH#execute can also
+      # raise Net::SSH::Disconnect, IOError or Net::SSH::ChannelOpenFailed
+      # untranslated.
+      def prune_image(docker, host, version)
+        image = "#{@config[:image]}:#{version}"
+        docker.remove_image(image)
+        @logger.info("  Pruned #{image} on #{host}")
+        true
+      rescue StandardError => e
+        @logger.info("  Kept #{image} on #{host}: #{e.message}")
+        false
+      end
+    end
+  end
+end