kamal 2.11.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f7525b3ed804be2810d0af353c254b8c7ebf4d5cf5916dbfa97d5bf4615d54
-  data.tar.gz: adfac172b3e4b45bc00092317bde87395fcedecf107b30c8500ab58097ef22d8
+  metadata.gz: 5d5aa65d23b2e2b68f8942617bb5ab754d6cb39e0444a61a95134590b6aadcf3
+  data.tar.gz: ecc576e1a0b82a0cc339d16a90cac74ecf47b7cdfb793fd5ff588fca61dc1d69
 SHA512:
-  metadata.gz: 05150f9253685ce18dd910cf809a99e51449b7452536e6c3f39c8e37d5ce3db4806bd8e198ed3e29aa872523eb8937db5b58faee036619f8e5b43d1084eebffc
-  data.tar.gz: 47e77a8d347c44aff4326f9927a0933c0240b5bfdb90f1b623e85ecdad8ba48c0e3443d43cd062b265aa29e2dbd47d778499be39a079d3cb93d8856cb0388108
+  metadata.gz: 8fe2acb803dd2b1930d3a9ecf62a6f35a2e1078fcd3e2950dfac0095e7ab5354d85e004b80581151e75a7b3cef247a0fefd442059a96ed39ffa9b10b67b12adc
+  data.tar.gz: 9ce3a70b368f59a310403f3c73e9ae438436dcaa174a039248d6b976f0e345a380d185d7409bdc7b84371a3708fd413fd9e96f682909b2820ddf12edb7a0dd7e

data/lib/kamal/cli/accessory.rb

@@ -4,7 +4,7 @@ require "concurrent/array"
 class Kamal::Cli::Accessory < Kamal::Cli::Base
   desc "boot [NAME]", "Boot new accessory service on host (use NAME=all to boot all accessories)"
   def boot(name, prepare: true)
-    with_lock do
+    modify(lock: true) do
       if name == "all"
         KAMAL.accessory_names.each { |accessory_name| boot(accessory_name) }
       else
@@ -42,7 +42,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "upload [NAME]", "Upload accessory files to host", hide: true
   def upload(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           accessory.files.each do |(local, config)|
@@ -61,7 +61,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "directories [NAME]", "Create accessory directories on host", hide: true
   def directories(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           accessory.directories.each do |(local, config)|
@@ -76,7 +76,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "reboot [NAME]", "Reboot existing accessory on host (stop container, remove container, start new container; use NAME=all to boot all accessories)"
   def reboot(name)
-    with_lock do
+    modify(lock: true) do
       if name == "all"
         KAMAL.accessory_names.each { |accessory_name| reboot(accessory_name) }
       else
@@ -91,7 +91,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "start [NAME]", "Start existing accessory container on host"
   def start(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *KAMAL.auditor.record("Started #{name} accessory"), verbosity: :debug
@@ -107,7 +107,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "stop [NAME]", "Stop existing accessory container on host"
   def stop(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *KAMAL.auditor.record("Stopped #{name} accessory"), verbosity: :debug
@@ -124,7 +124,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "restart [NAME]", "Restart existing accessory container on host"
   def restart(name)
-    with_lock do
+    modify(lock: true) do
       stop(name)
       start(name)
     end
@@ -146,36 +146,45 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
   desc "exec [NAME] [CMD...]", "Execute a custom command on servers within the accessory container (use --help to show options)"
   option :interactive, aliases: "-i", type: :boolean, default: false, desc: "Execute command over ssh for an interactive shell (use for console/bash)"
   option :reuse, type: :boolean, default: false, desc: "Reuse currently running container instead of starting a new one"
+  option :raw, type: :boolean, default: false, desc: "Output raw, unmodified stdout"
   def exec(name, *cmd)
-    pre_connect_if_required
+    raw = options[:raw]
 
-    cmd = Kamal::Utils.join_commands(cmd)
-    quiet = options[:quiet]
+    if raw && options[:interactive]
+      raise ArgumentError, "Raw is not compatible with interactive"
+    end
 
-    with_accessory(name) do |accessory, hosts|
-      case
-      when options[:interactive] && options[:reuse]
-        say "Launching interactive command via SSH from existing container...", :magenta
-        run_locally { exec accessory.execute_in_existing_container_over_ssh(cmd) }
-
-      when options[:interactive]
-        say "Launching interactive command via SSH from new container...", :magenta
-        on(accessory.hosts.first) { execute *KAMAL.registry.login }
-        run_locally { exec accessory.execute_in_new_container_over_ssh(cmd) }
-
-      when options[:reuse]
-        say "Launching command from existing container...", :magenta
-        on(hosts) do |host|
-          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
-          puts_by_host host, capture_with_info(*accessory.execute_in_existing_container(cmd)), quiet: quiet
-        end
+    with_raw_output(raw) do
+      pre_connect_if_required
 
-      else
-        say "Launching command from new container...", :magenta
-        on(hosts) do |host|
-          execute *KAMAL.registry.login
-          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
-          puts_by_host host, capture_with_info(*accessory.execute_in_new_container(cmd)), quiet: quiet
+      cmd = Kamal::Utils.join_commands(cmd)
+      quiet = options[:quiet]
+
+      with_accessory(name) do |accessory, hosts|
+        case
+        when options[:interactive] && options[:reuse]
+          say "Launching interactive command via SSH from existing container...", :magenta
+          run_locally { exec accessory.execute_in_existing_container_over_ssh(cmd) }
+
+        when options[:interactive]
+          say "Launching interactive command via SSH from new container...", :magenta
+          on(accessory.hosts.first) { execute *KAMAL.registry.login }
+          run_locally { exec accessory.execute_in_new_container_over_ssh(cmd) }
+
+        when options[:reuse]
+          say "Launching command from existing container...", :magenta
+          on(hosts) do |host|
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+            puts_by_host host, capture_with_info(*accessory.execute_in_existing_container(cmd), strip: !raw), quiet: quiet, raw: raw
+          end
+
+        else
+          say "Launching command from new container...", :magenta
+          on(hosts) do |host|
+            execute *KAMAL.registry.login
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+            puts_by_host host, capture_with_info(*accessory.execute_in_new_container(cmd), strip: !raw), quiet: quiet, raw: raw
+          end
         end
       end
     end
@@ -213,7 +222,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "pull_image [NAME]", "Pull accessory image on host", hide: true
   def pull_image(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *KAMAL.auditor.record("Pull #{name} accessory image"), verbosity: :debug
@@ -227,7 +236,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
   option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
   def remove(name)
     confirming "This will remove all containers, images and data directories for #{name}. Are you sure?" do
-      with_lock do
+      modify(lock: true) do
         if name == "all"
           KAMAL.accessory_names.each { |accessory_name| remove_accessory(accessory_name) }
         else
@@ -239,7 +248,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "remove_container [NAME]", "Remove accessory container from host", hide: true
   def remove_container(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *KAMAL.auditor.record("Remove #{name} accessory container"), verbosity: :debug
@@ -251,7 +260,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "remove_image [NAME]", "Remove accessory image from host", hide: true
   def remove_image(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *KAMAL.auditor.record("Removed #{name} accessory image"), verbosity: :debug
@@ -263,7 +272,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
 
   desc "remove_service_directory [NAME]", "Remove accessory directory used for uploaded files and data directories from host", hide: true
   def remove_service_directory(name)
-    with_lock do
+    modify(lock: true) do
       with_accessory(name) do |accessory, hosts|
         on(hosts) do
           execute *accessory.remove_service_directory
@@ -277,7 +286,7 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
   option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
   def upgrade(name)
     confirming "This will restart all accessories" do
-      with_lock do
+      modify(lock: true) do
         host_groups = options[:rolling] ? KAMAL.accessory_hosts : [ KAMAL.accessory_hosts ]
         host_groups.each do |hosts|
           host_list = Array(hosts).join(",")

data/lib/kamal/cli/app.rb

@@ -1,7 +1,7 @@
 class Kamal::Cli::App < Kamal::Cli::Base
   desc "boot", "Boot app on servers (or reboot app if already running)"
   def boot
-    with_lock do
+    modify(lock: true) do
       say "Get most recent version available as an image...", :magenta unless options[:version]
       using_version(version_or_latest) do |version|
         say "Start container with version #{version} (or reboot if already running)...", :magenta
@@ -42,7 +42,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "start", "Start existing app container on servers"
   def start
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.boot.parallel_roles) do |host, role|
         app = KAMAL.app(role: role, host: host)
         execute *KAMAL.auditor.record("Started app version #{KAMAL.config.version}"), verbosity: :debug
@@ -61,7 +61,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "stop", "Stop app container on servers"
   def stop
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.boot.parallel_roles) do |host, role|
         app = KAMAL.app(role: role, host: host)
         execute *KAMAL.auditor.record("Stopped app", role: role), verbosity: :debug
@@ -93,59 +93,68 @@ class Kamal::Cli::App < Kamal::Cli::Base
   option :reuse, type: :boolean, default: false, desc: "Reuse currently running container instead of starting a new one"
   option :env, aliases: "-e", type: :hash, desc: "Set environment variables for the command"
   option :detach, type: :boolean, default: false, desc: "Execute command in a detached container"
+  option :raw, type: :boolean, default: false, desc: "Output raw, unmodified stdout"
   def exec(*cmd)
-    pre_connect_if_required
+    raw = options[:raw]
 
     if (incompatible_options = [ :interactive, :reuse ].select { |key| options[:detach] && options[key] }.presence)
       raise ArgumentError, "Detach is not compatible with #{incompatible_options.join(" or ")}"
     end
 
+    if raw && (incompatible_options = [ :interactive, :detach ].select { |key| options[key] }.presence)
+      raise ArgumentError, "Raw is not compatible with #{incompatible_options.join(" or ")}"
+    end
+
     if cmd.empty?
       raise ArgumentError, "No command provided. You must specify a command to execute."
     end
 
-    cmd = Kamal::Utils.join_commands(cmd)
-    env = options[:env]
-    detach = options[:detach]
-    quiet = options[:quiet]
-    case
-    when options[:interactive] && options[:reuse]
-      say "Get current version of running container...", :magenta unless options[:version]
-      using_version(options[:version] || current_running_version) do |version|
-        say "Launching interactive command with version #{version} via SSH from existing container on #{KAMAL.primary_host}...", :magenta
-        run_locally { exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_existing_container_over_ssh(cmd, env: env) }
-      end
+    with_raw_output(raw) do
+      pre_connect_if_required
+
+      cmd = Kamal::Utils.join_commands(cmd)
+      env = options[:env]
+      detach = options[:detach]
+      quiet = options[:quiet]
+      case
+      when options[:interactive] && options[:reuse]
+        say "Get current version of running container...", :magenta unless options[:version]
+        using_version(options[:version] || current_running_version) do |version|
+          say "Launching interactive command with version #{version} via SSH from existing container on #{KAMAL.primary_host}...", :magenta
+          run_locally { exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_existing_container_over_ssh(cmd, env: env) }
+        end
 
-    when options[:interactive]
-      say "Get most recent version available as an image...", :magenta unless options[:version]
-      using_version(version_or_latest) do |version|
-        say "Launching interactive command with version #{version} via SSH from new container on #{KAMAL.primary_host}...", :magenta
-        on(KAMAL.primary_host) { execute *KAMAL.registry.login }
-        run_locally do
-          exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_new_container_over_ssh(cmd, env: env)
+      when options[:interactive]
+        say "Get most recent version available as an image...", :magenta unless options[:version]
+        using_version(version_or_latest) do |version|
+          say "Launching interactive command with version #{version} via SSH from new container on #{KAMAL.primary_host}...", :magenta
+          on(KAMAL.primary_host) { execute *KAMAL.registry.login }
+          run_locally do
+            exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_new_container_over_ssh(cmd, env: env)
+          end
         end
-      end
 
-    when options[:reuse]
-      say "Get current version of running container...", :magenta unless options[:version]
-      using_version(options[:version] || current_running_version) do |version|
-        say "Launching command with version #{version} from existing container...", :magenta
+      when options[:reuse]
+        say "Get current version of running container...", :magenta unless options[:version]
+        using_version(options[:version] || current_running_version) do |version|
+          say "Launching command with version #{version} from existing container...", :magenta
 
-        on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
-          puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_existing_container(cmd, env: env)), quiet: quiet
+          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_existing_container(cmd, env: env), strip: !raw), quiet: quiet, raw: raw
+          end
         end
-      end
-
-    else
-      say "Get most recent version available as an image...", :magenta unless options[:version]
-      using_version(version_or_latest) do |version|
-        say "Launching command with version #{version} from new container...", :magenta
-        on(KAMAL.app_hosts) { execute *KAMAL.registry.login }
 
-        on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-          execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
-          puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_new_container(cmd, env: env, detach: detach)), quiet: quiet
+      else
+        say "Get most recent version available as an image...", :magenta unless options[:version]
+        using_version(version_or_latest) do |version|
+          say "Launching command with version #{version} from new container...", :magenta
+          on(KAMAL.app_hosts) { execute *KAMAL.registry.login }
+
+          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_new_container(cmd, env: env, detach: detach), strip: !raw), quiet: quiet, raw: raw
+          end
         end
       end
     end
@@ -233,7 +242,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "remove", "Remove app containers and images from servers"
   def remove
-    with_lock do
+    modify(lock: true) do
       stop
       remove_containers
       remove_images
@@ -243,7 +252,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "live", "Set the app to live mode"
   def live
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
         execute *KAMAL.app(role: role, host: host).live if role.running_proxy?
       end
@@ -256,7 +265,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
   def maintenance
     maintenance_options = { drain_timeout: options[:drain_timeout] || KAMAL.config.drain_timeout, message: options[:message] }
 
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
         execute *KAMAL.app(role: role, host: host).maintenance(**maintenance_options) if role.running_proxy?
       end
@@ -265,7 +274,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "remove_container [VERSION]", "Remove app container with given version from servers", hide: true
   def remove_container(version)
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
         execute *KAMAL.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
         execute *KAMAL.app(role: role, host: host).remove_container(version: version)
@@ -275,7 +284,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "remove_containers", "Remove all app containers from servers", hide: true
   def remove_containers
-    with_lock do
+    modify(lock: true) do
       on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
         execute *KAMAL.auditor.record("Removed all app containers", role: role), verbosity: :debug
         execute *KAMAL.app(role: role, host: host).remove_containers
@@ -285,7 +294,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "remove_images", "Remove all app images from servers", hide: true
   def remove_images
-    with_lock do
+    modify(lock: true) do
       on(hosts_removing_all_roles) do
         execute *KAMAL.auditor.record("Removed all app images"), verbosity: :debug
         execute *KAMAL.app.remove_images
@@ -295,7 +304,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
   desc "remove_app_directories", "Remove the app directories from servers", hide: true
   def remove_app_directories
-    with_lock do
+    modify(lock: true) do
       on(hosts_removing_all_roles) do |host|
         execute *KAMAL.server.remove_app_directory, raise_on_non_zero_exit: false
         execute *KAMAL.auditor.record("Removed #{KAMAL.config.app_directory}"), verbosity: :debug
@@ -347,7 +356,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
     def with_lock_if_stopping
       if options[:stop]
-        with_lock { yield }
+        modify(lock: true) { yield }
       else
         yield
       end

data/lib/kamal/cli/base.rb

@@ -6,6 +6,10 @@ module Kamal::Cli
     include SSHKit::DSL
 
     VERBOSITY = { verbose: :debug, quiet: :error }.freeze
+    AUTOMATIC_DEPLOY_LOCK_MESSAGE = "Automatic deploy lock"
+
+    class LockHeldError < StandardError; end
+    class LockMissingError < StandardError; end
 
     def self.exit_on_failure?() true end
     def self.dynamic_command_class() Kamal::Cli::Alias::Command end
@@ -24,6 +28,10 @@ module Kamal::Cli
 
     class_option :skip_hooks, aliases: "-H", type: :boolean, default: false, desc: "Don't run hooks"
 
+    class_option :lock_wait, type: :boolean, default: false, desc: "Wait for the deploy lock if it's already held instead of failing immediately"
+    class_option :lock_wait_timeout, type: :numeric, default: 900, desc: "Maximum seconds to wait for the deploy lock when --lock-wait is set"
+    class_option :lock_wait_interval, type: :numeric, default: 15, desc: "Seconds between deploy lock polls when --lock-wait is set"
+
     def initialize(args = [], local_options = {}, config = {})
       if config[:current_command].is_a?(Kamal::Cli::Alias::Command)
         # When Thor generates a dynamic command, it doesn't attempt to parse the arguments.
@@ -60,6 +68,10 @@ module Kamal::Cli
           commander.specific_hosts    = options[:hosts]&.split(",")
           commander.specific_roles    = options[:roles]&.split(",")
           commander.specific_primary! if options[:primary]
+
+          commander.lock_wait          = options[:lock_wait]
+          commander.lock_wait_timeout  = options[:lock_wait_timeout]
+          commander.lock_wait_interval = options[:lock_wait_interval]
         end
       end
 
@@ -72,6 +84,23 @@ module Kamal::Cli
         puts "  Finished all in #{sprintf("%.1f seconds", runtime)}"
       end
 
+      def modify(lock: false)
+        KAMAL.modify(command: command, subcommand: subcommand) do
+          lock ? with_lock { yield } : yield
+        end
+      end
+
+      def say(message = "", *)
+        super unless options[:raw]
+        KAMAL.log(message.to_s)
+      end
+
+      # Raw output is written straight to stdout for piping, so silence SSHKit's
+      # command echoing that would otherwise corrupt the byte stream.
+      def with_raw_output(raw, &block)
+        raw ? KAMAL.with_verbosity(:error, &block) : block.call
+      end
+
       def with_lock
         if KAMAL.holding_lock?
           yield
@@ -106,31 +135,90 @@ module Kamal::Cli
       def acquire_lock
         ensure_run_directory
 
-        raise_if_locked do
-          say "Acquiring the deploy lock...", :magenta
-          on(KAMAL.primary_host) { execute *KAMAL.lock.acquire("Automatic deploy lock", KAMAL.config.version), verbosity: :debug }
+        if KAMAL.lock_wait
+          acquire_lock_with_wait
+        else
+          raise_if_locked do
+            say "Acquiring the deploy lock...", :magenta
+            execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+          end
         end
 
         KAMAL.holding_lock = true
       end
 
+      def acquire_lock_with_wait
+        timeout = KAMAL.lock_wait_timeout
+        interval = KAMAL.lock_wait_interval
+        deadline = Time.now + timeout
+        details_shown = false
+
+        say "Acquiring the deploy lock (waiting up to #{timeout}s)...", :magenta
+
+        loop do
+          execute_lock_acquire(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+          break
+        rescue LockHeldError
+          unless details_shown
+            status = capture_lock_status
+
+            say "Deploy lock is held by:", :magenta
+            puts status
+
+            unless status.include?(AUTOMATIC_DEPLOY_LOCK_MESSAGE)
+              raise LockError, "Deploy lock held manually, not waiting. Run 'kamal lock help' for more information"
+            end
+
+            details_shown = true
+          end
+
+          remaining = (deadline - Time.now).to_i
+          if remaining <= 0
+            say "Timed out after #{timeout}s waiting for the deploy lock", :red
+            raise LockError, "Timed out waiting for deploy lock"
+          end
+
+          say "Retrying in #{interval}s (#{remaining}s remaining)...", :magenta
+          sleep [ interval, remaining ].min
+        end
+      end
+
       def release_lock
         say "Releasing the deploy lock...", :magenta
-        on(KAMAL.primary_host) { execute *KAMAL.lock.release, verbosity: :debug }
+        execute_lock_release
 
         KAMAL.holding_lock = false
       end
 
       def raise_if_locked
         yield
+      rescue LockHeldError
+        say "Deploy lock already in place!", :red
+        puts capture_lock_status
+        raise LockError, "Deploy lock found. Run 'kamal lock help' for more information"
+      end
+
+      def execute_lock_acquire(message)
+        on(KAMAL.primary_host) { execute *KAMAL.lock.acquire(message, KAMAL.config.version), verbosity: :debug }
       rescue SSHKit::Runner::ExecuteError => e
-        if e.message =~ /cannot create directory/
-          say "Deploy lock already in place!", :red
-          on(KAMAL.primary_host) { puts capture_with_debug(*KAMAL.lock.status) }
-          raise LockError, "Deploy lock found. Run 'kamal lock help' for more information"
-        else
-          raise e
-        end
+        raise LockHeldError if e.message =~ /cannot create directory/
+        raise
+      end
+
+      def execute_lock_release
+        on(KAMAL.primary_host) { execute *KAMAL.lock.release, verbosity: :debug }
+      rescue SSHKit::Runner::ExecuteError => e
+        raise LockMissingError if e.message =~ /No such file or directory/
+        raise
+      end
+
+      def capture_lock_status
+        status = nil
+        on(KAMAL.primary_host) { status = capture_with_debug(*KAMAL.lock.status) }
+        status
+      rescue SSHKit::Runner::ExecuteError => e
+        raise LockMissingError if e.message =~ /No such file or directory/
+        raise
       end
 
       def run_hook(hook, **extra_details)

data/lib/kamal/cli/build.rb

@@ -18,7 +18,8 @@ class Kamal::Cli::Build < Kamal::Cli::Base
     pre_connect_if_required
 
     ensure_docker_installed
-    login_to_registry_locally if KAMAL.builder.login_to_registry_locally?
+    setup_local_registry      if KAMAL.registry.local?
+    login_to_registry_locally if !KAMAL.registry.local? && KAMAL.builder.login_to_registry_locally?
 
     run_hook "pre-build"
 
@@ -194,13 +195,15 @@ class Kamal::Cli::Build < Kamal::Cli::Base
       end
     end
 
+    def setup_local_registry
+      run_locally do
+        execute *KAMAL.registry.setup
+      end
+    end
+
     def login_to_registry_locally
       run_locally do
-        if KAMAL.registry.local?
-          execute *KAMAL.registry.setup
-        else
-          execute *KAMAL.registry.login
-        end
+        execute *KAMAL.registry.login
       end
     end
 

data/lib/kamal/cli/lock.rb

@@ -2,22 +2,17 @@ class Kamal::Cli::Lock < Kamal::Cli::Base
   desc "status", "Report lock status"
   def status
     handle_missing_lock do
-      on(KAMAL.primary_host) do
-        puts capture_with_debug(*KAMAL.lock.status)
-      end
+      puts capture_lock_status
     end
   end
 
   desc "acquire", "Acquire the deploy lock"
   option :message, aliases: "-m", type: :string, desc: "A lock message", required: true
   def acquire
-    message = options[:message]
     ensure_run_directory
 
     raise_if_locked do
-      on(KAMAL.primary_host) do
-        execute *KAMAL.lock.acquire(message, KAMAL.config.version), verbosity: :debug
-      end
+      execute_lock_acquire(options[:message])
       say "Acquired the deploy lock"
     end
   end
@@ -25,9 +20,7 @@ class Kamal::Cli::Lock < Kamal::Cli::Base
   desc "release", "Release the deploy lock"
   def release
     handle_missing_lock do
-      on(KAMAL.primary_host) do
-        execute *KAMAL.lock.release, verbosity: :debug
-      end
+      execute_lock_release
       say "Released the deploy lock"
     end
   end
@@ -35,11 +28,7 @@ class Kamal::Cli::Lock < Kamal::Cli::Base
   private
     def handle_missing_lock
       yield
-    rescue SSHKit::Runner::ExecuteError => e
-      if e.message =~ /No such file or directory/
-        say "There is no deploy lock"
-      else
-        raise
-      end
+    rescue LockMissingError
+      say "There is no deploy lock"
     end
 end