dash 3.2.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3a110ddc9f31ad566bce549f84ef6b216a395d9201e02747f1e062d89406f07
-  data.tar.gz: 40fcfdf62082cf07a8e7e19455fd9398567e6ace96be7426165d27309f0ef29e
+  metadata.gz: 749c8e286224f96b085fc8c325affcfde1cafaa18824e1405f880cc1aea966b1
+  data.tar.gz: 0dab0ae01b69f742e58551caaeee3352f98548c5a6265e98fcbe2de3025b50d1
 SHA512:
-  metadata.gz: c9a19af8c3f5c210d01d8aa9dcdee7e2ad76018050cf7df70ca3bc04a85089702a8ec32b14eab38701e48ffa2306880333e5fd2309e109fb83b720ea27041f33
-  data.tar.gz: bf7739b92e6685eb9bc62453eed18c7ba127faf29d42c15023b890632b4c2f3b8e1481e9fc3481b189b27a86dd39c04a57d08d5c00b46fe89b2a294ed807144e
+  metadata.gz: 7b8a1e07a72a34388817185a8e476b4c400a90061292fe9d143a9a67ab1e5e5d2a87cba154077d151922a306f577dce9d04d60ecef371296ca9b2e3c49a277cb
+  data.tar.gz: 5b396df37122ed76ff2e5b7b2b694940a9eb1bcaa5bf31ed0de3f01039bf59836224f225da0a59acc24445f1d6a3dfe19165f2c83fd2e4a4023e68a1ec41c2c6

data/lib/dash/cli/app/boot.rb

@@ -58,7 +58,7 @@ class Dash::Cli::App::Boot
         raise Dash::Cli::BootError, "Failed to get endpoint for #{role} on #{host}, did the container boot?" if endpoint.empty?
 
         run_hook "pre-proxy-deploy", hosts: host.to_s, role: role.name
-        info "Deploying #{role} on #{host} via kamal-proxy (waiting up to #{DASH.config.deploy_timeout}s for it to become healthy)..."
+        info "Deploying #{role} on #{host} via dash-proxy (waiting up to #{DASH.config.deploy_timeout}s for it to become healthy)..."
         execute *app.deploy(target: endpoint)
         run_hook "post-proxy-deploy", hosts: host.to_s, role: role.name
       else
@@ -84,7 +84,7 @@ class Dash::Cli::App::Boot
     end
 
     # Every failed boot gets the container log, and the health probe history when the
-    # container declares a healthcheck — non-primary roles have no kamal-proxy report to fall back on.
+    # container declares a healthcheck — non-primary roles have no dash-proxy report to fall back on.
     def dump_diagnostics
       error capture_with_info(*app.logs(container_id: app.container_id_for_version(version)))
 

data/lib/dash/cli/app.rb

@@ -283,7 +283,7 @@ class Dash::Cli::App < Dash::Cli::Base
     end
   end
 
-  desc "rollout <deploy|set|stop>", "Manage a canary rollout of a new version through kamal-proxy"
+  desc "rollout <deploy|set|stop>", "Manage a canary rollout of a new version through dash-proxy"
   option :percent, type: :numeric, desc: "Percentage of traffic to send to the rollout target"
   option :list, type: :array, desc: "Send requests whose kamal-rollout cookie matches these values to the rollout target"
   def rollout(action)

data/lib/dash/cli/base.rb

@@ -170,7 +170,7 @@ module Dash::Cli
         raw ? DASH.with_verbosity(:error, &block) : block.call
       end
 
-      # kamal-proxy is one container per host, shared by every destination
+      # dash-proxy is one container per host, shared by every destination
       # deployed there, but the deploy lock is per-destination — so two
       # destinations deploying at once take different locks and both mutate the
       # same proxy. Anything touching the proxy takes this lock as well.

data/lib/dash/cli/doctor/endpoint_checks.rb

@@ -2,7 +2,7 @@ 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 Dash::Cli::Doctor::EndpointChecks
   CERTIFICATE_EXPIRY_WARN_DAYS = 14

data/lib/dash/cli/doctor/host_checks.rb

@@ -127,13 +127,13 @@ class Dash::Cli::Doctor::HostChecks
         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"
@@ -154,7 +154,7 @@ class Dash::Cli::Doctor::HostChecks
       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

data/lib/dash/cli/main.rb

@@ -39,7 +39,7 @@ class Dash::Cli::Main < Dash::Cli::Base
         modify(lock: true) do
           run_hook "pre-deploy", secrets: true
 
-          say "Ensure kamal-proxy is running...", :magenta
+          say "Ensure dash-proxy is running...", :magenta
           invoke "dash:cli:proxy:boot", [], invoke_options
 
           invoke "dash:cli:accessory:boot", [ "all" ], invoke_options if boot_accessories
@@ -63,7 +63,7 @@ class Dash::Cli::Main < Dash::Cli::Base
     end
   end
 
-  desc "redeploy", "Deploy app to servers without bootstrapping servers, starting kamal-proxy and pruning"
+  desc "redeploy", "Deploy app to servers without bootstrapping servers, starting dash-proxy and pruning"
   option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip image build and push"
   option :no_cache, type: :boolean, default: false, desc: "Build without using Docker's build cache"
   def redeploy
@@ -226,7 +226,7 @@ class Dash::Cli::Main < Dash::Cli::Base
     end
   end
 
-  desc "remove", "Remove kamal-proxy, app, accessories, and registry session from servers"
+  desc "remove", "Remove dash-proxy, app, accessories, and registry session from servers"
   option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
   def remove
     confirming "This will remove all containers and images. Are you sure?" do
@@ -249,7 +249,7 @@ class Dash::Cli::Main < Dash::Cli::Base
   option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
   option :rolling, type: :boolean, default: false, desc: "Upgrade one host at a time"
   def upgrade
-    confirming "This will replace Traefik with kamal-proxy and restart all accessories" do
+    confirming "This will replace Traefik with dash-proxy and restart all accessories" do
       modify(lock: true) do
         if options[:rolling]
           DASH.hosts.each do |host|
@@ -293,7 +293,7 @@ class Dash::Cli::Main < Dash::Cli::Base
   desc "lock", "Manage the deploy lock"
   subcommand "lock", Dash::Cli::Lock
 
-  desc "proxy", "Manage kamal-proxy"
+  desc "proxy", "Manage dash-proxy"
   subcommand "proxy", Dash::Cli::Proxy
 
   desc "prune", "Prune old application images and containers"

data/lib/dash/cli/proxy/legacy_rename.rb

@@ -0,0 +1,58 @@
+# Stage 3c migration: brings a host that still carries pre-rename container
+# identity onto the renamed one.
+#
+# Three steps, run in this order on each proxy host before the normal boot:
+#
+#   1. Bridge the network. Docker cannot rename one, so `dash` is created
+#      alongside `kamal` and everything still attached to the old network joins
+#      the new one. App containers would be replaced by the next deploy anyway;
+#      accessories are not, which is the whole reason this exists — without it a
+#      renamed proxy cannot reach `db` or `redis`.
+#
+#   2. Copy the config volume. It holds the routing table and the ACME account
+#      and certificate cache, so losing it means re-issuing every certificate
+#      and spending Let's Encrypt rate limits to get back to where we were. This
+#      must happen before the new container starts.
+#
+#   3. Replace the legacy container. A rename means the old container has to
+#      release ports 80/443 before the new one can claim them, and no
+#      port-holder handoff spans two container names — so this stage accepts a
+#      brief outage per host. Deliberate; see zoolutions/dash#124.
+#
+# Every step is idempotent and guarded on its destination not already existing,
+# so a second deploy is a no-op. Nothing here removes the legacy network or
+# volume: an operator who wants them gone removes them by hand, and stage 3d
+# deletes this class outright.
+class Dash::Cli::Proxy::LegacyRename
+  attr_reader :host, :sshkit
+  delegate :execute, to: :sshkit
+
+  def initialize(host, sshkit)
+    @host = host
+    @sshkit = sshkit
+  end
+
+  def run
+    bridge_network
+    adopt_config_volume
+    replace_legacy_container
+  end
+
+  private
+    def bridge_network
+      execute *DASH.docker.connect_legacy_network_containers
+    end
+
+    def adopt_config_volume
+      execute *DASH.proxy(host).copy_legacy_config_volume
+    end
+
+    # The drain timeout the proxy is configured with, so a busy host is not cut
+    # off mid-request any more abruptly than a normal reboot would.
+    def replace_legacy_container
+      proxy = DASH.proxy(host)
+
+      execute *proxy.remove_legacy_container(timeout: DASH.config.drain_timeout)
+      execute *proxy.remove_legacy_holder_container
+    end
+end

data/lib/dash/cli/proxy/loadbalancer_reboot.rb

@@ -38,7 +38,7 @@ class Dash::Cli::Proxy::LoadbalancerReboot
     wait_until_ready
     verify_service if re_register_service
 
-    # kamal-proxy keeps its service state in the config volume, which the
+    # dash-proxy keeps its service state in the config volume, which the
     # replacement container re-mounts - every app's routes survive.
     services = capture_with_info(*DASH.loadbalancer.list).strip
     info "Services registered on the load balancer at #{host} after reboot:\n#{services}"

data/lib/dash/cli/proxy/reboot.rb

@@ -31,7 +31,7 @@ class Dash::Cli::Proxy::Reboot
     # Pull before stopping the old container: a registry outage or rate limit
     # can then no longer strand the host with no proxy at all.
     def pull_image
-      info "Pulling kamal-proxy image on #{host}..."
+      info "Pulling dash-proxy image on #{host}..."
       execute *proxy.pull
     end
 
@@ -64,7 +64,7 @@ class Dash::Cli::Proxy::Reboot
 
     # Phase 1 replacement: stop the old container, start the new one. Brief gap.
     def stop_and_replace
-      info "Stopping and removing kamal-proxy on #{host}, if running..."
+      info "Stopping and removing dash-proxy on #{host}, if running..."
       execute *proxy.stop(timeout: DASH.config.drain_timeout + 10), raise_on_non_zero_exit: false
       execute *proxy.remove_container
 
@@ -87,7 +87,7 @@ class Dash::Cli::Proxy::Reboot
     end
 
     def handoff_generation
-      info "Handing off kamal-proxy on #{host} to a new generation (zero downtime)..."
+      info "Handing off dash-proxy on #{host} to a new generation (zero downtime)..."
       execute *proxy.remove_stopped_container(name: proxy.next_container_name), raise_on_non_zero_exit: false
       execute *proxy.run(digest: drift.expected_digest, name: proxy.next_container_name)
       wait_until_ready(name: proxy.next_container_name)
@@ -102,7 +102,7 @@ class Dash::Cli::Proxy::Reboot
     # The old proxy still owns the published ports, so the holder cannot bind
     # them until it is gone. One final replacement with a brief gap.
     def migrate_to_holder
-      info "Migrating kamal-proxy on #{host} to the port-holder architecture (brief gap)..."
+      info "Migrating dash-proxy on #{host} to the port-holder architecture (brief gap)..."
       execute *proxy.stop(timeout: DASH.config.drain_timeout + 10), raise_on_non_zero_exit: false
       execute *proxy.remove_container
 
@@ -124,7 +124,7 @@ class Dash::Cli::Proxy::Reboot
       begin
         capture_with_info(*proxy.list(**{ name: name }.compact), verbosity: :debug)
       rescue SSHKit::Command::Failed
-        raise Dash::Cli::BootError, "kamal-proxy on #{host} did not become ready within #{READY_TIMEOUT} seconds" if Time.now >= deadline
+        raise Dash::Cli::BootError, "dash-proxy on #{host} did not become ready within #{READY_TIMEOUT} seconds" if Time.now >= deadline
         sleep 0.5
         retry
       end
@@ -146,7 +146,7 @@ class Dash::Cli::Proxy::Reboot
         endpoint = capture_with_info(*app.container_id_for_version(version, only_running: true), raise_on_non_zero_exit: false).strip.presence
         next unless endpoint
 
-        info "Re-registering #{role.container_prefix} with kamal-proxy on #{host}..."
+        info "Re-registering #{role.container_prefix} with dash-proxy on #{host}..."
         execute *app.deploy(target: endpoint)
         registered_services << role.container_prefix
       end
@@ -158,7 +158,7 @@ class Dash::Cli::Proxy::Reboot
         target = capture_with_info(*accessory.container_id_for(container_name: accessory_config.service_name, only_running: true), raise_on_non_zero_exit: false).strip.presence
         next unless target
 
-        info "Re-registering #{accessory_config.service_name} with kamal-proxy on #{host}..."
+        info "Re-registering #{accessory_config.service_name} with dash-proxy on #{host}..."
         execute *accessory.deploy(target: target)
         registered_services << accessory_config.service_name
       end
@@ -176,7 +176,7 @@ class Dash::Cli::Proxy::Reboot
       missing = registered_services - listed
 
       if missing.any?
-        raise Dash::Cli::BootError, "kamal-proxy on #{host} is missing services after reboot: #{missing.join(", ")}"
+        raise Dash::Cli::BootError, "dash-proxy on #{host} is missing services after reboot: #{missing.join(", ")}"
       end
     end
 end

data/lib/dash/cli/proxy.rb

@@ -21,6 +21,10 @@ class Dash::Cli::Proxy < Dash::Cli::Base
       on(proxy_hosts) do |host|
         execute *DASH.registry.login
 
+        # Before anything reads the new container, volume or network: bring a
+        # host still on pre-rename identity across. A no-op once it has been.
+        Dash::Cli::Proxy::LegacyRename.new(host, self).run
+
         proxy = DASH.proxy(host)
         drift = Dash::Cli::Proxy::Drift.new(host, self)
 
@@ -33,7 +37,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
           version = capture_with_info(*proxy.version).strip.presence
 
           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}"
+            raise "dash-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?
@@ -51,12 +55,12 @@ class Dash::Cli::Proxy < Dash::Cli::Base
       end
 
       if stale_hosts.any?
-        say "kamal-proxy on #{stale_hosts.sort.join(", ")} is running with a configuration that no longer matches the deploy config. " \
+        say "dash-proxy on #{stale_hosts.sort.join(", ")} is running with a configuration that no longer matches the deploy config. " \
             "Automatic reboot is disabled (proxy: reboot_on_deploy: false) - run `dash proxy reboot` to apply the new configuration.", :yellow
       end
 
       drifted_hosts.sort.each do |host|
-        say "kamal-proxy configuration changed, rebooting on #{host}...", :magenta
+        say "dash-proxy configuration changed, rebooting on #{host}...", :magenta
         run_hook "pre-proxy-reboot", hosts: host
         on(host) do |h|
           Dash::Cli::Proxy::Reboot.new(h, self).run
@@ -129,7 +133,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
     end
   end
 
-  desc "boot_config <set|get|reset>", "Manage kamal-proxy boot configuration"
+  desc "boot_config <set|get|reset>", "Manage dash-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: Dash::Configuration::Proxy::Run::DEFAULT_HTTP_PORT, desc: "HTTP port to publish on the host"
@@ -163,7 +167,7 @@ class Dash::Cli::Proxy < Dash::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 #{Dash::Utils.optionize(run_command_options).join(" ")}" if run_command_options.any?
+      run_command = "dash-proxy run #{Dash::Utils.optionize(run_command_options).join(" ")}" if run_command_options.any?
 
       on(DASH.proxy_hosts) do |host|
         proxy = DASH.proxy(host)
@@ -229,7 +233,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
           host_list = Array(hosts).join(",")
           run_hook "pre-proxy-reboot", hosts: host_list
           on(hosts) do |host|
-            info "Rebooting kamal-proxy on #{host}..."
+            info "Rebooting dash-proxy on #{host}..."
             Dash::Cli::Proxy::Reboot.new(host, self).run
           end
           run_hook "post-proxy-reboot", hosts: host_list
@@ -249,7 +253,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
     end
   end
 
-  desc "upgrade", "Upgrade to kamal-proxy on servers (stop container, remove container, start new container, reboot app)", hide: true
+  desc "upgrade", "Upgrade to dash-proxy on servers (stop container, remove container, start new container, reboot app)", hide: true
   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
@@ -269,7 +273,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
           info "Stopping and removing Traefik on #{host}, if running..."
           execute *proxy.cleanup_traefik
 
-          info "Stopping and removing kamal-proxy on #{host}, if running..."
+          info "Stopping and removing dash-proxy on #{host}, if running..."
           execute *proxy.stop, raise_on_non_zero_exit: false
           execute *proxy.remove_container
           execute *proxy.remove_image
@@ -566,7 +570,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
       on(cert_store_host) do |host|
         commands = load_balancing ? DASH.loadbalancer : DASH.proxy(host)
 
-        # kamal-proxy import runs offline against the data directory - importing
+        # dash-proxy import runs offline against the data directory - importing
         # under a live proxy risks a torn store. --verify only reads the archive.
         unless verify
           if capture_with_info(*commands.container_id(only_running: true), raise_on_non_zero_exit: false).strip.present?
@@ -652,7 +656,7 @@ class Dash::Cli::Proxy < Dash::Cli::Base
       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
+    # Mirrors dash-proxy's own flag groups (import.go), so a contradictory
     # invocation fails before anything is uploaded.
     def validate_import_certs_options!
       if options[:traefik_acme].present? == options[:archive].present?

data/lib/dash/commander.rb

@@ -110,7 +110,7 @@ class Dash::Commander
     @commands[:lock] ||= Dash::Commands::Lock.new(config)
   end
 
-  # Guards the kamal-proxy container, which a host runs once for every
+  # Guards the dash-proxy container, which a host runs once for every
   # destination deployed onto it. Every destination contends for this one.
   def server_lock
     @commands[:server_lock] ||= Dash::Commands::Lock.new(config, scope: :server)

data/lib/dash/commands/accessory/proxy.rb

@@ -11,6 +11,6 @@ module Dash::Commands::Accessory::Proxy
 
   private
     def proxy_exec(*command)
-      docker :exec, proxy_container_name, "kamal-proxy", *command
+      docker :exec, proxy_container_name, "dash-proxy", *command
     end
 end

data/lib/dash/commands/app/execution.rb

@@ -13,7 +13,7 @@ module Dash::Commands::App::Execution
       ("--detach" if detach),
       ("--rm" unless detach),
       "--name", container_name_for_exec,
-      "--network", "kamal",
+      "--network", "dash",
       *role&.env_args(host),
       *argumentize("--env", env),
       *role.logging_args,

data/lib/dash/commands/app/proxy.rb

@@ -39,6 +39,6 @@ module Dash::Commands::App::Proxy
 
   private
     def proxy_exec(*command)
-      docker :exec, proxy_container_name, "kamal-proxy", *command
+      docker :exec, proxy_container_name, "dash-proxy", *command
     end
 end

data/lib/dash/commands/app.rb

@@ -18,7 +18,7 @@ class Dash::Commands::App < Dash::Commands::Base
       "--detach",
       "--restart", role.restart_policy,
       "--name", container_name,
-      "--network", "kamal",
+      "--network", "dash",
       *([ "--hostname", hostname ] if hostname),
       "--env", "KAMAL_CONTAINER_NAME=\"#{container_name}\"",
       "--env", "KAMAL_VERSION=\"#{config.version}\"",

data/lib/dash/commands/docker.rb

@@ -41,10 +41,44 @@ class Dash::Commands::Docker < Dash::Commands::Base
   end
 
   def create_network
-    docker :network, :create, :kamal
+    docker :network, :create, Dash::Configuration::Proxy::NETWORK
+  end
+
+  # Stage 3c: docker cannot rename a network, so `dash` is created alongside
+  # `kamal` and everything still on the old one is joined to the new one.
+  #
+  # App containers would be replaced by the next deploy anyway; accessories are
+  # not, and that is the whole point — without this a renamed proxy cannot
+  # reach `db` or `redis`. Connecting a container that is already attached
+  # fails, so each connect tolerates its own failure rather than aborting the
+  # sweep. The old network is never removed; that is documented manual cleanup
+  # and stage 3d's code change.
+  def connect_legacy_network_containers
+    any \
+      combine(
+        legacy_network_exists,
+        pipe(legacy_network_container_names, connect_each_to_network)
+      ),
+      [ :true ]
   end
 
   private
+    def legacy_network_exists
+      docker :network, :inspect, Dash::Configuration::Proxy::LEGACY_NETWORK, ">", "/dev/null", "2>&1"
+    end
+
+    def legacy_network_container_names
+      docker :network, :inspect, Dash::Configuration::Proxy::LEGACY_NETWORK,
+        "--format", "'{{range .Containers}}{{.Name}}{{\"\\n\"}}{{end}}'"
+    end
+
+    # Already-attached containers make `network connect` fail; tolerate each
+    # one's failure rather than letting it abort the sweep.
+    def connect_each_to_network
+      [ :xargs, "-r", "-I{}", "sh", "-c",
+        "'docker network connect #{Dash::Configuration::Proxy::NETWORK} {} 2>/dev/null || true'" ]
+    end
+
     def get_docker
       shell \
         any \

data/lib/dash/commands/loadbalancer.rb

@@ -14,7 +14,7 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
     docker \
       :run,
       "--name", container_name,
-      "--network", "kamal",
+      "--network", "dash",
       "--detach",
       "--restart", "unless-stopped",
       "--label", label,
@@ -38,28 +38,28 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
   end
 
   def deploy(targets: [])
-    docker :exec, container_name, "kamal-proxy", "deploy", loadbalancer_config.config.service,
+    docker :exec, container_name, "dash-proxy", "deploy", loadbalancer_config.config.service,
       *loadbalancer_config.deploy_command_args(targets: targets)
   end
 
   # `retry` takes a host, or --all; the rest take no arguments.
   def domains(subcommand, *args)
-    docker :exec, container_name, "kamal-proxy", "domains", subcommand, *args
+    docker :exec, container_name, "dash-proxy", "domains", subcommand, *args
   end
 
   def list(json: false)
-    docker :exec, container_name, "kamal-proxy", :list, *("--json" if json)
+    docker :exec, container_name, "dash-proxy", :list, *("--json" if json)
   end
 
   # Cache policy is edge-only under load balancing (see the layering contract),
   # so the cache admin surface lives here - registered under the bare service
   # name, unlike the per-role services on the proxy hosts.
   def cache_stats(count: false, json: false)
-    docker :exec, container_name, "kamal-proxy", :cache, :stats, *optionize({ count: count || nil, json: json || nil }.compact)
+    docker :exec, container_name, "dash-proxy", :cache, :stats, *optionize({ count: count || nil, json: json || nil }.compact)
   end
 
   def cache_purge(service, path_prefix: nil)
-    docker :exec, container_name, "kamal-proxy", :cache, :purge, service, *optionize({ "path-prefix": path_prefix }.compact)
+    docker :exec, container_name, "dash-proxy", :cache, :purge, service, *optionize({ "path-prefix": path_prefix }.compact)
   end
 
   def config_digest
@@ -94,16 +94,24 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
   end
 
   # Prune by the label the container was actually created with - on a shared
-  # proxy host that is the kamal-proxy title, and pruning by the loadbalancer
-  # title would leave the container behind for `run` to collide with.
+  # proxy host that is the dash-proxy title, and pruning by the loadbalancer
+  # title would leave the container behind for `run` to collide with. Both the
+  # current and the pre-rename title are pruned, so a container created before
+  # the rename is not left behind to collide either.
   def remove_container
-    docker :container, :prune, "--force", "--filter", "label=#{label}"
+    combine \
+      prune_containers_titled(image_title),
+      prune_containers_titled(legacy_image_title)
   end
 
   # Image label filters match labels baked into the image, and the load balancer
-  # runs the kamal-proxy image whichever host it sits on.
+  # runs the dash-proxy image whichever host it sits on. Both titles are matched
+  # so a host still carrying a pre-rename image is cleaned up too; Docker ANDs
+  # multiple `--filter label=` values, so that is two commands.
   def remove_image
-    docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=kamal-proxy"
+    combine \
+      prune_images_titled(Dash::Configuration::Proxy::IMAGE_TITLE),
+      prune_images_titled(Dash::Configuration::Proxy::LEGACY_IMAGE_TITLE)
   end
 
   def ensure_directory
@@ -153,28 +161,50 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
       loadbalancer_config.on_proxy_host?
     end
 
+    # The full `key=value` the container is created with, so `--label #{label}`
+    # stays correct. The prune helpers take a bare title instead.
     def label
+      "org.opencontainers.image.title=#{image_title}"
+    end
+
+    def image_title
       if on_proxy_host?
-        "org.opencontainers.image.title=kamal-proxy"
+        Dash::Configuration::Proxy::IMAGE_TITLE
       else
-        "org.opencontainers.image.title=kamal-loadbalancer"
+        Dash::Configuration::Proxy::LOADBALANCER_IMAGE_TITLE
       end
     end
 
-    # kamal-proxy keeps its state under /home/kamal-proxy/.config/kamal-proxy
+    def legacy_image_title
+      if on_proxy_host?
+        Dash::Configuration::Proxy::LEGACY_IMAGE_TITLE
+      else
+        Dash::Configuration::Proxy::LEGACY_LOADBALANCER_IMAGE_TITLE
+      end
+    end
+
+    def prune_containers_titled(title)
+      docker :container, :prune, "--force", "--filter", "label=org.opencontainers.image.title=#{title}"
+    end
+
+    def prune_images_titled(title)
+      docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=#{title}"
+    end
+
+    # dash-proxy keeps its state under /home/dash-proxy/.config/dash-proxy
     # whichever host it runs on - only the volume name differs, so a dedicated
     # load balancer and a shared proxy host never fight over the same volume.
     # (The apps-config mount comes with run_args, via the proxy's run surface.)
     def config_volume
       if on_proxy_host?
-        [ "--volume", "kamal-proxy-config:/home/kamal-proxy/.config/kamal-proxy" ]
+        [ "--volume", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy" ]
       else
-        [ "--volume", "kamal-loadbalancer-config:/home/kamal-proxy/.config/kamal-proxy" ]
+        [ "--volume", "dash-loadbalancer-config:/home/dash-proxy/.config/dash-proxy" ]
       end
     end
 
     # The certificate store lives in whichever config volume this loadbalancer
-    # actually mounts — the shared kamal-proxy one on a proxy host.
+    # actually mounts — the shared dash-proxy one on a proxy host.
     def cert_store_volume_args
       config_volume
     end

data/lib/dash/commands/lock.rb

@@ -4,7 +4,7 @@ require "base64"
 
 class Dash::Commands::Lock < Dash::Commands::Base
   # The deploy lock is scoped to service+destination, so two destinations can
-  # deploy at once. Server-scoped resources — above all the single kamal-proxy
+  # deploy at once. Server-scoped resources — above all the single dash-proxy
   # container a host runs for every destination on it — need a lock that every
   # destination contends for, hence :server.
   SCOPES = %i[ destination server ].freeze

data/lib/dash/commands/proxy/cert_transfer.rb

@@ -18,7 +18,7 @@ module Dash::Commands::Proxy::CertTransfer
   # Through the RPC socket of the running container, under the proxy's own
   # certificate write lock, so a backup taken mid-renewal is never torn.
   def export_certs
-    docker :exec, container_name, "kamal-proxy", :export, :certs, certs_archive_container_path
+    docker :exec, container_name, "dash-proxy", :export, :certs, certs_archive_container_path
   end
 
   # Reads the data directory offline over the config volume — only safe when
@@ -28,10 +28,10 @@ module Dash::Commands::Proxy::CertTransfer
       *cert_store_volume_args,
       *config.proxy_boot.apps_volume.docker_args,
       *one_off_image,
-      "kamal-proxy", :export, :certs, certs_archive_container_path
+      "dash-proxy", :export, :certs, certs_archive_container_path
   end
 
-  # Offline by design (kamal-proxy import has no RPC path): the one-off
+  # Offline by design (dash-proxy import has no RPC path): the one-off
   # container mounts the config volume — creating it when no proxy has booted
   # yet, which is the Traefik-migration case — and the staged source streams
   # through stdin.
@@ -42,7 +42,7 @@ module Dash::Commands::Proxy::CertTransfer
     # run whatever follows on the target host.
     import_command = shell [
       "cat > #{CONTAINER_IMPORT_PATH} &&",
-      "kamal-proxy import certs",
+      "dash-proxy import certs",
       *optionize({ source_flag => CONTAINER_IMPORT_PATH, resolver: resolver, force: force || nil, verify: verify || nil }.compact, with: "=")
     ]