dash 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6645870f4a0452741a5974d1d822e73fae0d4a04aec353196af3c02b3fb149d2
-  data.tar.gz: 23d1738ee101bf3eda8c03c363845dacc396403767271f7fbda7cd6656b9f0ff
+  metadata.gz: 0c267bf789f49a3eede649d1b17a328fefe83367ae48ddde1ae45feec2185460
+  data.tar.gz: 16248804c04178338ca3a4187f5299135c6c25cd1f8691b16394e9b70f61f5ff
 SHA512:
-  metadata.gz: 972ac9e339a4b56463c2f6caaf764a272cc01002101345e2696474fb01817d3a36dcb2c825b6f188521da82c764764323ff1b92b34ced280a330eb5a1d1bde0d
-  data.tar.gz: 7e698f1dbb093d79787f7c48aec3053742c90bfe08261b942d66a208b8051f53b8154969f796c82e29dac893b531dd9bd945a11015f598f4ac76577b271ce1fe
+  metadata.gz: 12bf8d9a911c032b75256ef587f796503c062c9988c8fc6ae88448b019ecb3bcab0a06a3055a38a806fa56ca0ecc4cbafa2cdb105428b86a3084ae32972e6bd1
+  data.tar.gz: 89013ac78a74c960f6598517216fe536cc3eba9f237bde7f62af00c57eaed164c85c7584ca3aadbb0d566261b5a9cec429125ff39fd5de6792c515be5a8fb02a

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

@@ -6,6 +6,8 @@
 # loadbalancer keeps its service state in the config volume, which the
 # replacement container re-mounts, so every app's routes survive the gap.
 class Kamal::Cli::Proxy::LoadbalancerReboot
+  READY_TIMEOUT = 30
+
   attr_reader :host, :sshkit
   delegate :execute, :capture_with_info, :info, :upload!, to: :sshkit
 
@@ -33,9 +35,53 @@ class Kamal::Cli::Proxy::LoadbalancerReboot
     Kamal::Cli::Proxy::LoadbalancerClaim.new(host, sshkit).claim_run_config(replace: true)
     execute *KAMAL.loadbalancer.run
 
+    wait_until_ready
+    verify_service if re_register_service
+
     # kamal-proxy keeps its service state in the config volume, which the
     # replacement container re-mounts - every app's routes survive.
     services = capture_with_info(*KAMAL.loadbalancer.list).strip
     info "Services registered on the load balancer at #{host} after reboot:\n#{services}"
   end
+
+  private
+    def wait_until_ready
+      deadline = Time.now + READY_TIMEOUT
+
+      begin
+        capture_with_info(*KAMAL.loadbalancer.list, verbosity: :debug)
+      rescue SSHKit::Command::Failed
+        raise Kamal::Cli::BootError, "the load balancer on #{host} did not become ready within #{READY_TIMEOUT} seconds" if Time.now >= deadline
+        sleep 0.5
+        retry
+      end
+    end
+
+    # A deploy failure after this reboot must not strand a fresh LB with no
+    # services: re-register this app's routes now rather than trusting the
+    # deploy step that hasn't run yet, mirroring the per-host proxy reboot.
+    #
+    # Only this app's registration can be rebuilt from this deploy.yml - the
+    # owner files of other apps sharing the LB record tokens, not deploy
+    # commands - so anything else rides on the state-volume restore (which
+    # --recheck-targets-on-restore re-verifies). No owner record, or a foreign
+    # one, means nothing of ours to restore.
+    def re_register_service
+      owner = capture_with_info(*KAMAL.loadbalancer.read_service_owner, raise_on_non_zero_exit: false).strip
+      return false unless owner == KAMAL.loadbalancer_config.owner_token
+
+      info "Re-registering #{KAMAL.config.service} with the load balancer on #{host}..."
+      execute *KAMAL.loadbalancer.deploy(targets: KAMAL.loadbalancer_config.target_hosts)
+      true
+    end
+
+    # `list --json` returns {"services": {"<name>": ...}} - exact key
+    # membership, same as the per-host proxy reboot's verification.
+    def verify_service
+      listed = JSON.parse(capture_with_info(*KAMAL.loadbalancer.list(json: true))).fetch("services", {}).keys
+
+      unless listed.include?(KAMAL.config.service)
+        raise Kamal::Cli::BootError, "the load balancer on #{host} is missing service #{KAMAL.config.service} after reboot"
+      end
+    end
 end

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

@@ -83,6 +83,7 @@ class Kamal::Cli::Proxy::Reboot
       execute *proxy.run(digest: drift.expected_digest, name: proxy.next_container_name)
       wait_until_ready(name: proxy.next_container_name)
 
+      execute *proxy.disable_restart
       execute *proxy.drain(timeout: KAMAL.config.drain_timeout)
       execute *proxy.wait_for_exit
       execute *proxy.remove_stopped_container

data/lib/kamal/cli/proxy.rb

@@ -426,14 +426,7 @@ class Kamal::Cli::Proxy < Kamal::Cli::Base
       end
     when "deploy"
       if KAMAL.config.proxy.load_balancing?
-        targets = []
-        KAMAL.config.roles.each do |role|
-          next unless role.running_proxy?
-
-          role.hosts.each do |host|
-            targets << host
-          end
-        end
+        targets = KAMAL.loadbalancer_config.target_hosts
 
         on(KAMAL.config.proxy.effective_loadbalancer) do |host|
           Kamal::Cli::Proxy::LoadbalancerClaim.new(host, self).claim_service

data/lib/kamal/commands/loadbalancer.rb

@@ -44,8 +44,8 @@ class Kamal::Commands::Loadbalancer < Kamal::Commands::Base
     docker :exec, container_name, "kamal-proxy", "domains", subcommand
   end
 
-  def list
-    docker :exec, container_name, "kamal-proxy", :list
+  def list(json: false)
+    docker :exec, container_name, "kamal-proxy", :list, *("--json" if json)
   end
 
   # Cache policy is edge-only under load balancing (see the layering contract),

data/lib/kamal/commands/proxy.rb

@@ -113,6 +113,12 @@ class Kamal::Commands::Proxy < Kamal::Commands::Base
     container_id_for(container_name: proxy_run_config.holder_container_name, only_running: true)
   end
 
+  # Cancel the restart policy before draining: drain makes the proxy exit on
+  # its own, which - unlike `docker stop` - an active restart policy would undo.
+  def disable_restart
+    docker :update, "--restart=no", container_name
+  end
+
   def drain(timeout: nil)
     docker :exec, container_name, "kamal-proxy", :drain, *("--drain-timeout=#{timeout}s" if timeout)
   end

data/lib/kamal/configuration/loadbalancer.rb

@@ -12,12 +12,24 @@ class Kamal::Configuration::Loadbalancer < Kamal::Configuration::Proxy
 
   # The load balancer fans a single service out to many targets, so unlike the
   # per-app proxy deploy (which takes one target) it takes the full list and
-  # joins them into a single --target flag, honouring app_port for each.
+  # joins them into a single --target flag.
+  #
+  # Each target is a per-host proxy, reached on its published HTTP port
+  # (run.http_port, default 80) - the only cross-host surface it exposes.
+  # Never app_port: that is how a per-host proxy reaches the app container
+  # inside its own docker network, and nothing listens on it across hosts.
   def deploy_command_args(targets:)
-    target_arg = targets.map { |target| "#{target}:#{app_port}" }.join(",")
+    target_arg = targets.map { |target| "#{target}:#{run.http_port}" }.join(",")
     optionize ({ target: target_arg }).merge(deploy_options), with: "="
   end
 
+  # The hosts the load balancer forwards to: every host of every role that
+  # runs a proxy. One source of truth for the deploy step and the reboot
+  # re-registration, so their target lists cannot diverge.
+  def target_hosts
+    config.roles.select(&:running_proxy?).flat_map(&:hosts)
+  end
+
   def directory
     File.join config.run_directory, "loadbalancer"
   end

data/lib/kamal/version.rb

@@ -1,3 +1,3 @@
 module Kamal
-  VERSION = "3.0.0"
+  VERSION = "3.0.1"
 end

metadata

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