dash 4.0.0 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 749c8e286224f96b085fc8c325affcfde1cafaa18824e1405f880cc1aea966b1
-  data.tar.gz: 0dab0ae01b69f742e58551caaeee3352f98548c5a6265e98fcbe2de3025b50d1
+  metadata.gz: d2fca4cca966b5e857e1d537799367c1493701a1e18e48a691c53dddac6b2c36
+  data.tar.gz: 2627d3e285ddbee1da9b4bc0705c38fb3825345f554b3b7e8f85598810c0b354
 SHA512:
-  metadata.gz: 7b8a1e07a72a34388817185a8e476b4c400a90061292fe9d143a9a67ab1e5e5d2a87cba154077d151922a306f577dce9d04d60ecef371296ca9b2e3c49a277cb
-  data.tar.gz: 5b396df37122ed76ff2e5b7b2b694940a9eb1bcaa5bf31ed0de3f01039bf59836224f225da0a59acc24445f1d6a3dfe19165f2c83fd2e4a4023e68a1ec41c2c6
+  metadata.gz: d40d1805b3f3b1ed9f0a79bf53a6d96709ea7c3693cc0d8319791e92b10c345aaa2743ef8fdbc568cf9b79de5b37659fb2fbbb75b7d4fac0f111322bc2f807c2
+  data.tar.gz: 2972113fc39cd3dcbdd6476d91634e29f757989ca4c84e9dbd1dac6443f6169b967a3f3c9b9c5d7ed9913d212e18d8239c1cd142981a7a14f90dea56769fca1b

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)
@@ -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?
 
@@ -155,6 +172,10 @@ class Dash::Cli::Doctor::HostChecks
 
       if proxy_running
         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/proxy.rb

@@ -76,6 +76,10 @@ class Dash::Cli::Proxy < Dash::Cli::Base
           info "Starting loadbalancer on #{host}..."
           execute *DASH.registry.login
 
+          # Bring a pre-rename volume across before the container can be created
+          # against an empty one. A no-op once it has been.
+          execute *DASH.loadbalancer.copy_legacy_config_volume
+
           # 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.

data/lib/dash/commands/base.rb

@@ -126,6 +126,34 @@ module Dash::Commands
         [ :sh, "-c", "'#{command.flatten.join(" ").gsub("'", "'\\\\''")}'" ]
       end
 
+      # Adopts a pre-rename docker volume: creates `volume` from `legacy` if, and
+      # only if, `volume` is absent and `legacy` is present. A host with neither
+      # exits 0. The first word must be a program, never `!` — see
+      # Dash::Commands::Proxy#copy_legacy_config_volume.
+      def copy_legacy_volume(legacy:, volume:, image:)
+        any \
+          volume_exists(volume),
+          negate(volume_exists(legacy)),
+          [ "(", *combine(docker(:volume, :create, volume), copy_between_volumes(legacy, volume, image: image)), ")" ]
+      end
+
+      def negate(command)
+        [ "!", *command ]
+      end
+
+      def volume_exists(name)
+        docker :volume, :inspect, name, ">", "/dev/null", "2>&1"
+      end
+
+      def copy_between_volumes(from, to, image:)
+        docker \
+          :run, "--rm", "--user", "root", "--entrypoint", "sh",
+          "--volume", "#{from}:/from",
+          "--volume", "#{to}:/to",
+          image,
+          "-c", "'cp -a /from/. /to/'"
+      end
+
       def docker(*args)
         args.compact.unshift :docker
       end

data/lib/dash/commands/loadbalancer.rb

@@ -37,6 +37,16 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
     combine start, run, by: "||"
   end
 
+  # A dedicated load balancer host went through the 4.0 rename with nothing
+  # adopting its `kamal-loadbalancer-config` volume: the per-host proxies got
+  # Dash::Cli::Proxy::LegacyRename, the load balancer got a fresh empty volume
+  # and lost its routing table, dynamic domains and ACME cache. On a shared
+  # proxy host the volume is the proxy's own and LegacyRename already copied
+  # it, so this is a no-op there.
+  def copy_legacy_config_volume
+    copy_legacy_volume(legacy: legacy_config_volume_name, volume: config_volume_name, image: loadbalancer_config.run.image)
+  end
+
   def deploy(targets: [])
     docker :exec, container_name, "dash-proxy", "deploy", loadbalancer_config.config.service,
       *loadbalancer_config.deploy_command_args(targets: targets)
@@ -196,11 +206,15 @@ class Dash::Commands::Loadbalancer < Dash::Commands::Base
     # 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", "dash-proxy-config:/home/dash-proxy/.config/dash-proxy" ]
-      else
-        [ "--volume", "dash-loadbalancer-config:/home/dash-proxy/.config/dash-proxy" ]
-      end
+      [ "--volume", "#{config_volume_name}:/home/dash-proxy/.config/dash-proxy" ]
+    end
+
+    def config_volume_name
+      on_proxy_host? ? Dash::Configuration::Proxy::CONFIG_VOLUME : Dash::Configuration::Proxy::LOADBALANCER_CONFIG_VOLUME
+    end
+
+    def legacy_config_volume_name
+      on_proxy_host? ? Dash::Configuration::Proxy::LEGACY_CONFIG_VOLUME : Dash::Configuration::Proxy::LEGACY_LOADBALANCER_CONFIG_VOLUME
     end
 
     # The certificate store lives in whichever config volume this loadbalancer

data/lib/dash/commands/proxy.rb

@@ -51,21 +51,18 @@ class Dash::Commands::Proxy < Dash::Commands::Base
   # 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.
+  #
+  # Shape: `exists || ! legacy_exists || ( create && copy )`. The chain has to
+  # start with a real program: SSHKit prefixes the first word with
+  # `/usr/bin/env`, and `env !` is "No such file or directory" (exit 127), not
+  # shell negation. 4.0.0 led with `! docker volume inspect …`, so the whole
+  # chain failed silently into `|| true`, the proxy booted onto a volume docker
+  # created empty, and every host lost its routing table and ACME cache on the
+  # first deploy. The subshell groups create-and-copy because `&&` and `||`
+  # share precedence and associate left — without it a host that already has
+  # the new volume would still run the copy over live state.
   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 ]
+    copy_legacy_volume(legacy: legacy, volume: volume, image: proxy_image)
   end
 
   # Stops and removes a pre-rename proxy container so the renamed one can claim
@@ -106,9 +103,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
 
@@ -323,27 +323,10 @@ 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

data/lib/dash/version.rb

@@ -1,3 +1,3 @@
 module Dash
-  VERSION = "4.0.0"
+  VERSION = "4.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dash
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.2
 platform: ruby
 authors:
 - Mikael Henriksson