indocker 0.5.0 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5c86b947ae3162d9b81812db303c76b6825a1adc397cee5e3495bbd68437e96
-  data.tar.gz: 6dd6c07468dad622731efeb333a55279dabf18e74a940e62fa2308d572636713
+  metadata.gz: 738373105e7204366594f9789bc989e5c83453bc209fe0053485ef239156cc7a
+  data.tar.gz: 63dc5708eee2e75caab7a4bfaa8ac9c0e80c73fb46fbca987215d28309f07d86
 SHA512:
-  metadata.gz: 5546b2240618feacfe4efaa8c6b8ae82e58dde32eb383ff8cf7fd7295cf50caae8833ae0c8205031dea06bf7d7acb536935b0235c425bb5bf8506cb6cb22e7ef
-  data.tar.gz: e9d0d5ae9c6ee1b114d7551e954a282775a62c20840dc4c3a51675659f7ee99e5faa2691fb450e3e4c1ab1757b61d3459bc6aa1e0e67be0b75dd9d2de3036c74
+  metadata.gz: 477f6ae6ffd9fa9087743f06e354d751af669e803c4f9f5a7ee74c820bbfb5872674c379a0a006d46200f5fe174bf7f1779b088df093b6dfeabe51c2fcd3e7b9
+  data.tar.gz: 355bee8644ae9e6e478cc878f41ee26c3f73bcf31c951561dc80fdc2c4bdde162e1d3d0bd387633d74501767c2b089a3f7cb20610795c5a6d2808a2b61dd079f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    indocker (0.5.0)
+    indocker (0.5.3)
       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

@@ -302,31 +302,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
-
-        deploy_threads[container] = Thread.new do
-          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
 
@@ -348,7 +345,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

data/lib/indocker/version.rb

@@ -1,3 +1,3 @@
 module Indocker
-  VERSION = "0.5.0"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indocker
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.3
 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-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh