indocker 0.5.1 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a337d7800f2098f536fa3c6c070440e3a4e7ace58945d9a5e70127bb4350de3
-  data.tar.gz: '097fc4489b74f7ce5c49415e6ba2a662ecf15af95ec5b3d8a7128ec09b0b2f62'
+  metadata.gz: 70bf1241f0783dede869906f9f359c2a2137778a3059acaea9ae2fc7db30bb38
+  data.tar.gz: f4d906fc4ae36b9bf4482c7e5802c03b4a8633c7f839a0ffb71bbfc1571a5e30
 SHA512:
-  metadata.gz: fa93cd90ee34cf29b145dbc17493c18e419d1808b6cd3748d71ca712037f3b0bcf4ef8ceb88fdd00ef755dae44a1712d8547d6cfc2c46deba602ececdac26b4f
-  data.tar.gz: 2306ab2913402242c95a989c29b18cf918310889e4e1524764cdbe1e2e0d01d959d0cba2b912b4834d168e89c422bab0a4a7800f173faac9253135a1536d5a3b
+  metadata.gz: d45a4d6ab954e10b76fbaf2b4ca098c1368fd6b6365756f24bb210757d5f221d0fcfcf5b11b378cc5e31de38d72967158c90d91aaa3c9df53334f8a2596f12f0
+  data.tar.gz: a0ae86f49931e812d34761ff20f73f704a010b742edb1968dae8e70fc7798edbd75cab519f34632d8f6840ab0b87f5454c70773c50627ac10fc5693e263819cb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    indocker (0.5.1)
+    indocker (0.5.4)
       net-ssh
 
 GEM

data/lib/indocker/container_deployer.rb

@@ -20,29 +20,29 @@ class Indocker::ContainerDeployer
   def deploy(container, force_restart, skip_force_restart, progress)
     return if @deployed_containers[container]
 
-    # Deploy the container to all of its servers in parallel, each server in its
-    # own thread with its own ssh connection.
-    #
-    # Per-server exclusion: only one container may deploy on a given server at a
-    # time, so several container types don't spike CPU/memory by starting at once
-    # on the same host. We grab the lock of every target server before deploying.
-    # Locks are always taken in a consistent (sorted) order, so concurrent
-    # deployments of containers with overlapping server sets can't deadlock.
-    ordered_servers = container.servers.sort_by { |server| server_lock_key(server) }
-    locks = ordered_servers.map { |server| server_lock(server) }.uniq
-
-    with_locks(locks) do
-      threads = container.servers.map do |server|
-        Thread.new do
+    exit_codes =
+      if deploy_servers_in_parallel?(container)
+        # Stateless containers: deploy to all servers at once.
+        threads = container.servers.map do |server|
+          Thread.new do
+            deploy_to_server(container, server, force_restart, skip_force_restart, progress)
+          end
+        end
+
+        threads.map(&:value)
+      else
+        # Rolling deploy: one server at a time. Containers with rolling-restart
+        # hooks (e.g. draining/enabling an nginx upstream) sit behind a load
+        # balancer, so all of their servers must not restart simultaneously —
+        # otherwise there is a moment with no live backend (502s). Deploying
+        # server by server keeps the rest of the fleet serving.
+        container.servers.map do |server|
           deploy_to_server(container, server, force_restart, skip_force_restart, progress)
         end
       end
 
-      results = threads.map(&:value)
-
-      if results.any? { |exit_code| exit_code != 0 }
-        exit 1
-      end
+    if exit_codes.any? { |exit_code| exit_code != 0 }
+      exit 1
     end
 
     @deployed_containers[container] = true
@@ -56,52 +56,57 @@ class Indocker::ContainerDeployer
 
   private
 
+  # Whether the container may be deployed to all of its servers concurrently.
+  # An explicit :parallel_deploy start option wins; otherwise a container is
+  # deployed in parallel only when it has no rolling-restart hooks (containers
+  # with before/after start hooks are drained at a load balancer and must roll
+  # across servers one at a time).
+  def deploy_servers_in_parallel?(container)
+    option = container.get_start_option(:parallel_deploy)
+    return option unless option.nil?
+
+    container.before_start_proc.nil? && container.after_start_proc.nil?
+  end
+
   # Runs a single container deployment on a single server. Returns the remote
-  # exit code (0 on success). Runs inside its own thread with a dedicated ssh
-  # connection, so it must not touch shared mutable state except the
-  # thread-safe `progress`.
+  # exit code (0 on success).
+  #
+  # Per-server exclusion: only one container deploys on a given server at a time,
+  # so several container types don't spike CPU/memory by starting at once on the
+  # same host. Each invocation holds only its own server's lock, so concurrent
+  # deployments can't deadlock.
   def deploy_to_server(container, server, force_restart, skip_force_restart, progress)
-    progress.start_deploying_container(container, server)
-
-    deploy_server = @server_pool.create_connection!(server)
-    @logger.info("Deploying container: #{container.name.to_s.green} to #{server.user}@#{server.host}")
+    server_lock(server).synchronize do
+      progress.start_deploying_container(container, server)
+
+      deploy_server = @server_pool.create_connection!(server)
+      @logger.info("Deploying container: #{container.name.to_s.green} to #{server.user}@#{server.host}")
+
+      result = deploy_server
+        .run_container_remotely(
+          configuration_name: Indocker.configuration_name,
+          container_name:     container.name,
+          force_restart:      force_restart && !skip_force_restart.include?(container.name)
+        )
+
+      if result.exit_code == 0
+        @logger.info("Container deployment to #{server.user}@#{server.host} finished: #{container.name.to_s.green}")
+        progress.finish_deploying_container(container, server)
+      end
 
-    result = deploy_server
-      .run_container_remotely(
-        configuration_name: Indocker.configuration_name,
-        container_name:     container.name,
-        force_restart:      force_restart && !skip_force_restart.include?(container.name)
-      )
+      deploy_server.close_session
 
-    if result.exit_code == 0
-      @logger.info("Container deployment to #{server.user}@#{server.host} finished: #{container.name.to_s.green}")
-      progress.finish_deploying_container(container, server)
+      result.exit_code
     end
-
-    deploy_server.close_session
-
-    result.exit_code
-  end
-
-  def server_lock_key(server)
-    [server.host, server.port, server.user]
   end
 
   # Returns a process-wide singleton Mutex for the given server, so the same lock
   # is shared across every container targeting that server.
   def server_lock(server)
-    key = server_lock_key(server)
+    key = [server.host, server.port, server.user]
 
     @server_locks_mutex.synchronize do
       @server_locks[key] ||= Mutex.new
     end
   end
-
-  def with_locks(locks, &block)
-    if locks.empty?
-      block.call
-    else
-      locks.first.synchronize { with_locks(locks.drop(1), &block) }
-    end
-  end
 end

data/lib/indocker/launchers/configuration_deployer.rb

@@ -1,9 +1,7 @@
-require 'timeout'
 require 'benchmark'
 require 'tempfile'
 
 class Indocker::Launchers::ConfigurationDeployer
-  REMOTE_OPERATION_TIMEOUT = 60
 
   def initialize(logger:, global_logger:)
     Thread.abort_on_exception = true # abort all threads if exception occurs
@@ -107,12 +105,8 @@ class Indocker::Launchers::ConfigurationDeployer
 
   def wait_remote_operations(remote_operations)
     remote_operations.each do |remote_operation|
-      begin
-        Timeout::timeout(REMOTE_OPERATION_TIMEOUT) do
-          remote_operation.thread.join
-        end
-      rescue Timeout::Error
-        @global_logger.error("Deployment aborted. Remote operation :#{remote_operation.operation} on server #{remote_operation.server.user}@#{remote_operation.server.host} did not finish during #{REMOTE_OPERATION_TIMEOUT} seconds.")
+      if remote_operation.thread.join(Indocker.remote_operation_timeout).nil?
+        @global_logger.error("Deployment aborted. Remote operation :#{remote_operation.operation} on server #{remote_operation.server.user}@#{remote_operation.server.host} did not finish during #{Indocker.remote_operation_timeout} seconds.")
         exit 1
       end
     end
@@ -302,34 +296,28 @@ class Indocker::Launchers::ConfigurationDeployer
   # container to the deploy stage — so the next image is already building while
   # the previous container deploys.
   #
-  # The consumer starts a deploy per built container. Each deploy first waits for
-  # all of the container's dependencies to finish deploying (depends_on ordering),
-  # then deploys. Independent containers deploy concurrently; per-server exclusion
-  # (one container at a time per host) is enforced inside ContainerDeployer.
+  # The consumer deploys containers strictly one at a time, in the order they
+  # were built (which is dependency order, so depends_on is respected). Only a
+  # single container is ever restarting across the whole fleet at any moment —
+  # the invariant the original sequential deploy guaranteed. This matters for
+  # zero-downtime web apps: deploying several containers concurrently can flap an
+  # app's health (its health check depends on backends that would be restarting
+  # in parallel), leaving nginx with a live-but-unhealthy upstream and serving
+  # 502s during the deploy.
+  #
+  # Only image builds run ahead of deploys (below) — that is where the pipeline
+  # speedup comes from. A single container still fans out to its own servers in
+  # parallel (see ContainerDeployer), so multi-server containers stay fast.
   def pipeline_build_and_deploy(configuration, deployer, build_server_pool, containers,
     skip_build, skip_deploy, force_restart, skip_force_restart)
 
     ordered_containers = build_deploy_order(containers)
 
-    deploy_queue   = Queue.new
-    deploy_threads = {}
+    deploy_queue = Queue.new
 
     consumer = Thread.new do
       while (container = deploy_queue.pop) != :done
-        # Dependencies are always built (and therefore queued) before their
-        # dependents, so their deploy threads already exist here.
-        dependency_threads = container
-          .dependent_containers
-          .map { |dependency| deploy_threads[dependency] }
-          .compact
-
-        # Pass container/dependency_threads as thread arguments so each thread
-        # captures its own value — the shared loop variables get reassigned on
-        # the next iteration (eventually to :done) before these threads run.
-        deploy_threads[container] = Thread.new(container, dependency_threads) do |container, dependency_threads|
-          dependency_threads.each(&:join)
-          deploy_container(deployer, container, force_restart, skip_force_restart)
-        end
+        deploy_container(deployer, container, force_restart, skip_force_restart)
       end
     end
 
@@ -351,7 +339,6 @@ class Indocker::Launchers::ConfigurationDeployer
 
     deploy_queue.push(:done)
     consumer.join
-    deploy_threads.values.each(&:join)
   end
 
   # Returns the containers to deploy in dependency order (each container's
@@ -467,11 +454,13 @@ class Indocker::Launchers::ConfigurationDeployer
 
     @logger.info("Updating crontab file #{deploy_user}:#{crontab_filepath}")
 
-    Indocker::Shell.command("scp #{tmp_crontab_file.path} #{deploy_user}:#{crontab_filepath}", @logger)
+    ssh_options = "-o BatchMode=yes -o ConnectTimeout=#{Indocker.ssh_connect_timeout}"
+
+    Indocker::Shell.command("scp #{ssh_options} #{tmp_crontab_file.path} #{deploy_user}:#{crontab_filepath}", @logger)
 
     tmp_crontab_file.unlink
 
-    Indocker::Shell.command("ssh #{deploy_user} 'crontab #{crontab_filepath}'", @logger)
+    Indocker::Shell.command("ssh #{ssh_options} #{deploy_user} 'crontab #{crontab_filepath}'", @logger)
   end
 
   def sync_indocker(servers)

data/lib/indocker/rsync.rb

@@ -29,7 +29,20 @@ class Indocker::Rsync
         sync_local_cp(from, to, raise_on_error: raise_on_error)
       end
     else
-      command = "rsync --delete-after -a -e 'ssh -p #{session.port}' #{from} #{session.user}@#{session.host}:#{to}"
+      # BatchMode/ConnectTimeout: an unreachable server must fail in seconds with
+      # a clear rsync error instead of hanging silently (or prompting for a password)
+      # until the deployment-wide remote operation timeout kills the whole deploy.
+      # ServerAlive*: a path that accepts the connection and then stops delivering
+      # packets (seen when a cloud NAT address half-works) would otherwise hang
+      # just as long — keepalives tear such a session down in ~30s.
+      ssh_command = [
+        "ssh -p #{session.port}",
+        "-o BatchMode=yes",
+        "-o ConnectTimeout=#{Indocker.ssh_connect_timeout}",
+        "-o ServerAliveInterval=10",
+        "-o ServerAliveCountMax=3",
+      ].join(' ')
+      command = "rsync --delete-after -a -e '#{ssh_command}' #{from} #{session.user}@#{session.host}:#{to}"
       Indocker.logger.debug("sync #{from} #{session.user}@#{session.host}:#{to}")
       Indocker::Shell.command(command, Indocker.logger, raise_on_error: raise_on_error)
     end

data/lib/indocker/ssh_session.rb

@@ -29,7 +29,14 @@ class Indocker::SshSession
 
     if host != LOCALHOST
       require 'net/ssh'
-      @ssh = Net::SSH.start(@host, @user, {port: @port})
+      @ssh = Net::SSH.start(@host, @user, {
+        port:               @port,
+        non_interactive:    true,
+        timeout:            Indocker.ssh_connect_timeout,
+        keepalive:          true,
+        keepalive_interval: 10,
+        keepalive_maxcount: 3,
+      })
     end
   end
 

data/lib/indocker/version.rb

@@ -1,3 +1,3 @@
 module Indocker
-  VERSION = "0.5.1"
+  VERSION = "0.5.4"
 end

data/lib/indocker.rb

@@ -135,6 +135,22 @@ module Indocker
       @redeploy_crontab_path = val
     end
 
+    def set_remote_operation_timeout(seconds)
+      @remote_operation_timeout = seconds
+    end
+
+    def remote_operation_timeout
+      @remote_operation_timeout || 300
+    end
+
+    def set_ssh_connect_timeout(seconds)
+      @ssh_connect_timeout = seconds
+    end
+
+    def ssh_connect_timeout
+      @ssh_connect_timeout || 15
+    end
+
     def redeploy_crontab_path
       @redeploy_crontab_path
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indocker
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.4
 platform: ruby
 authors:
 - Ruslan Gatiyatov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-07-06 00:00:00.000000000 Z
+date: 2026-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh