indocker 0.1.6 → 0.1.11

data/lib/indocker/build_context.rb

@@ -8,17 +8,18 @@ class Indocker::BuildContext
     @logger = logger
     @helper = Indocker::BuildContextHelper.new(@configuration, @build_server)
     @server = build_server
+    @compiled_images = Hash.new(false)
+  end
 
-    if build_server
-      @session = Indocker::SshSession.new(
-        host: build_server.host,
-        user: build_server.user,
-        port: build_server.port,
-        logger: @logger
-      )
-    end
+  def create_session!
+    return unless @server
 
-    @compiled_images = Hash.new(false)
+    @session = Indocker::SshSession.new(
+      host: @server.host,
+      user: @server.user,
+      port: @server.port,
+      logger: @logger
+    )
   end
 
   def exec!(command)
@@ -69,10 +70,10 @@ class Indocker::BuildContext
       build_args = args.join(' ')
 
       res = Indocker::Docker.build(image.local_registry_url, build_args)
-
+      
       if res.exit_status != 0
-        @logger.error("image compilation :#{image.name} failed")
-        @logger.error(res.stdout)
+        puts "image compilation :#{image.name} failed"
+        puts res.stdout
         exit 1
       end
 

data/lib/indocker/build_context_pool.rb

@@ -7,11 +7,15 @@ class Indocker::BuildContextPool
       Indocker::BuildContext.new(
         logger: @logger,
         configuration: configuration,
-        build_server: build_server,
+        build_server: build_server
       )
     end
   end
 
+  def create_sessions!
+    @contexts.each(&:create_session!)
+  end
+
   def get
     context = nil
 

data/lib/indocker/configuration_deployer.rb

@@ -5,92 +5,109 @@ require 'tempfile'
 class Indocker::ConfigurationDeployer
   REMOTE_OPERATION_TIMEOUT = 60
 
-  def initialize(logger)
+  def initialize(logger:, global_logger:)
     Thread.abort_on_exception = true # abort all threads if exception occurs
 
     @logger = logger
-    @global_logger = Logger.new(STDOUT)
-    @global_logger.formatter = logger.formatter
+    @global_logger = global_logger
 
     @progress = Indocker::DeploymentProgress.new(
       Indocker.logger.level == Logger::DEBUG ? nil : Logger.new(STDOUT)
     )
   end
 
-  def run(configuration:, deploy_containers:, skip_tags:, deploy_tags:, skip_dependent:,
-          skip_containers:, servers:, skip_build:, force_restart:, skip_force_restart:, auto_confirm:, require_confirmation:)
+  # Launch deployment & measure the benchmark
+  def run(configuration:, deployment_policy:)
     build_context_pool = nil
     deployer = nil
 
     time = Benchmark.realtime do
-      if force_restart
+      if deployment_policy.force_restart
         @logger.warn("WARNING. All containers will be forced to restart.")
       end
 
-      if skip_build
+      if deployment_policy.skip_build
         @logger.warn("WARNING. Images build step will be skipped")
       end
 
-      preload_containers(configuration)
-
-      containers = find_deploy_containers(configuration, deploy_containers, deploy_tags, skip_dependent, skip_containers, servers, skip_tags, auto_confirm, require_confirmation)
-      containers = containers.uniq {|c| c.name}
-
-      clonner = Indocker::Repositories::Clonner.new(configuration, @logger)
-
-      @global_logger.info("Establishing ssh sessions to all servers...")
-
-      build_context_pool = Indocker::BuildContextPool.new(configuration: configuration, logger: @logger)
-      deployer = Indocker::ContainerDeployer.new(configuration: configuration, logger: @logger)
-
-      build_servers = configuration
-        .build_servers
-        .uniq { |s| s.host }
-
-      deploy_servers = containers
-        .map(&:servers)
-        .flatten
-        .uniq { |s| s.host }
+      if deployment_policy.skip_deploy
+        @logger.warn("WARNING. Images deploy step will be skipped")
+      end
 
-      servers = (deploy_servers + build_servers).uniq { |s| s.host }
+      run!(configuration: configuration, deployment_policy: deployment_policy)
+    end
 
-      @progress.setup(
-        binaries_servers: servers,
-        build_servers: build_servers,
-        deploy_servers: deploy_servers,
-        env_files: configuration.env_files.keys,
-        repositories: configuration.repositories.keys,
-        force_restart: force_restart,
-        skip_build: skip_build,
-        containers: containers,
-        artifact_servers: configuration.artifact_servers,
-      )
+    @global_logger.info("Deployment finished".green)
+    @global_logger.info("Total time taken: #{time.round}s".green)
+  end
 
-      remote_operations = sync_indocker(servers)
-      wait_remote_operations(remote_operations)
+  # The main flow of the deployment would happen in this method.
+  def run!(configuration:, deployment_policy:)
+    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)
+    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_servers = configuration
+      .build_servers
+      .uniq { |s| s.host }
+
+    deploy_servers = containers
+      .map(&:servers)
+      .flatten
+      .uniq { |s| s.host }
+
+    servers = (deploy_servers + build_servers).uniq { |s| s.host }
+
+    @progress.setup(
+      binaries_servers: servers,
+      build_servers:    build_servers,
+      deploy_servers:   deploy_servers,
+      env_files:        configuration.env_files.keys,
+      repositories:     configuration.repositories.keys,
+      force_restart:    deployment_policy.force_restart,
+      skip_build:       deployment_policy.skip_build,
+      skip_deploy:      deployment_policy.skip_deploy,
+      containers:       containers,
+      artifact_servers: configuration.artifact_servers,
+    )
 
-      remote_operations = sync_env_files(deploy_servers, configuration.env_files)
-      wait_remote_operations(remote_operations)
+    remote_operations = sync_indocker(servers)
+    wait_remote_operations(remote_operations)
 
-      remote_operations = pull_repositories(clonner, build_servers, configuration.repositories)
-      wait_remote_operations(remote_operations)
+    remote_operations = sync_env_files(deploy_servers, configuration.env_files)
+    wait_remote_operations(remote_operations)
 
-      remote_operations = sync_artifacts(clonner, configuration.artifact_servers)
-      wait_remote_operations(remote_operations)
+    remote_operations = pull_repositories(clonner, build_servers, configuration.repositories)
+    wait_remote_operations(remote_operations)
 
-      update_crontab_redeploy_rules(configuration, build_servers.first)
+    remote_operations = sync_artifacts(clonner, configuration.artifact_servers)
+    wait_remote_operations(remote_operations)
 
-      containers.uniq.each do |container|
-        recursively_deploy_container(configuration, deployer, build_context_pool, container, containers, skip_build, force_restart, skip_force_restart)
-      end
+    update_crontab_redeploy_rules(configuration, build_servers.first)
 
-      Thread
-        .list
-        .each { |t| t.join if t != Thread.current }
+    containers.uniq.each do |container|
+      recursively_deploy_container(
+        configuration, 
+        deployer, 
+        build_context_pool, 
+        container, 
+        containers, 
+        deployment_policy.skip_build, 
+        deployment_policy.skip_deploy, 
+        deployment_policy.force_restart, 
+        deployment_policy.skip_force_restart
+      )
     end
 
-    @global_logger.info("Deployment finished".green)
-    @global_logger.info("Total time taken: #{time.round}s".green)
+    Thread
+      .list
+      .each { |t| t.join if t != Thread.current }
   ensure
     build_context_pool.close_sessions if build_context_pool
     deployer.close_sessions if deployer
@@ -111,23 +128,18 @@ class Indocker::ConfigurationDeployer
     end
   end
 
-  def preload_containers(configuration)
-    configuration.enabled_containers.each do |container_name|
-      path = Indocker.container_files[container_name]
-      require path
-    end
-  end
-
-  def find_deploy_containers(configuration, deploy_containers, deploy_tags, skip_dependent, skip_containers, servers, skip_tags, auto_confirm, require_confirmation)
+  def find_containers_to_deploy(configuration, deployment_policy)
+    load_enabled_containers(configuration)
+    
     containers = []
 
-    deploy_tags.each do |tag|
+    deployment_policy.deploy_tags.each do |tag|
       containers += configuration.containers.select do |container|
         container.tags.include?(tag)
       end
     end
 
-    skip_containers.each do |name|
+    deployment_policy.skip_containers.each do |name|
       container = configuration.containers.detect do |container|
         container.name == name
       end
@@ -144,7 +156,7 @@ class Indocker::ConfigurationDeployer
       end
     end
 
-    deploy_containers.each do |name|
+    deployment_policy.deploy_containers.each do |name|
       container = configuration.containers.detect do |container|
         container.name == name
       end
@@ -158,17 +170,17 @@ class Indocker::ConfigurationDeployer
       end
     end
 
-    if deploy_tags.empty? && deploy_containers.empty?
+    if deployment_policy.deploy_tags.empty? && deployment_policy.deploy_containers.empty?
       containers = configuration.containers.select do |container|
         configuration.enabled_containers.include?(container.name)
       end
     end
 
-    if !skip_dependent
+    if !deployment_policy.skip_dependent
       containers = collect_dependent_containers(containers)
     end
 
-    if !skip_dependent
+    if !deployment_policy.skip_dependent
       containers = collect_soft_dependent_containers(containers, configuration)
     end
 
@@ -181,13 +193,13 @@ class Indocker::ConfigurationDeployer
 
     containers = containers
       .select { |container| configuration.container_enabled?(container) }
-      .select { |container| !skip_containers.include?(container.name) }
+      .select { |container| !deployment_policy.skip_containers.include?(container.name) }
       .select { |container|
-        (skip_tags & container.tags).empty?
+        (deployment_policy.skip_tags & container.tags).empty?
       }
 
-    if !servers.empty?
-      containers = containers.select {|c| !(c.servers.map(&:name) & servers).empty? }
+    if !deployment_policy.servers.empty?
+      containers = containers.select {|c| !(c.servers.map(&:name) & deployment_policy.servers).empty? }
     end
 
     if containers.empty?
@@ -196,6 +208,7 @@ class Indocker::ConfigurationDeployer
     else
       @global_logger.info("Following containers will be deployed:")
 
+      servers = deployment_policy.servers
       if servers.empty?
         servers = containers.map(&:servers).flatten.uniq.map(&:name)
       end
@@ -213,7 +226,7 @@ class Indocker::ConfigurationDeployer
         end
       end
 
-      if (require_confirmation || configuration.confirm_deployment) && !auto_confirm
+      if (deployment_policy.require_confirmation || configuration.confirm_deployment) && !deployment_policy.auto_confirm
         @global_logger.info("\n")
         @global_logger.info("Do you want to continue deployment? (y or n)")
         result = gets.chomp
@@ -224,7 +237,14 @@ class Indocker::ConfigurationDeployer
         end
       end
 
-      containers
+      containers.uniq {|c| c.name}
+    end
+  end
+
+  def load_enabled_containers(configuration)
+    configuration.enabled_containers.each do |container_name|
+      path = Indocker.container_files[container_name]
+      require path
     end
   end
 
@@ -270,24 +290,42 @@ class Indocker::ConfigurationDeployer
       result = build_context
         .session
         .exec!(
-          "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/compile -C #{Indocker.configuration_name} -i #{image.name} -s #{@logger.debug? ? '-d' : ''}"
+          "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/compile -C #{Indocker.configuration_name} -i #{image.name} -s #{@logger.debug? ? '-d' : ''}",
+          on_stdout: proc { |data|
+            @logger.info("[compile] #{data}")
+          },
+          on_stderr: proc { |data|
+            @logger.error("[compile] #{data}")
+          }
         )
     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
+      @global_logger.error("[compile] #{image.name.to_s.green} image compilation failed")
+      puts result.stdout_data
+      exit 1 
+    end
 
     @logger.info("Image compilation completed #{image.name.to_s.green}. Time taken: #{time}")
 
     build_context.set_compiled(image)
   end
 
-  def recursively_deploy_container(configuration, deployer, build_context_pool, container, containers, skip_build, force_restart, skip_force_restart)
+  def recursively_deploy_container(configuration, deployer, build_context_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, container, containers, skip_build, force_restart, skip_force_restart)
+      recursively_deploy_container(
+        configuration, 
+        deployer, 
+        build_context_pool, 
+        container, 
+        containers, 
+        skip_build, 
+        skip_deploy,
+        force_restart, 
+        skip_force_restart
+      )
     end
 
     return if !containers.include?(container)
@@ -304,7 +342,9 @@ class Indocker::ConfigurationDeployer
 
     @progress.finish_building_container(container)
 
-    deployer.deploy(container, force_restart, skip_force_restart, @progress)
+    if !skip_deploy
+      deployer.deploy(container, force_restart, skip_force_restart, @progress)
+    end
   end
 
   class RemoteOperation
@@ -319,7 +359,6 @@ class Indocker::ConfigurationDeployer
   end
 
   def pull_repositories(clonner, servers, repositories)
-    @logger.info("{timestamp}")
     @logger.info("Clonning/pulling repositories")
 
     remote_operations = []
@@ -372,7 +411,6 @@ class Indocker::ConfigurationDeployer
   end
 
   def sync_artifacts(clonner, artifact_servers)
-    @logger.info("{timestamp}")
     @logger.info("Syncing git artifacts")
 
     remote_operations = []
@@ -424,8 +462,6 @@ class Indocker::ConfigurationDeployer
     redeploy_containers = configuration.containers.select {|c| c.redeploy_schedule}.uniq
     return if redeploy_containers.empty?
 
-    @logger.info("{timestamp}")
-
     deploy_user       = "#{server.user}@#{server.host}"
     crontab_filepath  = Indocker.redeploy_crontab_path
 
@@ -450,8 +486,6 @@ class Indocker::ConfigurationDeployer
   end
 
   def sync_indocker(servers)
-    @logger.info("{timestamp}")
-
     servers.map do |server|
       @progress.start_syncing_binaries(server)
 
@@ -482,8 +516,6 @@ class Indocker::ConfigurationDeployer
   end
 
   def sync_env_files(servers, env_files)
-    @logger.info("{timestamp}")
-
     remote_operations = []
 
     servers.map do |server|

data/lib/indocker/container_deployer.rb

@@ -14,6 +14,10 @@ class Indocker::ContainerDeployer
     @deployed_servers = {}
   end
 
+  def create_sessions!
+    @server_pool.create_sessions!
+  end
+
   def deploy(container, force_restart, skip_force_restart, progress)
     return if @deployed_containers[container]
 
@@ -34,7 +38,6 @@ class Indocker::ContainerDeployer
 
       exec_proc.call do
         deploy_context = @server_pool.get(server)
-        @logger.info("{timestamp}")
         @logger.info("Deploying container: #{container.name.to_s.green} to #{server.user}@#{server.host}")
 
         command_output  = @logger.debug? ? "" : " > /dev/null"
@@ -47,14 +50,21 @@ class Indocker::ContainerDeployer
         result = deploy_context
           .session
           .exec!(
-            "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/run -C #{Indocker.configuration_name} -c #{container.name} #{debug_options} #{command_output} #{force_restart_options}"
+            "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/run -C #{Indocker.configuration_name} -c #{container.name} #{debug_options} #{command_output} #{force_restart_options}",
+            on_stdout: proc { |data|
+              @logger.info("[deploy] #{data}")
+            },
+            on_stderr: proc { |data|
+              @logger.error("[deploy] #{data}")
+            }
           )
+        
+        if result.exit_code != 0
+          @global_logger.error("[deploy] #{container.name.to_s.green} deployment for server #{server.name} failed")
+          puts result.stdout_data
+          exit 1 
+        end
 
-        Indocker::SshResultLogger
-          .new(@logger)
-          .log(result, "#{container.name.to_s.green} deployment for server #{server.name} failed")
-
-        exit 1 if result.exit_code != 0
         @logger.info("Container deployment to #{server.user}@#{server.host} finished: #{container.name.to_s.green}")
 
         deploy_context.close_session