dash 3.2.1 → 4.0.1

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: "=")
     ]
 

data/lib/dash/commands/proxy.rb

@@ -28,7 +28,7 @@ class Dash::Commands::Proxy < Dash::Commands::Base
         *proxy_run_config.network_args,
         "--detach",
         "--restart", "unless-stopped",
-        "--volume", "kamal-proxy-config:/home/kamal-proxy/.config/kamal-proxy",
+        "--volume", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy",
         *config_digest_label_args(digest),
         *proxy_run_config.docker_options_args,
         *proxy_run_config.image,
@@ -38,6 +38,58 @@ class Dash::Commands::Proxy < Dash::Commands::Base
     end
   end
 
+  # Stage 3c migrations. All three are idempotent and guarded on the
+  # destination not existing, so a second deploy is a no-op. Stage 3d deletes
+  # them along with the legacy constants they read.
+
+  # Copies the pre-rename config volume into the new one, before anything
+  # starts. The volume holds the routing table and the ACME account and
+  # certificate cache; losing it means re-issuing every certificate and
+  # spending Let's Encrypt rate limits to get back where we were.
+  #
+  # Runs in the dash-proxy image itself — already pulled by this point in the
+  # boot sequence, and its ubuntu base has sh and cp. `--user root` because the
+  # image's own user cannot write the destination volume; `cp -a` preserves the
+  # uid, which the rename leaves at 1001.
+  # The guard is negated and leads the chain, with `|| true` last, because
+  # shell `&&` and `||` share precedence and associate left: written as
+  # `exists || legacy_exists && create && copy` it would parse as
+  # `((exists || legacy_exists) && create) && copy` and re-copy the legacy
+  # volume over live state on every deploy. Leading with `! exists` makes the
+  # whole chain a single left-associative AND, which short-circuits correctly.
+  def copy_legacy_config_volume(volume: Dash::Configuration::Proxy::CONFIG_VOLUME, legacy: Dash::Configuration::Proxy::LEGACY_CONFIG_VOLUME)
+    any \
+      combine(
+        negate(volume_exists(volume)),
+        volume_exists(legacy),
+        docker(:volume, :create, volume),
+        copy_between_volumes(legacy, volume)
+      ),
+      [ :true ]
+  end
+
+  # Stops and removes a pre-rename proxy container so the renamed one can claim
+  # ports 80/443. No port-holder handoff spans two container names, which is
+  # why this stage accepts a brief outage per host.
+  def remove_legacy_container(timeout: nil)
+    any \
+      combine(
+        container_exists(Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME),
+        docker(:container, :stop, *("--time=#{timeout}" if timeout), Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME),
+        docker(:container, :rm, Dash::Configuration::Proxy::LEGACY_CONTAINER_NAME)
+      ),
+      [ :true ]
+  end
+
+  def remove_legacy_holder_container
+    any \
+      combine(
+        container_exists(Dash::Configuration::Proxy::LEGACY_HOLDER_CONTAINER_NAME),
+        docker(:container, :rm, "--force", Dash::Configuration::Proxy::LEGACY_HOLDER_CONTAINER_NAME)
+      ),
+      [ :true ]
+  end
+
   def start
     docker :container, :start, container_name
   end
@@ -54,9 +106,12 @@ class Dash::Commands::Proxy < Dash::Commands::Base
     docker :ps, "--filter", "'name=^#{container_name}$'"
   end
 
-  def version
+  # `name:` so the doctor can also ask about the pre-rename container: during
+  # the stage-3c transition a host still runs kamal-proxy, and a check that only
+  # ever looks at dash-proxy concludes no proxy is running.
+  def version(name: container_name)
     pipe \
-      docker(:inspect, container_name, "--format '{{.Config.Image}}'"),
+      docker(:inspect, name, "--format '{{.Config.Image}}'"),
       [ :awk, "-F:", "'{print \$NF}'" ]
   end
 
@@ -77,15 +132,15 @@ class Dash::Commands::Proxy < Dash::Commands::Base
   end
 
   def list(name: container_name, json: false)
-    docker :exec, name, "kamal-proxy", :list, *("--json" if json)
+    docker :exec, name, "dash-proxy", :list, *("--json" if json)
   end
 
   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
 
   # One mount destination per line - what the running container was actually
@@ -108,12 +163,12 @@ class Dash::Commands::Proxy < Dash::Commands::Base
     docker \
       :run,
       "--name", proxy_run_config.holder_container_name,
-      "--network", "kamal",
+      "--network", "dash",
       "--detach",
       "--restart", "unless-stopped",
       *proxy_run_config.holder_docker_args,
       *proxy_run_config.image,
-      "kamal-proxy", "hold"
+      "dash-proxy", "hold"
   end
 
   def start_holder_or_run
@@ -131,7 +186,7 @@ class Dash::Commands::Proxy < Dash::Commands::Base
   end
 
   def drain(timeout: nil)
-    docker :exec, container_name, "kamal-proxy", :drain, *("--drain-timeout=#{timeout}s" if timeout)
+    docker :exec, container_name, "dash-proxy", :drain, *("--drain-timeout=#{timeout}s" if timeout)
   end
 
   def wait_for_exit(name: container_name)
@@ -161,15 +216,24 @@ class Dash::Commands::Proxy < Dash::Commands::Base
 
   # `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
 
+  # Docker ANDs multiple `--filter label=` values, so matching both the current
+  # and the pre-rename image title takes two commands rather than one filter
+  # with two values. Without the legacy pass, `dash proxy remove` on a host that
+  # has not yet been through the rename silently leaves the old container and
+  # image behind. Stage 3d drops the legacy half.
   def remove_container
-    docker :container, :prune, "--force", "--filter", "label=org.opencontainers.image.title=kamal-proxy"
+    combine \
+      prune_containers_titled(Dash::Configuration::Proxy::IMAGE_TITLE),
+      prune_containers_titled(Dash::Configuration::Proxy::LEGACY_IMAGE_TITLE)
   end
 
   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 cleanup_traefik
@@ -245,7 +309,7 @@ class Dash::Commands::Proxy < Dash::Commands::Base
     end
 
     def cert_store_volume_args
-      [ "--volume", "kamal-proxy-config:/home/kamal-proxy/.config/kamal-proxy" ]
+      [ "--volume", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy" ]
     end
 
     # Same fallback as #pull: without a run config the image comes from the
@@ -262,14 +326,52 @@ class Dash::Commands::Proxy < Dash::Commands::Base
       [ "--label", "#{CONFIG_DIGEST_LABEL}=#{digest}" ] if digest
     end
 
+    def negate(command)
+      [ "!", *command ]
+    end
+
+    def volume_exists(name)
+      docker :volume, :inspect, name, ">", "/dev/null", "2>&1"
+    end
+
+    def container_exists(name)
+      docker :container, :inspect, name, ">", "/dev/null", "2>&1"
+    end
+
+    def copy_between_volumes(from, to)
+      docker \
+        :run, "--rm", "--user", "root", "--entrypoint", "sh",
+        "--volume", "#{from}:/from",
+        "--volume", "#{to}:/to",
+        proxy_image,
+        "-c", "'cp -a /from/. /to/'"
+    end
+
+    # The image the volume copy borrows. The proxy this gem is pinned to is
+    # already pulled by the time the copy runs, and `rake release` gates on
+    # MINIMUM_VERSION being published, so this is always resolvable — unlike
+    # the legacy boot path's image, which is read from a file on the host.
+    def proxy_image
+      proxy_run_config&.image ||
+        "#{config.proxy_boot.image_default}:#{Dash::Configuration::Proxy::Run::MINIMUM_VERSION}"
+    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
+
     def docker_run(digest: nil)
       docker \
         :run,
         "--name", container_name,
-        "--network", "kamal",
+        "--network", "dash",
         "--detach",
         "--restart", "unless-stopped",
-        "--volume", "kamal-proxy-config:/home/kamal-proxy/.config/kamal-proxy",
+        "--volume", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy",
         *config_digest_label_args(digest),
         *config.proxy_boot.apps_volume.docker_args
     end

data/lib/dash/commands/prune.rb

@@ -15,7 +15,7 @@ class Dash::Commands::Prune < Dash::Commands::Base
 
   # Scoped to one role so a busy sibling role cannot push another role's newest
   # container past the retain window. That matters beyond disk hygiene: a
-  # container kamal-proxy has put to sleep is `exited`, so it is a removal
+  # container dash-proxy has put to sleep is `exited`, so it is a removal
   # candidate, and once it is gone every wake 404s. With `retain >= 1` a role's
   # newest container always survives, and the slept one is always the newest —
   # sleeping happens to the current release.

data/lib/dash/configuration/accessory.rb

@@ -1,7 +1,7 @@
 class Dash::Configuration::Accessory
   include Dash::Configuration::Validation
 
-  DEFAULT_NETWORK = "kamal"
+  DEFAULT_NETWORK = "dash"
 
   delegate :argumentize, :optionize, to: Dash::Utils
 
@@ -129,7 +129,7 @@ class Dash::Configuration::Accessory
 
     # The load balancer fans the app's own service out to role targets only
     # (see Dash::Cli::Proxy#loadbalancer), so an accessory is never behind it
-    # and must keep the host/TLS it registers with kamal-proxy directly.
+    # and must keep the host/TLS it registers with dash-proxy directly.
     def initialize_proxy
       Dash::Configuration::Proxy.new \
         config: config,

data/lib/dash/configuration/docs/accessory.yml

@@ -150,7 +150,7 @@ accessories:
     #
     # The network the accessory will be attached to.
     #
-    # Defaults to kamal:
+    # Defaults to dash:
     network: custom
 
     # Proxy
@@ -160,12 +160,12 @@ accessories:
     # app-level `proxy:` (see `dash docs proxy`), though root-only keys such as
     # `loadbalancer` and `reboot_on_deploy` have no effect inside an accessory.
     # Declaring a proxy here makes the accessory's hosts proxy hosts:
-    # `dash proxy boot` (and `dash deploy`) will run kamal-proxy on them
+    # `dash proxy boot` (and `dash deploy`) will run dash-proxy on them
     # automatically.
     #
     # Accessories are never load balanced. The loadbalancer fans the app's own
     # service out to its role targets, so an accessory always registers its
-    # hostname and TLS with the kamal-proxy on its own host — whether or not the
+    # hostname and TLS with the dash-proxy on its own host — whether or not the
     # loadbalancer is active for the app. Point the accessory's DNS record at the
     # accessory host, not at the loadbalancer.
     #

data/lib/dash/configuration/docs/configuration.yml

@@ -201,7 +201,7 @@ accessories:
 
 # Proxy
 #
-# Configuration for kamal-proxy, see dash docs proxy:
+# Configuration for dash-proxy, see dash docs proxy:
 proxy:
   ...