dash 3.2.0 → 3.2.1

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

@@ -1,28 +1,28 @@
-class Kamal::Cli::Proxy < Kamal::Cli::Base
+class Dash::Cli::Proxy < Dash::Cli::Base
   desc "boot", "Boot proxy on servers"
   def boot
     modify(lock: true, server_lock: true) do
-      on(KAMAL.hosts) do |host|
-        execute *KAMAL.docker.create_network
+      on(DASH.hosts) do |host|
+        execute *DASH.docker.create_network
       rescue SSHKit::Command::Failed => e
         raise unless e.message.include?("already exists")
       end
 
       # Skip proxy on loadbalancer host - the loadbalancer will handle it
-      proxy_hosts = KAMAL.proxy_hosts
-      if KAMAL.config.proxy.loadbalancer_on_proxy_host?
-        proxy_hosts = proxy_hosts - [ KAMAL.config.proxy.effective_loadbalancer ]
+      proxy_hosts = DASH.proxy_hosts
+      if DASH.config.proxy.loadbalancer_on_proxy_host?
+        proxy_hosts = proxy_hosts - [ DASH.config.proxy.effective_loadbalancer ]
       end
 
       drifted_hosts = Concurrent::Array.new
       stale_hosts = Concurrent::Array.new
-      auto_reboot = KAMAL.config.proxy.reboot_on_deploy?
+      auto_reboot = DASH.config.proxy.reboot_on_deploy?
 
       on(proxy_hosts) do |host|
-        execute *KAMAL.registry.login
+        execute *DASH.registry.login
 
-        proxy = KAMAL.proxy(host)
-        drift = Kamal::Cli::Proxy::Drift.new(host, self)
+        proxy = DASH.proxy(host)
+        drift = Dash::Cli::Proxy::Drift.new(host, self)
 
         if drift.drifted? && auto_reboot
           # Leave the old proxy serving until its serial reboot slot below.
@@ -32,8 +32,8 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
 
           version = capture_with_info(*proxy.version).strip.presence
 
-          if version && Kamal::Utils.older_version?(version, Kamal::Configuration::Proxy::Run::MINIMUM_VERSION)
-            raise "kamal-proxy version #{version} is too old, run `dash proxy reboot` in order to update to at least #{Kamal::Configuration::Proxy::Run::MINIMUM_VERSION}"
+          if version && Dash::Utils.older_version?(version, Dash::Configuration::Proxy::Run::MINIMUM_VERSION)
+            raise "kamal-proxy version #{version} is too old, run `dash proxy reboot` in order to update to at least #{Dash::Configuration::Proxy::Run::MINIMUM_VERSION}"
           end
 
           if (run_config = proxy.proxy_run_config)&.secrets?
@@ -59,56 +59,56 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
         say "kamal-proxy configuration changed, rebooting on #{host}...", :magenta
         run_hook "pre-proxy-reboot", hosts: host
         on(host) do |h|
-          Kamal::Cli::Proxy::Reboot.new(h, self).run
+          Dash::Cli::Proxy::Reboot.new(h, self).run
         end
         run_hook "post-proxy-reboot", hosts: host
       end
 
-      if KAMAL.config.proxy.load_balancing?
+      if DASH.config.proxy.load_balancing?
         lb_drifted = Concurrent::Array.new
         lb_stale = Concurrent::Array.new
 
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
           info "Starting loadbalancer on #{host}..."
-          execute *KAMAL.registry.login
+          execute *DASH.registry.login
 
           # The load balancer terminates TLS and owns the cache, so its host
           # needs the proxy secrets (acme credentials, cache store) just like
           # the proxy hosts do.
-          if (lb_run = KAMAL.loadbalancer_config.run).secrets?
-            execute *KAMAL.loadbalancer.ensure_proxy_directory
+          if (lb_run = DASH.loadbalancer_config.run).secrets?
+            execute *DASH.loadbalancer.ensure_proxy_directory
             upload! lb_run.secrets_io, lb_run.secrets_path, mode: "0600"
           else
-            execute *KAMAL.loadbalancer.remove_proxy_secrets_file, raise_on_non_zero_exit: false
+            execute *DASH.loadbalancer.remove_proxy_secrets_file, raise_on_non_zero_exit: false
           end
 
-          execute *KAMAL.loadbalancer.ensure_apps_config_directory
+          execute *DASH.loadbalancer.ensure_apps_config_directory
 
           # TLS terminates at the load balancer, so the TLS material the app
           # hosts get - custom certificates and the mTLS client CA - must
           # reach this host too; the LB container reads it through the same
           # apps-config mount the per-host proxies use.
-          KAMAL.config.roles.select(&:running_proxy?).each do |role|
-            Kamal::Cli::App::SslCertificates.new(host, role, self).run
+          DASH.config.roles.select(&:running_proxy?).each do |role|
+            Dash::Cli::App::SslCertificates.new(host, role, self).run
           end
 
           # The same drift detection the proxy hosts get: a loadbalancer booted
           # with a different config digest reboots below (or warns, when
           # automatic reboot is off) instead of serving a stale config forever.
-          container_id = capture_with_info(*KAMAL.loadbalancer.container_id, raise_on_non_zero_exit: false).strip
-          current_digest = capture_with_info(*KAMAL.loadbalancer.config_digest, raise_on_non_zero_exit: false).strip
+          container_id = capture_with_info(*DASH.loadbalancer.container_id, raise_on_non_zero_exit: false).strip
+          current_digest = capture_with_info(*DASH.loadbalancer.config_digest, raise_on_non_zero_exit: false).strip
 
-          if container_id.present? && current_digest != KAMAL.loadbalancer_config.run_config_digest
+          if container_id.present? && current_digest != DASH.loadbalancer_config.run_config_digest
             if auto_reboot
               # Leave the old loadbalancer serving until its reboot below.
               lb_drifted << host.to_s
             else
               lb_stale << host.to_s
-              execute *KAMAL.loadbalancer.start_or_run
+              execute *DASH.loadbalancer.start_or_run
             end
           else
-            Kamal::Cli::Proxy::LoadbalancerClaim.new(host, self).claim_run_config
-            execute *KAMAL.loadbalancer.start_or_run
+            Dash::Cli::Proxy::LoadbalancerClaim.new(host, self).claim_run_config
+            execute *DASH.loadbalancer.start_or_run
           end
         end
 
@@ -121,7 +121,7 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
           say "Loadbalancer configuration changed, rebooting on #{host}...", :magenta
           run_hook "pre-loadbalancer-reboot", hosts: host
           on(host) do |h|
-            Kamal::Cli::Proxy::LoadbalancerReboot.new(h, self).run
+            Dash::Cli::Proxy::LoadbalancerReboot.new(h, self).run
           end
           run_hook "post-loadbalancer-reboot", hosts: host
         end
@@ -132,9 +132,9 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "boot_config <set|get|reset>", "Manage kamal-proxy boot configuration"
   option :publish, type: :boolean, default: true, desc: "Publish the proxy ports on the host"
   option :publish_host_ip, type: :string, repeatable: true, default: nil, desc: "Host IP address to bind HTTP/HTTPS traffic to. Defaults to all interfaces"
-  option :http_port, type: :numeric, default: Kamal::Configuration::Proxy::Run::DEFAULT_HTTP_PORT, desc: "HTTP port to publish on the host"
-  option :https_port, type: :numeric, default: Kamal::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT, desc: "HTTPS port to publish on the host"
-  option :log_max_size, type: :string, default: Kamal::Configuration::Proxy::Run::DEFAULT_LOG_MAX_SIZE, desc: "Max size of proxy logs"
+  option :http_port, type: :numeric, default: Dash::Configuration::Proxy::Run::DEFAULT_HTTP_PORT, desc: "HTTP port to publish on the host"
+  option :https_port, type: :numeric, default: Dash::Configuration::Proxy::Run::DEFAULT_HTTPS_PORT, desc: "HTTPS port to publish on the host"
+  option :log_max_size, type: :string, default: Dash::Configuration::Proxy::Run::DEFAULT_LOG_MAX_SIZE, desc: "Max size of proxy logs"
   option :registry, type: :string, default: nil, desc: "Registry to use for the proxy image"
   option :repository, type: :string, default: nil, desc: "Repository for the proxy image"
   option :image_version, type: :string, default: nil, desc: "Version of the proxy to run"
@@ -143,7 +143,7 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   option :docker_options, type: :array, default: [], desc: "Docker options to pass to the proxy container", banner: "option=value option2=value2"
   def boot_config(subcommand)
     say "The proxy boot_config command is deprecated - set the config in the deploy YAML at proxy/run instead", :yellow
-    proxy_boot_config = KAMAL.config.proxy_boot
+    proxy_boot_config = DASH.config.proxy_boot
 
     case subcommand
     when "set"
@@ -163,10 +163,10 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
       image_version = options[:image_version]
 
       run_command_options = { debug: options[:debug] || nil, "metrics-port": options[:metrics_port] }.compact
-      run_command = "kamal-proxy run #{Kamal::Utils.optionize(run_command_options).join(" ")}" if run_command_options.any?
+      run_command = "kamal-proxy run #{Dash::Utils.optionize(run_command_options).join(" ")}" if run_command_options.any?
 
-      on(KAMAL.proxy_hosts) do |host|
-        proxy = KAMAL.proxy(host)
+      on(DASH.proxy_hosts) do |host|
+        proxy = DASH.proxy(host)
         execute(*proxy.ensure_proxy_directory)
         if boot_options != proxy_boot_config.default_boot_options
           upload! StringIO.new(boot_options.join(" ")), proxy_boot_config.options_file
@@ -194,12 +194,12 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
       end
     when "get"
 
-      on(KAMAL.proxy_hosts) do |host|
-        puts "Host #{host}: #{capture_with_info(*KAMAL.proxy(host).boot_config)}"
+      on(DASH.proxy_hosts) do |host|
+        puts "Host #{host}: #{capture_with_info(*DASH.proxy(host).boot_config)}"
       end
     when "reset"
-      on(KAMAL.proxy_hosts) do |host|
-        proxy = KAMAL.proxy(host)
+      on(DASH.proxy_hosts) do |host|
+        proxy = DASH.proxy(host)
         execute *proxy.reset_boot_options, raise_on_non_zero_exit: false
         execute *proxy.reset_image, raise_on_non_zero_exit: false
         execute *proxy.reset_image_version, raise_on_non_zero_exit: false
@@ -217,9 +217,9 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
     confirming "This will cause a brief outage on each host. Are you sure?" do
       modify(lock: true, server_lock: true) do
         # Skip proxy on loadbalancer host - it will be handled by loadbalancer reboot
-        proxy_hosts = KAMAL.proxy_hosts
-        if KAMAL.config.proxy.loadbalancer_on_proxy_host?
-          proxy_hosts = proxy_hosts - [ KAMAL.config.proxy.effective_loadbalancer ]
+        proxy_hosts = DASH.proxy_hosts
+        if DASH.config.proxy.loadbalancer_on_proxy_host?
+          proxy_hosts = proxy_hosts - [ DASH.config.proxy.effective_loadbalancer ]
         end
 
         host_groups = options[:rolling] ? proxy_hosts : [ proxy_hosts ]
@@ -230,17 +230,17 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
           run_hook "pre-proxy-reboot", hosts: host_list
           on(hosts) do |host|
             info "Rebooting kamal-proxy on #{host}..."
-            Kamal::Cli::Proxy::Reboot.new(host, self).run
+            Dash::Cli::Proxy::Reboot.new(host, self).run
           end
           run_hook "post-proxy-reboot", hosts: host_list
         end
 
-        if KAMAL.config.proxy.load_balancing?
-          lb_host = KAMAL.config.proxy.effective_loadbalancer
+        if DASH.config.proxy.load_balancing?
+          lb_host = DASH.config.proxy.effective_loadbalancer
           run_hook "pre-loadbalancer-reboot", hosts: lb_host
 
           on(lb_host) do |host|
-            Kamal::Cli::Proxy::LoadbalancerReboot.new(host, self).run
+            Dash::Cli::Proxy::LoadbalancerReboot.new(host, self).run
           end
 
           run_hook "post-loadbalancer-reboot", hosts: lb_host
@@ -253,18 +253,18 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   option :rolling, type: :boolean, default: false, desc: "Reboot proxy on hosts in sequence, rather than in parallel"
   option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
   def upgrade
-    invoke_options = { "version" => KAMAL.config.latest_tag }.merge(options)
+    invoke_options = { "version" => DASH.config.latest_tag }.merge(options)
 
     confirming "This will cause a brief outage on each host. Are you sure?" do
-      host_groups = options[:rolling] ? KAMAL.hosts : [ KAMAL.hosts ]
+      host_groups = options[:rolling] ? DASH.hosts : [ DASH.hosts ]
       host_groups.each do |hosts|
         host_list = Array(hosts).join(",")
         say "Upgrading proxy on #{host_list}...", :magenta
         run_hook "pre-proxy-reboot", hosts: host_list
         on(hosts) do |host|
-          proxy = KAMAL.proxy(host)
-          execute *KAMAL.auditor.record("Rebooted proxy"), verbosity: :debug
-          execute *KAMAL.registry.login
+          proxy = DASH.proxy(host)
+          execute *DASH.auditor.record("Rebooted proxy"), verbosity: :debug
+          execute *DASH.registry.login
 
           info "Stopping and removing Traefik on #{host}, if running..."
           execute *proxy.cleanup_traefik
@@ -275,13 +275,13 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
           execute *proxy.remove_image
         end
 
-        KAMAL.with_specific_hosts(hosts) do
-          invoke "kamal:cli:proxy:boot", [], invoke_options
-          reset_invocation(Kamal::Cli::Proxy)
-          invoke "kamal:cli:app:boot", [], invoke_options
-          reset_invocation(Kamal::Cli::App)
-          invoke "kamal:cli:prune:all", [], invoke_options
-          reset_invocation(Kamal::Cli::Prune)
+        DASH.with_specific_hosts(hosts) do
+          invoke "dash:cli:proxy:boot", [], invoke_options
+          reset_invocation(Dash::Cli::Proxy)
+          invoke "dash:cli:app:boot", [], invoke_options
+          reset_invocation(Dash::Cli::App)
+          invoke "dash:cli:prune:all", [], invoke_options
+          reset_invocation(Dash::Cli::Prune)
         end
 
         run_hook "post-proxy-reboot", hosts: host_list
@@ -293,15 +293,15 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "start", "Start existing proxy container on servers"
   def start
     modify(lock: true, server_lock: true) do
-      on(KAMAL.proxy_hosts) do |host|
-        execute *KAMAL.auditor.record("Started proxy"), verbosity: :debug
-        execute *KAMAL.proxy(host).start
+      on(DASH.proxy_hosts) do |host|
+        execute *DASH.auditor.record("Started proxy"), verbosity: :debug
+        execute *DASH.proxy(host).start
       end
 
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do
-          execute *KAMAL.auditor.record("Started loadbalancer"), verbosity: :debug
-          execute *KAMAL.loadbalancer.start, raise_on_non_zero_exit: false
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do
+          execute *DASH.auditor.record("Started loadbalancer"), verbosity: :debug
+          execute *DASH.loadbalancer.start, raise_on_non_zero_exit: false
         end
       end
     end
@@ -310,18 +310,18 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "stop", "Stop existing proxy container on servers"
   def stop
     modify(lock: true, server_lock: true) do
-      on(KAMAL.proxy_hosts) do |host|
-        execute *KAMAL.auditor.record("Stopped proxy"), verbosity: :debug
-        execute *KAMAL.proxy(host).stop, raise_on_non_zero_exit: false
+      on(DASH.proxy_hosts) do |host|
+        execute *DASH.auditor.record("Stopped proxy"), verbosity: :debug
+        execute *DASH.proxy(host).stop, raise_on_non_zero_exit: false
       end
 
       # `docker container prune` only collects stopped containers, so leaving the
       # loadbalancer running would also leave `dash proxy remove` unable to
       # remove it.
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do
-          execute *KAMAL.auditor.record("Stopped loadbalancer"), verbosity: :debug
-          execute *KAMAL.loadbalancer.stop, raise_on_non_zero_exit: false
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do
+          execute *DASH.auditor.record("Stopped loadbalancer"), verbosity: :debug
+          execute *DASH.loadbalancer.stop, raise_on_non_zero_exit: false
         end
       end
     end
@@ -338,11 +338,11 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "details", "Show details about proxy container from servers"
   def details
     quiet = options[:quiet]
-    on(KAMAL.proxy_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.proxy(host).info), type: "Proxy", quiet: quiet }
+    on(DASH.proxy_hosts) { |host| puts_by_host host, capture_with_info(*DASH.proxy(host).info), type: "Proxy", quiet: quiet }
 
-    if KAMAL.config.proxy.load_balancing?
-      on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-        puts_by_host host, capture_with_info(*KAMAL.loadbalancer.info), type: "Loadbalancer"
+    if DASH.config.proxy.load_balancing?
+      on(DASH.config.proxy.effective_loadbalancer) do |host|
+        puts_by_host host, capture_with_info(*DASH.loadbalancer.info), type: "Loadbalancer"
       end
     end
   end
@@ -359,17 +359,17 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
 
     if options[:follow]
       run_locally do
-        proxy = KAMAL.proxy(KAMAL.primary_host)
-        info "Following logs on #{KAMAL.primary_host}..."
-        info proxy.follow_logs(host: KAMAL.primary_host, timestamps: timestamps, grep: grep)
-        exec proxy.follow_logs(host: KAMAL.primary_host, timestamps: timestamps, grep: grep)
+        proxy = DASH.proxy(DASH.primary_host)
+        info "Following logs on #{DASH.primary_host}..."
+        info proxy.follow_logs(host: DASH.primary_host, timestamps: timestamps, grep: grep)
+        exec proxy.follow_logs(host: DASH.primary_host, timestamps: timestamps, grep: grep)
       end
     else
       since = options[:since]
       lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
 
-      on(KAMAL.proxy_hosts) do |host|
-        puts_by_host host, capture(*KAMAL.proxy(host).logs(timestamps: timestamps, since: since, lines: lines, grep: grep)), type: "Proxy"
+      on(DASH.proxy_hosts) do |host|
+        puts_by_host host, capture(*DASH.proxy(host).logs(timestamps: timestamps, since: since, lines: lines, grep: grep)), type: "Proxy"
       end
     end
   end
@@ -391,47 +391,47 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   def loadbalancer(status)
     case status
     when "info"
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
           puts "Loadbalancer status on #{host}:"
-          puts capture_with_info(*KAMAL.loadbalancer.info)
+          puts capture_with_info(*DASH.loadbalancer.info)
         end
       else
         puts "Load balancing is not configured"
       end
     when "start"
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          execute *KAMAL.registry.login
-          execute *KAMAL.loadbalancer.start_or_run
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          execute *DASH.registry.login
+          execute *DASH.loadbalancer.start_or_run
         end
       else
         puts "Load balancing is not configured"
       end
     when "stop"
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          execute *KAMAL.loadbalancer.stop, raise_on_non_zero_exit: false
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          execute *DASH.loadbalancer.stop, raise_on_non_zero_exit: false
         end
       else
         puts "Load balancing is not configured"
       end
     when "logs"
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          puts_by_host host, capture(*KAMAL.loadbalancer.logs(timestamps: true)), type: "Loadbalancer"
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          puts_by_host host, capture(*DASH.loadbalancer.logs(timestamps: true)), type: "Loadbalancer"
         end
       else
         puts "Load balancing is not configured"
       end
     when "deploy"
-      if KAMAL.config.proxy.load_balancing?
-        targets = KAMAL.loadbalancer_config.target_hosts
+      if DASH.config.proxy.load_balancing?
+        targets = DASH.loadbalancer_config.target_hosts
 
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          Kamal::Cli::Proxy::LoadbalancerClaim.new(host, self).claim_service
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          Dash::Cli::Proxy::LoadbalancerClaim.new(host, self).claim_service
           info "Deploying to loadbalancer on #{host} with targets: #{targets.join(', ')}"
-          execute *KAMAL.loadbalancer.deploy(targets: targets)
+          execute *DASH.loadbalancer.deploy(targets: targets)
         end
       else
         puts "Load balancing is not configured"
@@ -453,29 +453,29 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
       # The cache lives where its policy applies: at the loadbalancer when
       # load balancing (cache is edge-only in the layering contract),
       # otherwise on each proxy host.
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          puts_by_host host, capture_with_info(*KAMAL.loadbalancer.cache_stats(count: count, json: json)), type: "Loadbalancer"
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          puts_by_host host, capture_with_info(*DASH.loadbalancer.cache_stats(count: count, json: json)), type: "Loadbalancer"
         end
       else
-        on(KAMAL.proxy_hosts) do |host|
-          puts_by_host host, capture_with_info(*KAMAL.proxy(host).cache_stats(count: count, json: json)), type: "Proxy"
+        on(DASH.proxy_hosts) do |host|
+          puts_by_host host, capture_with_info(*DASH.proxy(host).cache_stats(count: count, json: json)), type: "Proxy"
         end
       end
     when "purge"
-      if KAMAL.config.proxy.load_balancing?
+      if DASH.config.proxy.load_balancing?
         # The loadbalancer registers one service under the bare service name.
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          execute *KAMAL.auditor.record("Purged the response cache"), verbosity: :debug
-          puts_by_host host, capture_with_info(*KAMAL.loadbalancer.cache_purge(KAMAL.config.service, path_prefix: path_prefix)), type: "Loadbalancer"
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          execute *DASH.auditor.record("Purged the response cache"), verbosity: :debug
+          puts_by_host host, capture_with_info(*DASH.loadbalancer.cache_purge(DASH.config.service, path_prefix: path_prefix)), type: "Loadbalancer"
         end
       else
         # Each proxied role registered its own service, so purge walks them.
-        on(KAMAL.proxy_hosts) do |host|
-          execute *KAMAL.auditor.record("Purged the response cache"), verbosity: :debug
+        on(DASH.proxy_hosts) do |host|
+          execute *DASH.auditor.record("Purged the response cache"), verbosity: :debug
 
-          KAMAL.roles_on(host).select(&:running_proxy?).each do |role|
-            puts_by_host host, capture_with_info(*KAMAL.proxy(host).cache_purge(role.container_prefix, path_prefix: path_prefix)), type: "Proxy"
+          DASH.roles_on(host).select(&:running_proxy?).each do |role|
+            puts_by_host host, capture_with_info(*DASH.proxy(host).cache_purge(role.container_prefix, path_prefix: path_prefix)), type: "Proxy"
           end
         end
       end
@@ -484,37 +484,49 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
     end
   end
 
-  desc "domains SUBCOMMAND", "Manage dynamic TLS domains (refresh, list, stats)"
-  def domains(subcommand)
+  desc "domains SUBCOMMAND [ARGS]", "Inspect TLS domains and their certificate issuance (refresh, list, stats, retry)"
+  long_desc <<~DESC
+    Inspect the TLS domains this proxy serves, and the state of their certificates.
+
+    `list` shows every domain — both those learned from a domain source and the
+    hosts named in deploy.yml — with whether it holds a certificate and, if
+    issuance is held, when the hold lifts and why.
+
+    A hold normally clears itself: the proxy re-checks held domains and issues as
+    soon as the domain points at it, so a DNS cutover needs no intervention.
+    `retry HOST` (or `retry --all`) is for when you already know the cause is
+    fixed and would rather not wait.
+  DESC
+  def domains(subcommand, *args)
     case subcommand
-    when "refresh", "list", "stats"
+    when "refresh", "list", "stats", "retry"
       # TLS terminates at the load balancer when load balancing, so the
       # dynamic domain set lives there rather than on the per-host proxies.
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do |host|
-          puts_by_host host, capture_with_info(*KAMAL.loadbalancer.domains(subcommand)), type: "Loadbalancer"
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do |host|
+          puts_by_host host, capture_with_info(*DASH.loadbalancer.domains(subcommand, *args)), type: "Loadbalancer"
         end
       else
-        on(KAMAL.proxy_hosts) do |host|
-          puts_by_host host, capture_with_info(*KAMAL.proxy(host).domains(subcommand)), type: "Proxy"
+        on(DASH.proxy_hosts) do |host|
+          puts_by_host host, capture_with_info(*DASH.proxy(host).domains(subcommand, *args)), type: "Proxy"
         end
       end
     else
-      puts "Unknown domains subcommand: #{subcommand}. Available: refresh, list, stats"
+      puts "Unknown domains subcommand: #{subcommand}. Available: refresh, list, stats, retry"
     end
   end
 
   desc "export_certs LOCAL_PATH", "Export the TLS certificate store to a local archive (contains private keys)"
   def export_certs(local_path)
-    load_balancing = KAMAL.config.proxy.load_balancing?
+    load_balancing = DASH.config.proxy.load_balancing?
 
     # Under the deploy lock: a concurrent deploy could boot or reboot the
     # proxy mid-export, and the offline read below would archive a torn store.
     modify(lock: true, server_lock: true) do
       on(cert_store_host) do |host|
-        execute *KAMAL.auditor.record("Exported the proxy certificate store"), verbosity: :debug
+        execute *DASH.auditor.record("Exported the proxy certificate store"), verbosity: :debug
 
-        commands = load_balancing ? KAMAL.loadbalancer : KAMAL.proxy(host)
+        commands = load_balancing ? DASH.loadbalancer : DASH.proxy(host)
         execute *commands.ensure_apps_config_directory
 
         # Running: export through the container's RPC socket, under the proxy's
@@ -523,7 +535,7 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
         if capture_with_info(*commands.container_id(only_running: true), raise_on_non_zero_exit: false).strip.present?
           puts capture_with_info(*commands.export_certs)
         else
-          execute *KAMAL.registry.login
+          execute *DASH.registry.login
           puts capture_with_info(*commands.export_certs_offline)
         end
 
@@ -548,11 +560,11 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
     source = options[:traefik_acme] || options[:archive]
     traefik_acme, resolver = options[:traefik_acme].present?, options[:resolver]
     force, verify = options[:force], options[:verify]
-    load_balancing = KAMAL.config.proxy.load_balancing?
+    load_balancing = DASH.config.proxy.load_balancing?
 
     modify(lock: true, server_lock: true) do
       on(cert_store_host) do |host|
-        commands = load_balancing ? KAMAL.loadbalancer : KAMAL.proxy(host)
+        commands = load_balancing ? DASH.loadbalancer : DASH.proxy(host)
 
         # kamal-proxy import runs offline against the data directory - importing
         # under a live proxy risks a torn store. --verify only reads the archive.
@@ -564,8 +576,8 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
           end
         end
 
-        execute *KAMAL.auditor.record("Imported certificates into the proxy certificate store"), verbosity: :debug
-        execute *KAMAL.registry.login
+        execute *DASH.auditor.record("Imported certificates into the proxy certificate store"), verbosity: :debug
+        execute *DASH.registry.login
         execute *commands.ensure_proxy_directory
 
         # upload! inside the ensure's reach: a failed or partial upload must
@@ -584,15 +596,15 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "remove_container", "Remove proxy container from servers", hide: true
   def remove_container
     modify(lock: true, server_lock: true) do
-      on(KAMAL.proxy_hosts) do
-        execute *KAMAL.auditor.record("Removed proxy container"), verbosity: :debug
-        execute *KAMAL.proxy(host).remove_container
+      on(DASH.proxy_hosts) do
+        execute *DASH.auditor.record("Removed proxy container"), verbosity: :debug
+        execute *DASH.proxy(host).remove_container
       end
 
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do
-          execute *KAMAL.auditor.record("Removed loadbalancer container"), verbosity: :debug
-          execute *KAMAL.loadbalancer.remove_container
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do
+          execute *DASH.auditor.record("Removed loadbalancer container"), verbosity: :debug
+          execute *DASH.loadbalancer.remove_container
         end
       end
     end
@@ -601,15 +613,15 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "remove_image", "Remove proxy image from servers", hide: true
   def remove_image
     modify(lock: true, server_lock: true) do
-      on(KAMAL.proxy_hosts) do
-        execute *KAMAL.auditor.record("Removed proxy image"), verbosity: :debug
-        execute *KAMAL.proxy(host).remove_image
+      on(DASH.proxy_hosts) do
+        execute *DASH.auditor.record("Removed proxy image"), verbosity: :debug
+        execute *DASH.proxy(host).remove_image
       end
 
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do
-          execute *KAMAL.auditor.record("Removed loadbalancer image"), verbosity: :debug
-          execute *KAMAL.loadbalancer.remove_image
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do
+          execute *DASH.auditor.record("Removed loadbalancer image"), verbosity: :debug
+          execute *DASH.loadbalancer.remove_image
         end
       end
     end
@@ -618,15 +630,15 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
   desc "remove_proxy_directory", "Remove the proxy directory from servers", hide: true
   def remove_proxy_directory
     modify(lock: true, server_lock: true) do
-      on(KAMAL.proxy_hosts) do
-        execute *KAMAL.proxy(host).remove_proxy_directory, raise_on_non_zero_exit: false
+      on(DASH.proxy_hosts) do
+        execute *DASH.proxy(host).remove_proxy_directory, raise_on_non_zero_exit: false
       end
 
       # Otherwise the ownership registry outlives the load balancer and a later
       # boot would fail against an owner that no longer exists.
-      if KAMAL.config.proxy.load_balancing?
-        on(KAMAL.config.proxy.effective_loadbalancer) do
-          execute *KAMAL.loadbalancer.remove_directory, raise_on_non_zero_exit: false
+      if DASH.config.proxy.load_balancing?
+        on(DASH.config.proxy.effective_loadbalancer) do
+          execute *DASH.loadbalancer.remove_directory, raise_on_non_zero_exit: false
         end
       end
     end
@@ -637,7 +649,7 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
     # host when load balancing (TLS terminates at the edge), else the primary
     # host - the same host `loadbalancer: true` would resolve to.
     def cert_store_host
-      KAMAL.config.proxy.load_balancing? ? KAMAL.config.proxy.effective_loadbalancer : KAMAL.primary_host
+      DASH.config.proxy.load_balancing? ? DASH.config.proxy.effective_loadbalancer : DASH.primary_host
     end
 
     # Mirrors kamal-proxy's own flag groups (import.go), so a contradictory
@@ -664,14 +676,14 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
     # has to cover the load balancer host too - `remove_container` and
     # `remove_image` both act on it.
     def removal_hosts
-      hosts = KAMAL.proxy_hosts.to_a
-      hosts |= [ KAMAL.config.proxy.effective_loadbalancer ] if KAMAL.config.proxy.load_balancing?
+      hosts = DASH.proxy_hosts.to_a
+      hosts |= [ DASH.config.proxy.effective_loadbalancer ] if DASH.config.proxy.load_balancing?
       hosts
     end
 
     def removal_allowed?(force)
       on(removal_hosts) do |host|
-        app_count = capture_with_info(*KAMAL.server.app_directory_count).chomp.to_i
+        app_count = capture_with_info(*DASH.server.app_directory_count).chomp.to_i
         raise "The are other applications installed on #{host}" if app_count > 0
       end