indocker 0.1.9 → 0.1.14

data/lib/indocker/deploy_context.rb

@@ -2,42 +2,14 @@ require 'digest'
 require 'fileutils'
 
 class Indocker::DeployContext
-  attr_reader :server, :session
+  attr_reader :configuration, :logger
 
-  def initialize(logger:, configuration:, server:)
+  def initialize(logger:, configuration:)
     @logger = logger
     @configuration = configuration
-    @server = server
     @restart_policy = Indocker::Containers::RestartPolicy.new(configuration, logger)
   end
 
-  def create_session!
-    return unless @server
-    
-    @session = Indocker::SshSession.new(
-      host: @server.host,
-      user: @server.user,
-      port: @server.port,
-      logger: @logger
-    )
-  end
-
-  def exec!(command)
-    @session.exec!(command)
-  end
-
-  def close_session
-    @session.close if @session
-  end
-
-  def set_busy(flag)
-    @busy = !!flag
-  end
-
-  def busy?
-    !!@busy
-  end
-
   def deploy(container, force_restart)
     @logger.info("Deploying container: #{container.name.to_s.green}")
     @logger.debug("Deploy dir: #{Indocker.deploy_dir}")
@@ -46,14 +18,14 @@ class Indocker::DeployContext
 
     container.networks.each do |network|
       Indocker::Docker.create_network(
-        Indocker::NetworkHelper.name(@configuration.name, network)
+        Indocker::Networks::NetworkHelper.name(@configuration.name, network)
       )
     end
 
     container.volumes.each do |volume|
       if volume.is_a?(Indocker::Volumes::External)
         Indocker::Docker.create_volume(
-          Indocker::VolumeHelper.name(@configuration.name, volume)
+          Indocker::Volumes::VolumeHelper.name(@configuration.name, volume)
         )
       end
     end

data/lib/indocker/docker_run_args.rb

@@ -159,7 +159,7 @@ class Indocker::DockerRunArgs
         if volume.is_a?(Indocker::Volumes::Local)
           args.push("-v #{volume.local_path}:#{volume.path}")
         elsif volume.is_a?(Indocker::Volumes::External)
-          name = Indocker::VolumeHelper.name(configuration.name, volume)
+          name = Indocker::Volumes::VolumeHelper.name(configuration.name, volume)
           args.push("-v #{name}:#{volume.path}")
         elsif volume.is_a?(Indocker::Volumes::Repository)
           repository = configuration.repositories.fetch(volume.repository_name) do
@@ -173,7 +173,7 @@ class Indocker::DockerRunArgs
       end
 
       container.networks.each do |network|
-        name = Indocker::NetworkHelper.name(configuration.name, network)
+        name = Indocker::Networks::NetworkHelper.name(configuration.name, network)
         args.push("--network #{name}")
       end
 

data/lib/indocker/images/image_compiler.rb

@@ -61,7 +61,6 @@ class Indocker::Images::ImageCompiler
     end
 
     build_context.build_image(image, compile_dir)
-    build_context.set_compiled(image)
 
     @compiled_images[image] = true
   end

data/lib/indocker/{configuration_deployer.rb → launchers/configuration_deployer.rb}

@@ -2,7 +2,7 @@ require 'timeout'
 require 'benchmark'
 require 'tempfile'
 
-class Indocker::ConfigurationDeployer
+class Indocker::Launchers::ConfigurationDeployer
   REMOTE_OPERATION_TIMEOUT = 60
 
   def initialize(logger:, global_logger:)
@@ -14,13 +14,11 @@ class Indocker::ConfigurationDeployer
     @progress = Indocker::DeploymentProgress.new(
       Indocker.logger.level == Logger::DEBUG ? nil : Logger.new(STDOUT)
     )
+    @compiled_images = Hash.new(false)
   end
 
   # Launch deployment & measure the benchmark
   def run(configuration:, deployment_policy:)
-    build_context_pool = nil
-    deployer = nil
-
     time = Benchmark.realtime do
       if deployment_policy.force_restart
         @logger.warn("WARNING. All containers will be forced to restart.")
@@ -46,12 +44,11 @@ class Indocker::ConfigurationDeployer
     containers = find_containers_to_deploy(configuration, deployment_policy)
 
     clonner = Indocker::Repositories::Clonner.new(configuration, @logger)
-    build_context_pool = Indocker::BuildContextPool.new(configuration: configuration, logger: @logger, global_logger: @global_logger)
+    build_server_pool = Indocker::ServerPools::BuildServerPool.new(configuration: configuration, logger: @logger)
     deployer = Indocker::ContainerDeployer.new(configuration: configuration, logger: @logger)
     
     @global_logger.info("Establishing ssh sessions to all servers...")
-    build_context_pool.create_sessions!
-    deployer.create_sessions!
+    build_server_pool.create_sessions!
 
     build_servers = configuration
       .build_servers
@@ -95,7 +92,7 @@ class Indocker::ConfigurationDeployer
       recursively_deploy_container(
         configuration, 
         deployer, 
-        build_context_pool, 
+        build_server_pool, 
         container, 
         containers, 
         deployment_policy.skip_build, 
@@ -109,7 +106,7 @@ class Indocker::ConfigurationDeployer
       .list
       .each { |t| t.join if t != Thread.current }
   ensure
-    build_context_pool.close_sessions if build_context_pool
+    build_server_pool.close_sessions if build_server_pool
     deployer.close_sessions if deployer
   end
 
@@ -272,12 +269,12 @@ class Indocker::ConfigurationDeployer
     result.uniq
   end
 
-  def compile_image(configuration, image, build_context)
-    return if build_context.image_compiled?(image)
+  def compile_image(configuration, image, build_server)
+    return if @compiled_images[image]
 
     image.dependent_images.each do |dependent_image|
-      next if build_context.image_compiled?(dependent_image)
-      compile_image(configuration, dependent_image, build_context)
+      next if @compiled_images[image]
+      compile_image(configuration, dependent_image, build_server)
     end
 
     compiler = Indocker::Images::ImageCompiler.new
@@ -287,32 +284,30 @@ class Indocker::ConfigurationDeployer
     result = nil
 
     time = Benchmark.realtime do
-      result = build_context
-        .session
-        .exec!(
-          "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/compile -C #{Indocker.configuration_name} -i #{image.name} -s #{@logger.debug? ? '-d' : ''}"
+      result = build_server
+        .compile_image_remotely(
+          configuration_name: Indocker.configuration_name,
+          image_name:         image.name
         )
     end
 
-    Indocker::SshResultLogger
-      .new(@logger)
-      .log(result, "#{image.name.to_s.green} image compilation failed")
-
-    exit 1 if result.exit_code != 0
+    if result.exit_code != 0
+      exit 1
+    end
 
     @logger.info("Image compilation completed #{image.name.to_s.green}. Time taken: #{time}")
 
-    build_context.set_compiled(image)
+    @compiled_images[image] = true
   end
 
-  def recursively_deploy_container(configuration, deployer, build_context_pool, container, 
+  def recursively_deploy_container(configuration, deployer, build_server_pool, container, 
     containers, skip_build, skip_deploy, force_restart, skip_force_restart)
 
     container.dependent_containers.each do |container|
       recursively_deploy_container(
         configuration, 
         deployer, 
-        build_context_pool, 
+        build_server_pool, 
         container, 
         containers, 
         skip_build, 
@@ -327,20 +322,24 @@ class Indocker::ConfigurationDeployer
     @progress.start_building_container(container)
 
     if !skip_build
-      build_context = build_context_pool.get
+      build_server = build_server_pool.get
 
-      build_context.set_busy(true)
-      compile_image(configuration, container.image, build_context)
-      build_context.set_busy(false)
+      build_server.set_busy(true)
+      compile_image(configuration, container.image, build_server)
+      build_server.set_busy(false)
     end
 
     @progress.finish_building_container(container)
 
     if !skip_deploy
-      deployer.deploy(container, force_restart, skip_force_restart, @progress)
+      deploy_container(deployer, container, force_restart, skip_force_restart)
     end
   end
 
+  def deploy_container(deployer, container, force_restart, skip_force_restart)
+    deployer.deploy(container, force_restart, skip_force_restart, @progress)
+  end
+
   class RemoteOperation
     attr_reader :thread, :server, :operation, :message
 

data/lib/indocker/{container_runner.rb → launchers/container_runner.rb}

@@ -1,4 +1,4 @@
-class Indocker::ContainerRunner
+class Indocker::Launchers::ContainerRunner
   def initialize(logger)
     @logger = logger
   end
@@ -13,8 +13,7 @@ class Indocker::ContainerRunner
 
     deploy_context = Indocker::DeployContext.new(
       logger: @logger,
-      configuration: configuration,
-      server: nil
+      configuration: configuration
     )
 
     container = configuration.containers.detect { |c| c.name == container_name }

data/lib/indocker/{images_compiler.rb → launchers/images_compiler.rb}

@@ -1,4 +1,4 @@
-class Indocker::ImagesCompiler
+class Indocker::Launchers::ImagesCompiler
   def initialize(logger)
     @logger = logger
   end
@@ -8,8 +8,8 @@ class Indocker::ImagesCompiler
 
     build_context = Indocker::BuildContext.new(
       configuration: configuration,
-      build_server:  nil,
-      logger: Indocker.logger
+      logger: @logger,
+      global_logger: Indocker.global_logger
     )
 
     image_compiler = Indocker::Images::ImageCompiler.new

data/lib/indocker/{network.rb → networks/network.rb}

@@ -1,4 +1,4 @@
-class Indocker::Network
+class Indocker::Networks::Network
   attr_reader :name, :containers
 
   def initialize(name)

data/lib/indocker/{network_helper.rb → networks/network_helper.rb}

@@ -1,4 +1,4 @@
-class Indocker::NetworkHelper
+class Indocker::Networks::NetworkHelper
   class << self
     def name(configuration_name, network)
       "#{configuration_name}_#{network.name}"

data/lib/indocker/server_pools/build_server_connection.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+
+class Indocker::ServerPools::BuildServerConnection < Indocker::ServerPools::ServerConnection
+  def compile_image_remotely(configuration_name:, image_name:)
+    result = exec!(
+      "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/compile -C #{configuration_name} -i #{image_name} -s #{@logger.debug? ? '-d' : ''}"
+    )
+
+    Indocker::SshResultLogger
+      .new(@logger)
+      .log(result, "#{image_name.to_s.green} image compilation failed")
+    
+    result
+  end
+end

data/lib/indocker/server_pools/build_server_pool.rb

@@ -0,0 +1,40 @@
+class Indocker::ServerPools::BuildServerPool
+  def initialize(configuration:, logger:)
+    @logger = logger
+    @configuration = configuration
+
+    @connections = configuration.build_servers.map do |build_server|
+      Indocker::ServerPools::BuildServerConnection.new(
+        logger: @logger,
+        configuration: configuration,
+        server: build_server,
+      )
+    end
+  end
+
+  def create_sessions!
+    @connections.each(&:create_session!)
+  end
+
+  def get
+    context = nil
+
+    loop do
+      context = @connections.detect {|c| !c.busy?}
+      sleep(0.1)
+      break if context
+    end
+
+    context
+  end
+
+  def each(&proc)
+    @connections.each(&proc)
+  end
+
+  def close_sessions
+    @connections.each(&:close_session)
+  rescue => e
+    @logger.error("error during session close: #{e.inspect}")
+  end
+end

data/lib/indocker/server_pools/deploy_server_connection.rb

@@ -0,0 +1,17 @@
+class Indocker::ServerPools::DeployServerConnection < Indocker::ServerPools::ServerConnection
+  def run_container_remotely(configuration_name:, container_name:, force_restart:)
+    command_output  = @logger.debug? ? "" : " > /dev/null"
+    debug_options   = @logger.debug? ? "-d" : ""
+    force_restart_options = force_restart ? "-f" : ""
+
+    result = exec!(
+      "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/run -C #{configuration_name} -c #{container_name} #{debug_options} #{command_output} #{force_restart_options}"
+    )
+
+    Indocker::SshResultLogger
+      .new(@logger)
+      .log(result, "#{container_name.to_s.green} deployment for server #{server.name} failed")
+    
+    result
+  end
+end

data/lib/indocker/server_pools/deploy_server_pool.rb

@@ -0,0 +1,41 @@
+class Indocker::ServerPools::DeployServerPool
+  def initialize(configuration:, logger:)
+    @logger = logger
+    @configuration = configuration
+    @connections = []
+    @semaphore = Mutex.new
+  end
+
+  def create_connection!(server)
+    @semaphore.synchronize do
+      create_connection_unsafe!(server)
+    end
+  end
+
+  def each(&proc)
+    @connections.each(&proc)
+  end
+
+  def close_sessions
+    @connections.each(&:close_session)
+  end
+
+  private
+    def create_connection_unsafe!(server)
+      connection = @connections.detect do |connection|
+        connection.server.host == server.host &&
+        connection.server.port == server.port &&
+        connection.server.user == server.user
+      end
+      if connection.nil?
+        connection = Indocker::ServerPools::DeployServerConnection.new(
+          logger: @logger,
+          configuration: @configuration,
+          server: server,
+        )
+        connection.create_session!
+        @connections.push(connection)
+      end
+      connection
+    end
+end

data/lib/indocker/server_pools/server_connection.rb

@@ -0,0 +1,36 @@
+class Indocker::ServerPools::ServerConnection
+  attr_reader :server, :session
+
+  def initialize(logger:, configuration:, server:)
+    @logger = logger
+    @configuration = configuration
+    @server = server
+  end
+
+  def create_session!
+    return unless @server
+    
+    @session = Indocker::SshSession.new(
+      host: @server.host,
+      user: @server.user,
+      port: @server.port,
+      logger: @logger
+    )
+  end
+
+  def exec!(command)
+    @session.exec!(command)
+  end
+
+  def close_session
+    @session.close if @session
+  end
+
+  def set_busy(flag)
+    @busy = !!flag
+  end
+
+  def busy?
+    !!@busy
+  end
+end

data/lib/indocker/ssh_session.rb

@@ -38,10 +38,26 @@ class Indocker::SshSession
   end
 
   def exec!(command)
-    if !@ssh
+    if local?
+      exec_locally!(command)
+    else
+      exec_remotely!(command)
+    end
+  end
+
+  def close
+    if @ssh
+      @ssh.close
+    end
+  end
+
+  private
+    def exec_locally!(command)
       res = Indocker::Shell.command_with_result(command, @logger, skip_logging: false)
       ExecResult.new(res.stdout, '', res.exit_status, nil)
-    else
+    end
+
+    def exec_remotely!(command)
       if Indocker.export_command
         command = "#{Indocker.export_command} && #{command}"
       end
@@ -82,11 +98,4 @@ class Indocker::SshSession
 
       ExecResult.new(stdout_data, stderr_data, exit_code, exit_signal)
     end
-  end
-
-  def close
-    if @ssh
-      @ssh.close
-    end
-  end
 end