dash 3.2.1 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3a110ddc9f31ad566bce549f84ef6b216a395d9201e02747f1e062d89406f07
-  data.tar.gz: 40fcfdf62082cf07a8e7e19455fd9398567e6ace96be7426165d27309f0ef29e
+  metadata.gz: 8651f7a91510814ccfa26283d3aef0f364caa5c99419a76ee6cdb15820680148
+  data.tar.gz: aef6a718f6f4d1427d6e20f73e3096eed8436426e32b6c6ea0a40f52e3588261
 SHA512:
-  metadata.gz: c9a19af8c3f5c210d01d8aa9dcdee7e2ad76018050cf7df70ca3bc04a85089702a8ec32b14eab38701e48ffa2306880333e5fd2309e109fb83b720ea27041f33
-  data.tar.gz: bf7739b92e6685eb9bc62453eed18c7ba127faf29d42c15023b890632b4c2f3b8e1481e9fc3481b189b27a86dd39c04a57d08d5c00b46fe89b2a294ed807144e
+  metadata.gz: da7a30a00bf6f622aeeb13889670133285a202c5c4481a7b83cc8d980624db48a0c5d8007e0efaf723489d4ea20672999dc8791e5ff4240b6f4fa65ba54a7380
+  data.tar.gz: cdcf6391c305f5e84125687bb6f4174729a7c09819a08a5c8a26bd8de2fd5b10933606387f581187c94151574c2607d803689e3d97c2cffa00beab9e26375f09

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

@@ -61,12 +61,17 @@ class Dash::Cli::Doctor::HostChecks
 
     def proxy_checks
       version, version_error = capture_proxy_version
+      # A host that has not been through the stage-3c rename is still running
+      # kamal-proxy. Without asking about it too, the version check reports "not
+      # running" and the ports check blames a foreign process for the ports that
+      # container legitimately holds — failing the very deploy that migrates it.
+      legacy_version = version.present? ? nil : capture_legacy_proxy_version
 
       {
         proxy_image: proxy_image_check,
-        proxy_version: proxy_version_check(version, version_error),
+        proxy_version: proxy_version_check(version, version_error, legacy_version),
         proxy_socket: proxy_socket_check(proxy_running: version.present?),
-        ports: ports_check(proxy_running: version.present?)
+        ports: ports_check(proxy_running: version.present?, legacy_proxy_running: legacy_version.present?)
       }
     end
 
@@ -76,6 +81,14 @@ class Dash::Cli::Doctor::HostChecks
       [ nil, e ]
     end
 
+    # Best-effort: a host with no legacy container simply reports nothing, and
+    # any error here must not turn into a failing check of its own.
+    def capture_legacy_proxy_version
+      capture_with_info(*DASH.proxy(host).version(name: Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME)).strip.presence
+    rescue StandardError
+      nil
+    end
+
     def proxy_image_check
       image = expected_proxy_image
 
@@ -88,11 +101,15 @@ class Dash::Cli::Doctor::HostChecks
       result :proxy_image, :fail, "#{e.class}: #{e.message}"
     end
 
-    def proxy_version_check(version, error)
+    def proxy_version_check(version, error, legacy_version = nil)
       minimum = Dash::Configuration::Proxy::Run::MINIMUM_VERSION
 
       if error
         result :proxy_version, :warn, "could not determine the running version (#{error.message})"
+      elsif version.nil? && legacy_version.present?
+        result :proxy_version, :ok,
+          "#{Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME} #{legacy_version} is running; it is renamed to " \
+          "#{Dash::Configuration::Proxy::CONTAINER_NAME} on the next deploy, which briefly interrupts this host"
       elsif version.nil?
         result :proxy_version, :ok, "not running (will be started on deploy)"
       elsif Dash::Utils.older_version?(version, minimum)
@@ -127,13 +144,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"
@@ -146,7 +163,7 @@ class Dash::Cli::Doctor::HostChecks
       DASH.config.roles.any? { |role| role.running_proxy? && role.proxy.proxy_config["sleep"].present? }
     end
 
-    def ports_check(proxy_running:)
+    def ports_check(proxy_running:, legacy_proxy_running: false)
       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?
 
@@ -154,7 +171,11 @@ 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 legacy_proxy_running
+        result :ports, :ok,
+          "ports #{http_port}/#{https_port} held by the running #{Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME}, " \
+          "replaced on the next deploy"
       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 \