dash 3.2.0 → 4.0.0

data/lib/{kamal → dash}/cli/doctor/endpoint_checks.rb

@@ -2,9 +2,9 @@ require "resolv"
 require "socket"
 require "openssl"
 
-# Local (no SSH) readiness checks for the domains kamal-proxy will serve:
+# Local (no SSH) readiness checks for the domains dash-proxy will serve:
 # DNS resolution against the configured hosts and TLS certificate expiry.
-class Kamal::Cli::Doctor::EndpointChecks
+class Dash::Cli::Doctor::EndpointChecks
   CERTIFICATE_EXPIRY_WARN_DAYS = 14
   SECONDS_PER_DAY = 86_400
   TLS_CONNECT_TIMEOUT = 5
@@ -15,22 +15,39 @@ class Kamal::Cli::Doctor::EndpointChecks
 
   private
     def result(check, target, status, detail)
-      Kamal::Cli::Doctor::Result.new(check, target, status, detail)
+      Dash::Cli::Doctor::Result.new(check, target, status, detail)
     end
 
     # Roles and accessories that run behind the proxy with custom domains.
     def proxied_units
-      @proxied_units ||= (KAMAL.roles + KAMAL.config.proxy_accessories).select do |unit|
+      @proxied_units ||= (DASH.roles + DASH.config.proxy_accessories).select do |unit|
         unit.running_proxy? && unit.proxy.hosts.any?
       end
     end
 
     def dns_results
       proxied_units.flat_map do |unit|
-        unit.proxy.hosts.map { |domain| dns_check(domain, unit.hosts) }
+        unit.proxy.hosts.map { |domain| dns_check(domain, unit.hosts, acme_issued: acme_issued?(unit)) }
       end
     end
 
+    # Whether this unit's certificate comes from ACME rather than the operator.
+    # Only then does where the domain points decide whether a certificate can
+    # exist — a supplied certificate is unaffected by DNS.
+    def acme_issued?(unit)
+      unit.proxy.ssl? && !unit.proxy.custom_ssl_certificate?
+    end
+
+    # The two states a DNS cutover passes through — not resolving yet, and still
+    # resolving to the old host — are exactly when an operator wonders whether
+    # something is broken. Nothing is: the proxy refuses to spend an ACME order
+    # it cannot win, re-checks held domains, and issues once the domain arrives.
+    ISSUANCE_PENDING = "no certificate can be issued until it points here, and the proxy issues automatically once it does".freeze
+
+    def with_issuance_note(detail, acme_issued)
+      acme_issued ? "#{detail} - #{ISSUANCE_PENDING}" : detail
+    end
+
     def certificate_results
       proxied_units.flat_map do |unit|
         next [] unless unit.proxy.ssl?
@@ -41,17 +58,18 @@ class Kamal::Cli::Doctor::EndpointChecks
       end
     end
 
-    def dns_check(domain, unit_hosts)
+    def dns_check(domain, unit_hosts, acme_issued: false)
       resolved = Resolv.getaddresses(domain)
       expected = expected_ips(unit_hosts)
       matching = resolved & expected
 
       if resolved.empty?
-        result :dns, domain, :fail, "does not resolve"
+        result :dns, domain, :fail, with_issuance_note("does not resolve", acme_issued)
       elsif matching.any?
         result :dns, domain, :ok, "resolves to #{matching.join(", ")}"
       else
-        result :dns, domain, :warn, "resolves to #{resolved.join(", ")}, expected one of #{expected.join(", ")} (fine when fronted by a CDN or load balancer)"
+        result :dns, domain, :warn,
+          with_issuance_note("resolves to #{resolved.join(", ")}, expected one of #{expected.join(", ")} (fine when fronted by a CDN or load balancer)", acme_issued)
       end
     rescue StandardError => e
       result :dns, domain, :fail, "could not resolve (#{e.message})"

data/lib/{kamal → dash}/cli/doctor/host_checks.rb

@@ -3,7 +3,7 @@
 # Every check rescues StandardError at its boundary: the doctor's contract is
 # to report broken environments, not crash on them, and a failed connection can
 # raise anything from Net::SSH errors to Errno and DNS resolution errors.
-class Kamal::Cli::Doctor::HostChecks
+class Dash::Cli::Doctor::HostChecks
   attr_reader :host, :sshkit, :proxy_host
   delegate :execute, :capture_with_info, to: :sshkit
 
@@ -27,7 +27,7 @@ class Kamal::Cli::Doctor::HostChecks
 
   private
     def result(check, status, detail)
-      Kamal::Cli::Doctor::Result.new(check, host, status, detail)
+      Dash::Cli::Doctor::Result.new(check, host, status, detail)
     end
 
     def ssh_check
@@ -38,7 +38,7 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def docker_check
-      if execute(*KAMAL.docker.running?, raise_on_non_zero_exit: false)
+      if execute(*DASH.docker.running?, raise_on_non_zero_exit: false)
         result :docker, :ok, "docker is installed and running"
       else
         result :docker, :fail, "docker is not installed or not running (run `dash server bootstrap`)"
@@ -48,9 +48,9 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def registry_check
-      return result(:registry, :ok, "local registry, no login required") if KAMAL.registry.local?
+      return result(:registry, :ok, "local registry, no login required") if DASH.registry.local?
 
-      if execute(*KAMAL.registry.login, raise_on_non_zero_exit: false)
+      if execute(*DASH.registry.login, raise_on_non_zero_exit: false)
         result :registry, :ok, "logged in to #{registry_name}"
       else
         result :registry, :fail, "docker login to #{registry_name} failed (check registry credentials)"
@@ -71,7 +71,7 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def capture_proxy_version
-      [ capture_with_info(*KAMAL.proxy(host).version).strip.presence, nil ]
+      [ capture_with_info(*DASH.proxy(host).version).strip.presence, nil ]
     rescue StandardError => e
       [ nil, e ]
     end
@@ -79,7 +79,7 @@ class Kamal::Cli::Doctor::HostChecks
     def proxy_image_check
       image = expected_proxy_image
 
-      if execute(*KAMAL.docker.manifest_available?(image), raise_on_non_zero_exit: false)
+      if execute(*DASH.docker.manifest_available?(image), raise_on_non_zero_exit: false)
         result :proxy_image, :ok, "#{image} manifest is fetchable"
       else
         result :proxy_image, :fail, "cannot fetch the manifest for #{image} (registry unreachable or unauthorized)"
@@ -89,13 +89,13 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def proxy_version_check(version, error)
-      minimum = Kamal::Configuration::Proxy::Run::MINIMUM_VERSION
+      minimum = Dash::Configuration::Proxy::Run::MINIMUM_VERSION
 
       if error
         result :proxy_version, :warn, "could not determine the running version (#{error.message})"
       elsif version.nil?
         result :proxy_version, :ok, "not running (will be started on deploy)"
-      elsif Kamal::Utils.older_version?(version, minimum)
+      elsif Dash::Utils.older_version?(version, minimum)
         result :proxy_version, :fail, "#{version} is older than the minimum #{minimum}, run `dash proxy reboot` to update"
       else
         result :proxy_version, :ok, "#{version} (minimum #{minimum})"
@@ -114,26 +114,26 @@ class Kamal::Cli::Doctor::HostChecks
     # mode is one hung request when a sleeping service never wakes - and one
     # from before it was removed keeps root-equivalent host access.
     def proxy_socket_check(proxy_running:)
-      expected = KAMAL.config.proxy_run(host)&.docker_socket
+      expected = DASH.config.proxy_run(host)&.docker_socket
 
       unless proxy_running
         detail = expected ? "docker socket #{expected} will be mounted on boot" : "no docker socket configured"
         return result(:proxy_socket, :ok, detail)
       end
 
-      mounted = capture_with_info(*KAMAL.proxy(host).mount_destinations, raise_on_non_zero_exit: false).split("\n").map(&:strip)
+      mounted = capture_with_info(*DASH.proxy(host).mount_destinations, raise_on_non_zero_exit: false).split("\n").map(&:strip)
 
       if expected
         if mounted.include?(expected)
           result :proxy_socket, :ok, "docker socket #{expected} is mounted"
         elsif sleep_configured?
-          result :proxy_socket, :fail, "the running kamal-proxy has no #{expected} mount, so sleeping services never wake - run `dash proxy reboot`"
+          result :proxy_socket, :fail, "the running dash-proxy has no #{expected} mount, so sleeping services never wake - run `dash proxy reboot`"
         else
           # Nothing sleeps yet, so nothing hangs - drift rather than breakage.
-          result :proxy_socket, :warn, "the running kamal-proxy has no #{expected} mount - run `dash proxy reboot` to apply the current configuration"
+          result :proxy_socket, :warn, "the running dash-proxy has no #{expected} mount - run `dash proxy reboot` to apply the current configuration"
         end
       elsif (stray = mounted.grep(DOCKER_SOCKET_PATTERN).first)
-        result :proxy_socket, :warn, "the running kamal-proxy mounts #{stray} but the config no longer asks for it - " \
+        result :proxy_socket, :warn, "the running dash-proxy mounts #{stray} but the config no longer asks for it - " \
           "the socket is root-equivalent host access; `dash proxy reboot` removes it"
       else
         result :proxy_socket, :ok, "no docker socket configured or mounted"
@@ -143,18 +143,18 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def sleep_configured?
-      KAMAL.config.roles.any? { |role| role.running_proxy? && role.proxy.proxy_config["sleep"].present? }
+      DASH.config.roles.any? { |role| role.running_proxy? && role.proxy.proxy_config["sleep"].present? }
     end
 
     def ports_check(proxy_running:)
-      run_config = KAMAL.config.proxy_run(host)
+      run_config = DASH.config.proxy_run(host)
       return result(:ports, :ok, "proxy ports are not published, nothing to check") if run_config && !run_config.publish?
 
-      http_port = run_config&.http_port || Kamal::Configuration::Proxy::Run::DEFAULT_HTTP_PORT
-      https_port = run_config&.https_port || Kamal::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT
+      http_port = run_config&.http_port || Dash::Configuration::Proxy::Run::DEFAULT_HTTP_PORT
+      https_port = run_config&.https_port || Dash::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT
 
       if proxy_running
-        result :ports, :ok, "ports #{http_port}/#{https_port} held by the running kamal-proxy"
+        result :ports, :ok, "ports #{http_port}/#{https_port} held by the running dash-proxy"
       elsif (busy = busy_ports(http_port, https_port)).any?
         result :ports, :fail, "port(s) #{busy.join(", ")} already in use by another process"
       else
@@ -165,14 +165,14 @@ class Kamal::Cli::Doctor::HostChecks
     end
 
     def busy_ports(*ports)
-      ports.select { |port| capture_with_info(*KAMAL.server.listeners_on(port), raise_on_non_zero_exit: false).present? }
+      ports.select { |port| capture_with_info(*DASH.server.listeners_on(port), raise_on_non_zero_exit: false).present? }
     end
 
     def expected_proxy_image
-      KAMAL.config.proxy_run(host)&.image || "#{KAMAL.config.proxy_boot.image_default}:#{Kamal::Configuration::Proxy::Run::MINIMUM_VERSION}"
+      DASH.config.proxy_run(host)&.image || "#{DASH.config.proxy_boot.image_default}:#{Dash::Configuration::Proxy::Run::MINIMUM_VERSION}"
     end
 
     def registry_name
-      KAMAL.config.registry.server || "Docker Hub"
+      DASH.config.registry.server || "Docker Hub"
     end
 end

data/lib/{kamal → dash}/cli/doctor.rb

@@ -1,8 +1,8 @@
-require "kamal/sshkit_with_ext"
+require "dash/sshkit_with_ext"
 
 # Runs read-only deploy readiness checks and collects the results, without ever
 # raising on a broken environment - failures become failing results instead.
-class Kamal::Cli::Doctor
+class Dash::Cli::Doctor
   include SSHKit::DSL
 
   HOST_CHECKS = %i[ ssh docker registry proxy_image proxy_version proxy_socket ports ]
@@ -71,19 +71,19 @@ class Kamal::Cli::Doctor
       results_by_host = collect_host_checks
 
       HOST_CHECKS.flat_map do |check|
-        KAMAL.hosts.filter_map { |host| results_by_host.dig(host, check) }
+        DASH.hosts.filter_map { |host| results_by_host.dig(host, check) }
       end
     end
 
     def collect_host_checks
       results_by_host = {}
       mutex = Mutex.new
-      proxy_hosts = KAMAL.proxy_hosts
+      proxy_hosts = DASH.proxy_hosts
       error = nil
 
       begin
-        on(KAMAL.hosts) do |host|
-          checks = Kamal::Cli::Doctor::HostChecks.new(host.hostname, self, proxy_host: proxy_hosts.include?(host.hostname)).run
+        on(DASH.hosts) do |host|
+          checks = Dash::Cli::Doctor::HostChecks.new(host.hostname, self, proxy_host: proxy_hosts.include?(host.hostname)).run
           mutex.synchronize { results_by_host[host.hostname] = checks }
         end
       # Only ExecuteError: sshkit 1.25 has no MultipleExecuteError, and naming
@@ -95,7 +95,7 @@ class Kamal::Cli::Doctor
         error = e
       end
 
-      KAMAL.hosts.each do |host|
+      DASH.hosts.each do |host|
         results_by_host[host] ||= { ssh: Result.new(:ssh, host, :fail, "could not run checks (#{error&.message || "connection failed"})") }
       end
 
@@ -103,10 +103,10 @@ class Kamal::Cli::Doctor
     end
 
     def endpoint_check_results
-      Kamal::Cli::Doctor::EndpointChecks.new.run
+      Dash::Cli::Doctor::EndpointChecks.new.run
     end
 
     def config_check_results
-      Kamal::Cli::Doctor::ConfigChecks.new.run
+      Dash::Cli::Doctor::ConfigChecks.new.run
     end
 end

data/lib/{kamal → dash}/cli/healthcheck/barrier.rb

@@ -1,6 +1,6 @@
 require "concurrent/ivar"
 
-class Kamal::Cli::Healthcheck::Barrier
+class Dash::Cli::Healthcheck::Barrier
   def initialize
     @ivar = Concurrent::IVar.new
   end
@@ -15,7 +15,7 @@ class Kamal::Cli::Healthcheck::Barrier
 
   def wait
     unless opened?
-      raise Kamal::Cli::Healthcheck::Error.new("Halted at barrier")
+      raise Dash::Cli::Healthcheck::Error.new("Halted at barrier")
     end
   end
 

data/lib/{kamal → dash}/cli/healthcheck/drift_error.rb

@@ -1,7 +1,7 @@
 # Raised when the config declares a healthcheck the running container does not have.
 #
-# Deliberately NOT a Kamal::Cli::Healthcheck::Error: the poller retries that class until
+# Deliberately NOT a Dash::Cli::Healthcheck::Error: the poller retries that class until
 # deploy_timeout, and drift is deterministic — `.State.Health` exists from the moment a
 # container with a healthcheck is created, so retrying only burns the timeout before
 # reporting the same thing.
-class Kamal::Cli::Healthcheck::DriftError < StandardError; end
+class Dash::Cli::Healthcheck::DriftError < StandardError; end

data/lib/dash/cli/healthcheck/error.rb

@@ -0,0 +1,2 @@
+class Dash::Cli::Healthcheck::Error < StandardError
+end

data/lib/{kamal → dash}/cli/healthcheck/poller.rb

@@ -1,11 +1,11 @@
-module Kamal::Cli::Healthcheck::Poller
+module Dash::Cli::Healthcheck::Poller
   extend self
 
-  NO_HEALTHCHECK = Kamal::Commands::Base::NO_HEALTHCHECK
+  NO_HEALTHCHECK = Dash::Commands::Base::NO_HEALTHCHECK
 
   def wait_for_healthy(role:, &block)
     attempt = 1
-    timeout_at = Time.now + KAMAL.config.deploy_timeout
+    timeout_at = Time.now + DASH.config.deploy_timeout
     readiness_delay = role.readiness_delay
 
     begin
@@ -27,13 +27,13 @@ module Kamal::Cli::Healthcheck::Poller
       end
 
       unless acceptable?(status)
-        raise Kamal::Cli::Healthcheck::Error, "container not ready after #{KAMAL.config.deploy_timeout} seconds (#{status})"
+        raise Dash::Cli::Healthcheck::Error, "container not ready after #{DASH.config.deploy_timeout} seconds (#{status})"
       end
-    rescue Kamal::Cli::Healthcheck::Error => e
+    rescue Dash::Cli::Healthcheck::Error => e
       time_left = timeout_at - Time.now
       if time_left > 0
         sleep_for = [ attempt, time_left ].min
-        elapsed = KAMAL.config.deploy_timeout - time_left
+        elapsed = DASH.config.deploy_timeout - time_left
         info "Container not ready yet, retrying in #{sleep_for.ceil}s (#{elapsed.round}s elapsed, #{time_left.round}s left)"
         sleep sleep_for
         attempt += 1
@@ -65,7 +65,7 @@ module Kamal::Cli::Healthcheck::Poller
     def ensure_no_healthcheck_drift(role, status)
       return unless %i[ healthcheck docker_options ].include?(role.readiness_source)
 
-      raise Kamal::Cli::Healthcheck::DriftError,
+      raise Dash::Cli::Healthcheck::DriftError,
         "#{role.name} declares a healthcheck but the container reports none (#{status}) — the flags never reached docker. " \
         "Compare `servers/#{role.name}` in your deploy config against `docker inspect --format '{{json .Config.Healthcheck}}'` " \
         "on the container; the deploy would otherwise be accepted without ever probing it."

data/lib/{kamal → dash}/cli/lock.rb

@@ -1,4 +1,4 @@
-class Kamal::Cli::Lock < Kamal::Cli::Base
+class Dash::Cli::Lock < Dash::Cli::Base
   desc "status", "Report lock status"
   def status
     handle_missing_lock do

data/lib/dash/cli/main/migrate.rb

@@ -0,0 +1,77 @@
+require "fileutils"
+
+# Moves a project from the legacy `.kamal` directory to `.dash`. Purely local -
+# it never opens an SSH connection and never reads deploy.yml - and only ever
+# runs when the operator asks for it, because silently rewriting someone's
+# working tree is not a deploy tool's job.
+#
+# Returns [message, color] pairs rather than printing: output belongs to the Thor
+# command, and reaching into the Thor instance for `say` couples this class to a
+# shell helper whose visibility changes between Thor versions.
+class Dash::Cli::Main::Migrate
+  CURRENT = Dash::ProjectDirectory::CURRENT
+  LEGACY = Dash::ProjectDirectory::LEGACY
+
+  LEGACY_ENV_PATTERN = /\bKAMAL_[A-Z0-9_]+/
+  EXTRA_SCANNED_FILES = [ "config/deploy.yml" ].freeze
+
+  attr_reader :dry_run
+
+  def initialize(dry_run: false)
+    @dry_run = dry_run
+  end
+
+  def run
+    return [ [ "No #{LEGACY} directory to migrate.", nil ] ] unless Dir.exist?(LEGACY)
+
+    if Dir.exist?(CURRENT)
+      return [ [ "Both #{CURRENT} and #{LEGACY} exist. Merge them by hand, then remove #{LEGACY}.", :yellow ] ]
+    end
+
+    if dry_run
+      [ [ "Would move #{LEGACY} to #{CURRENT}#{" with git mv" if tracked_by_git?}", nil ], *legacy_env_reference_lines ]
+    else
+      move
+      [ [ "Moved #{LEGACY} to #{CURRENT}", :green ], *legacy_env_reference_lines ]
+    end
+  end
+
+  private
+    # `git mv` stages the rename, so the operator is left with a clean rename in
+    # `git status` rather than a delete plus a pile of untracked files.
+    def move
+      if tracked_by_git?
+        system("git", "mv", LEGACY, CURRENT, exception: true)
+      else
+        FileUtils.mv LEGACY, CURRENT
+      end
+    end
+
+    def tracked_by_git?
+      return @tracked_by_git if defined?(@tracked_by_git)
+      @tracked_by_git = !`git ls-files -- #{LEGACY} 2> /dev/null`.strip.empty?
+    end
+
+    # Reported, never rewritten: both prefixes carry the same value until 5.0,
+    # so there is nothing to fix today and an automatic rewrite of hook scripts
+    # would be a much bigger promise than this command makes.
+    def legacy_env_reference_lines
+      references = scanned_files.filter_map do |file|
+        names = File.read(file, encoding: Encoding::BINARY).scan(LEGACY_ENV_PATTERN).uniq
+        [ file, names ] if names.any?
+      end
+
+      return [] if references.empty?
+
+      [
+        [ "\nFound legacy KAMAL_* references. dash sets both prefixes until 5.0, so nothing is urgent:", nil ],
+        *references.map { |file, names| [ "  #{file}: #{names.sort.join(", ")}", nil ] }
+      ]
+    end
+
+    def scanned_files
+      directory = dry_run ? LEGACY : CURRENT
+
+      (Dir.glob("#{directory}/**/*") + EXTRA_SCANNED_FILES).select { |file| File.file?(file) && File.readable?(file) }
+    end
+end