odysseus-core 0.3.2 → 0.9.0

data/lib/odysseus/deploy_log.rb

@@ -0,0 +1,120 @@
+# lib/odysseus/deploy_log.rb
+
+require 'shellwords'
+
+module Odysseus
+  # Append-only record of what has been deployed to one host, keyed by service.
+  #
+  # This is the host's own account of its history: it orders versions reliably,
+  # which image timestamps cannot, and it survives container removal and image
+  # pruning. It is also the host-side audit trail.
+  class DeployLog
+    FILENAME = 'deploys.log'.freeze
+    TIME_FORMAT = '%Y-%m-%dT%H:%M:%SZ'.freeze
+
+    Entry = Data.define(:at, :version, :role, :ref, :deployer, :kind, :from)
+
+    # @param ssh [Odysseus::Deployer::SSH] connection to the host
+    # @param service [String] the service: value from deploy.yml, never role-suffixed
+    def initialize(ssh:, service:)
+      @ssh = ssh
+      @service = service
+    end
+
+    # @return [String] absolute path of this service's log on the host
+    def path
+      File.join(host_paths.service_dir(@service), FILENAME)
+    end
+
+    # Where a root install wrote this log. A host that has since moved to a
+    # deploy user still has its history here, and nothing ever deletes it.
+    # @return [String]
+    def legacy_path
+      File.join(host_paths.legacy_base, @service, FILENAME)
+    end
+
+    # Record one deploy of one role.
+    #
+    # @param kind [String] 'deployed' or 'rolled-back'
+    # @param from [String, nil] the version replaced, for a rollback
+    def append(version:, role:, ref:, deployer:, kind: 'deployed', from: nil)
+      fields = [
+        Time.now.utc.strftime(TIME_FORMAT), sanitize(version), sanitize(role.to_s),
+        sanitize(ref || '-'), sanitize(deployer || '-'), sanitize(kind)
+      ]
+      fields << "from=#{sanitize(from)}" if from
+
+      # Escape the assembled line as ONE argument. printf reuses its format for
+      # every remaining argument, so passing the fields separately would write
+      # one line per field instead of one line per deploy.
+      line = Shellwords.escape(fields.map(&:to_s).join(' '))
+
+      @ssh.execute("mkdir -p #{Shellwords.escape(File.dirname(path))}")
+      @ssh.execute("printf '%s\\n' #{line} >> #{Shellwords.escape(path)}")
+    end
+
+    # @return [Array<Entry>] parsed entries, oldest first; empty when absent
+    def entries
+      # Prefer the current location, then the one a root install used. No
+      # merging: a host deploying as two different users is not a supported
+      # shape, and merging two histories would invent an ordering.
+      #
+      # For a root connection path and legacy_path are the same file, so the
+      # legacy `cat` is only added when they differ — otherwise the command
+      # would read one file twice for no reason, and no longer match what a
+      # root install has always run.
+      command = "cat #{Shellwords.escape(path)} 2>/dev/null"
+      command += " || cat #{Shellwords.escape(legacy_path)} 2>/dev/null" if legacy_path != path
+      command += ' || true'
+
+      raw = @ssh.execute(command)
+
+      raw.to_s.lines.filter_map { |line| parse_line(line) }
+    end
+
+    private
+
+    def host_paths
+      @host_paths ||= Odysseus::HostPaths.new(@ssh)
+    end
+
+    # The log's shape -- one line per record, fields separated by single
+    # spaces -- is load-bearing: phase 3's rollback ordering reads this file
+    # and relies on exactly one record per line and stable field positions.
+    # A field value is not guaranteed to be whitespace-free (git config
+    # user.email, for instance, can contain a literal newline), and
+    # `Shellwords.escape` treats a newline as safe to embed rather than
+    # stripping it, so an unsanitised value could split one record across
+    # multiple lines or shift every field after it. Collapse any run of
+    # whitespace in a field to a single underscore so the shape can never be
+    # broken, instead of raising and risking the record being dropped
+    # entirely (callers log after a deploy has already succeeded). A blank
+    # field maps to '-' rather than the empty string: split(/\s+/, 7) on read
+    # collapses an empty field into the whitespace around it, silently
+    # shifting every field after it into the wrong position with no line-count
+    # anomaly to notice.
+    def sanitize(value)
+      collapsed = value.to_s.gsub(/\s+/, '_')
+      collapsed.empty? ? '-' : collapsed
+    end
+
+    def parse_line(line)
+      stripped = line.strip
+
+      # Checked against the full split, not the limit-7 one below: a genuinely
+      # shifted or garbage-laden record can still land inside 6..7 once the
+      # trailing words are merged into the last field, which is exactly the
+      # "plausible-looking wrong record" this guards against.
+      return nil unless (6..7).cover?(stripped.split(/\s+/).length)
+
+      at, version, role, ref, deployer, kind, extra = stripped.split(/\s+/, 7)
+      return nil if at.nil? || version.nil? || kind.nil?
+      return nil unless at.match?(/\A\d{4}-\d{2}-\d{2}T/)
+
+      Entry.new(
+        at: at, version: version, role: role, ref: ref, deployer: deployer,
+        kind: kind, from: extra&.slice(/\Afrom=(\S+)/, 1)
+      )
+    end
+  end
+end

data/lib/odysseus/deploy_version.rb

@@ -0,0 +1,9 @@
+# lib/odysseus/deploy_version.rb
+
+module Odysseus
+  # The identity of one deploy: the image tag, plus where it came from.
+  # ref is nil when the version was given explicitly, because an arbitrary tag
+  # says nothing about a commit. deployer is still known in that case — it
+  # never depended on the tag identifying a commit.
+  DeployVersion = Data.define(:version, :ref, :deployer)
+end

data/lib/odysseus/deployer/dependency_manager.rb

@@ -0,0 +1,121 @@
+# lib/odysseus/deployer/dependency_manager.rb
+
+module Odysseus
+  module Deployer
+    # Dependency verbs (deploy/remove/restart/upgrade/status/boot), split out of
+    # Executor because they are a distinct concern from deploying and rolling
+    # back the service itself, sharing only config and a way to open a
+    # connection.
+    class DependencyManager
+      # @param config [Hash] parsed deploy.yml
+      # @param secrets_loader [Odysseus::Secrets::Loader]
+      # @param connector [#call] returns an open SSH connection for a host
+      def initialize(config:, secrets_loader:, connector:)
+        @config = config
+        @secrets_loader = secrets_loader
+        @connector = connector
+      end
+
+      # @param name [Symbol] dependency name
+      # @return [Hash] results keyed by host
+      def deploy(name:)
+        run_action(name, 'Deploying', 'to') { |orchestrator| orchestrator.deploy(name: name.to_sym) }
+      end
+
+      # @param name [Symbol] dependency name
+      # @return [Hash] results keyed by host
+      def remove(name:)
+        run_action(name, 'Removing', 'from') { |orchestrator| orchestrator.remove(name: name.to_sym) }
+      end
+
+      # @param name [Symbol] dependency name
+      # @return [Hash] results keyed by host
+      def restart(name:)
+        run_action(name, 'Restarting', 'on') { |orchestrator| orchestrator.restart(name: name.to_sym) }
+      end
+
+      # @param name [Symbol] dependency name
+      # @return [Hash] results keyed by host
+      def upgrade(name:)
+        run_action(name, 'Upgrading', 'on') { |orchestrator| orchestrator.upgrade(name: name.to_sym) }
+      end
+
+      # @return [Array<Hash>] status for every dependency on every configured host
+      def status
+        return [] unless @config[:dependencies]&.any?
+
+        all_statuses = []
+        @config[:dependencies].each do |name, dep_config|
+          (dep_config[:hosts] || []).each do |host|
+            dep_status = status_on(host, name)
+            all_statuses << dep_status if dep_status
+          end
+        end
+        all_statuses
+      end
+
+      # @return [Hash] boot results keyed by dependency name
+      def boot_all
+        return {} unless @config[:dependencies]&.any?
+
+        results = {}
+        @config[:dependencies].each_key do |name|
+          puts "\n=== Booting dependency: #{name} ==="
+          results[name] = deploy(name: name)
+        end
+        results
+      end
+
+      private
+
+      # DependencyDeploy exposes #list_status (no args, every dependency on the
+      # host) rather than a per-dependency lookup, so pick out the one entry
+      # this host/dependency pair needs; nil when it is somehow absent. One
+      # #list_status call per dependency/host pair where one per host would
+      # do; accepted for now rather than restructuring the dependency-then-host
+      # result order.
+      def status_on(host, name)
+        ssh = @connector.call(host)
+
+        begin
+          dep_status = build_orchestrator(ssh).list_status.find { |entry| entry[:name] == name }
+          dep_status&.merge(host: host)
+        ensure
+          ssh.close
+        end
+      end
+
+      def dependency_config(name)
+        config = @config[:dependencies]&.[](name.to_sym)
+        raise Odysseus::ConfigError, "Dependency '#{name}' not found in config" unless config
+
+        config
+      end
+
+      # Shared plumbing for the verbs above: resolve hosts, connect, build the
+      # orchestrator, run the block, and always close the connection.
+      def run_action(name, verb, preposition)
+        hosts = dependency_config(name)[:hosts] || []
+
+        raise Odysseus::ConfigError, "No hosts configured for dependency #{name}" if hosts.empty?
+
+        results = {}
+        hosts.each do |host|
+          puts "#{verb} dependency #{name} #{preposition} #{host}..."
+          ssh = @connector.call(host)
+
+          begin
+            results[host] = yield(build_orchestrator(ssh))
+          ensure
+            ssh.close
+          end
+        end
+        results
+      end
+
+      def build_orchestrator(ssh)
+        Odysseus::Orchestrator::DependencyDeploy.new(ssh: ssh, config: @config, secrets_loader: @secrets_loader)
+      end
+    end
+  end
+end