kamal 2.8.2 → 2.10.0

data/lib/kamal/sshkit_with_ext.rb

@@ -3,6 +3,7 @@ require "sshkit/dsl"
 require "net/scp"
 require "active_support/core_ext/hash/deep_merge"
 require "json"
+require "resolv"
 require "concurrent/atomic/semaphore"
 
 class SSHKit::Backend::Abstract
@@ -18,8 +19,11 @@ class SSHKit::Backend::Abstract
     JSON.pretty_generate(JSON.parse(capture(*args, **kwargs)))
   end
 
-  def puts_by_host(host, output, type: "App")
-    puts "#{type} Host: #{host}\n#{output}\n\n"
+  def puts_by_host(host, output, type: "App", quiet: false)
+    unless quiet
+      puts "#{type} Host: #{host}"
+    end
+    puts "#{output}\n\n"
   end
 
   # Our execution pattern is for the CLI execute args lists returned
@@ -58,10 +62,50 @@ class SSHKit::Backend::Abstract
 end
 
 class SSHKit::Backend::Netssh::Configuration
-  attr_accessor :max_concurrent_starts
+  attr_accessor :max_concurrent_starts, :dns_retries
 end
 
 class SSHKit::Backend::Netssh
+  module DnsRetriable
+    DNS_RETRY_BASE = 0.1
+    DNS_RETRY_MAX = 2.0
+    DNS_RETRY_JITTER = 0.1
+    DNS_ERROR_MESSAGE = /getaddrinfo|Temporary failure in name resolution|Name or service not known|nodename nor servname provided|No address associated|failed to look up|resolve/i
+
+    def with_dns_retry(hostname, retries: config.dns_retries, base: DNS_RETRY_BASE, max_sleep: DNS_RETRY_MAX, jitter: DNS_RETRY_JITTER)
+      attempts = 0
+      begin
+        attempts += 1
+        yield
+      rescue => error
+        raise unless retryable_dns_error?(error) && attempts <= retries
+
+        delay = dns_retry_sleep(attempts, base: base, jitter: jitter, max_sleep: max_sleep)
+        SSHKit.config.output.warn("Retrying DNS for #{hostname} (attempt #{attempts}/#{retries}) in #{format("%0.2f", delay)}s: #{error.message}")
+        sleep delay
+        retry
+      end
+    end
+
+    private
+      def retryable_dns_error?(error)
+        case error
+        when Resolv::ResolvError, Resolv::ResolvTimeout
+          true
+        when SocketError
+          error.message =~ DNS_ERROR_MESSAGE
+        else
+          error.cause && retryable_dns_error?(error.cause)
+        end
+      end
+
+      def dns_retry_sleep(attempt, base:, jitter:, max_sleep:)
+        sleep_for = [ base * (2 ** (attempt - 1)), max_sleep ].min
+        sleep_for += Kernel.rand * jitter
+        sleep_for
+      end
+  end
+
   module LimitConcurrentStartsClass
     attr_reader :start_semaphore
 
@@ -76,14 +120,31 @@ class SSHKit::Backend::Netssh
 
   class << self
     prepend LimitConcurrentStartsClass
+    prepend DnsRetriable
   end
 
+  module ConnectSsh
+    private
+      def connect_ssh(...)
+        Net::SSH.start(...)
+      end
+  end
+  include ConnectSsh
+
+  module DnsRetriableConnection
+    private
+      def connect_ssh(...)
+        self.class.with_dns_retry(host.hostname) { super }
+      end
+  end
+  prepend DnsRetriableConnection
+
   module LimitConcurrentStartsInstance
     private
       def with_ssh(&block)
         host.ssh_options = self.class.config.ssh_options.merge(host.ssh_options || {})
         self.class.pool.with(
-          method(:start_with_concurrency_limit),
+          method(:connect_ssh),
           String(host.hostname),
           host.username,
           host.netssh_options,
@@ -91,17 +152,18 @@ class SSHKit::Backend::Netssh
         )
       end
 
-      def start_with_concurrency_limit(*args)
+      def connect_ssh(...)
+        with_concurrency_limit { super }
+      end
+
+      def with_concurrency_limit(&block)
         if self.class.start_semaphore
-          self.class.start_semaphore.acquire do
-            Net::SSH.start(*args)
-          end
+          self.class.start_semaphore.acquire(&block)
         else
-          Net::SSH.start(*args)
+          yield
         end
       end
   end
-
   prepend LimitConcurrentStartsInstance
 end
 
@@ -148,3 +210,58 @@ module NetSshForwardingNoPuts
 end
 
 Net::SSH::Service::Forward.prepend NetSshForwardingNoPuts
+
+module SSHKitDslRoles
+  # Execute on hosts grouped by role.
+  #
+  # Unlike `on()` which deduplicates hosts, this allows the same host to have
+  # multiple concurrent connections when it appears in multiple roles.
+  #
+  # Options:
+  #   hosts: The hosts to run on (required)
+  #   parallel: When true, each role runs in its own thread with separate
+  #             connections. When false, hosts run in parallel but roles on each
+  #             host run sequentially (default: true)
+  #
+  # Example:
+  #   on_roles(roles) do |host, role|
+  #     # deploy role to host
+  #   end
+  def on_roles(roles, hosts:, parallel: true, &block)
+    if parallel
+      threads = roles.filter_map do |role|
+        if (role_hosts = role.hosts & hosts).any?
+          Thread.new do
+            on(role_hosts) { |host| instance_exec(host, role, &block) }
+          rescue StandardError => e
+            raise SSHKit::Runner::ExecuteError.new(e), "Exception while executing on #{role}: #{e.message}"
+          end
+        end
+      end
+
+      exceptions = []
+      threads.each do |t|
+        begin
+          t.join
+        rescue SSHKit::Runner::ExecuteError => e
+          exceptions << e
+        end
+      end
+
+      if exceptions.one?
+        raise exceptions.first
+      elsif exceptions.many?
+        raise exceptions.first, [ "Exceptions on #{exceptions.count} roles:", exceptions.map(&:message) ].join("\n")
+      end
+    else
+      # Host-first iteration: hosts run in parallel, roles on each host run sequentially
+      on(hosts) do |host|
+        roles.each do |role|
+          instance_exec(host, role, &block) if role.hosts.include?(host.to_s)
+        end
+      end
+    end
+  end
+end
+
+SSHKit::DSL.prepend SSHKitDslRoles

data/lib/kamal/utils.rb

@@ -21,11 +21,11 @@ module Kamal::Utils
   end
 
   # Returns a list of shell-dashed option arguments. If the value is true, it's treated like a value-less option.
-  def optionize(args, with: nil)
+  def optionize(args, with: nil, escape: true)
     options = if with
-      flatten_args(args).collect { |(key, value)| value == true ? "--#{key}" : "--#{key}#{with}#{escape_shell_value(value)}" }
+      flatten_args(args).collect { |(key, value)| value == true ? "--#{key}" : "--#{key}#{with}#{escape ? escape_shell_value(value) : value}" }
     else
-      flatten_args(args).collect { |(key, value)| [ "--#{key}", value == true ? nil : escape_shell_value(value) ] }
+      flatten_args(args).collect { |(key, value)| [ "--#{key}", value == true ? nil : escape ? escape_shell_value(value) : value ] }
     end
 
     options.flatten.compact

data/lib/kamal/version.rb

@@ -1,3 +1,3 @@
 module Kamal
-  VERSION = "2.8.2"
+  VERSION = "2.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamal
 version: !ruby/object:Gem::Version
-  version: 2.8.2
+  version: 2.10.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -299,6 +299,7 @@ files:
 - lib/kamal/configuration/logging.rb
 - lib/kamal/configuration/proxy.rb
 - lib/kamal/configuration/proxy/boot.rb
+- lib/kamal/configuration/proxy/run.rb
 - lib/kamal/configuration/registry.rb
 - lib/kamal/configuration/role.rb
 - lib/kamal/configuration/servers.rb