capistrano_multiconfig_parallel 2.0.0.beta5 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dcf6eedb9a056078cbf9751eec4891962435a25
-  data.tar.gz: 23169131c3f9ad637f3fba23aa6cb0e0ff72999f
+  metadata.gz: 3f293dd460a9b6468a63c41cabe277f8a948b419
+  data.tar.gz: 07307d95d8574a28775a03549afa110d233d730e
 SHA512:
-  metadata.gz: 0ba7953d5f457de62eb60117b04ab7857bab1a127cb0c17865d951343e8d4a3a937eecb25364c8b65e6f74d5b9337a117fa0957888bccb1bd845e4d73a53e31f
-  data.tar.gz: f75e4abf68ef7323ac2c6669dac8e2ae5baf49f09b4126f1e2d481bfd634dfbd9169fcf00e853d55b79f6216efbb9680b1e17048286ecf89ea3f1aaf1b8f89c0
+  metadata.gz: 6209f4db889a5a4c29cf83476509405e56f796180f2024f5945057ce633eedbfde0dbcc4048684947aef4c981071cb1fa99caab3bd142672e7a8dc0c0c98f507
+  data.tar.gz: a5231899ad5ded76359d19f625e921114aa4f3dd4aa1dc8046ec1179f398f2eaf94b4cddbcac7ca65bd66c33fc7aa5d86b03a762aa0f629811f6b3ae7f56023c

data/README.md

@@ -17,8 +17,8 @@ IMPORTANT! The whole reason for this gem was for using [Caphub](https://github.c
 
 CAUTION!! PLEASE READ CAREFULLY!! Capistrano is not thread-safe. However in order to work around this problem, each of the task is executing inside a thread that spawns a new process in order to run capistrano tasks The thread monitors the process. This works well, however if the tasks you are executing is working with files, you might get into deadlocks because multiple proceses try to access same resource. Instead of using files , please consider using StringIO instead.
 
-NEW Improvements started in version 2.0.0.alpha ( currently gem is in beta version)
------------------------------------------------------------------------------------
+NEW Improvements started in version 2.0.0.alpha ( currently gem is in a release candidate version)
+--------------------------------------------------------------------------------------------------
 
 -	Code for handling websocket events when a task is invoked was moved to a new gem [capistrano_sentinel](https://github.com/bogdanRada/capistrano_sentinel)
 -	You can now deploy applications from anywhere on your computer without having to add this gem to the Gemfile, however you need to add the [capistrano_sentinel](https://github.com/bogdanRada/capistrano_sentinel) gem to your Gemfile, if you want to use this .
@@ -76,7 +76,7 @@ Add the following to your Capfile after requiring **capistrano** and **capistran
 Install locally on your system the capistrano_multiconfig_parallel gem using this command :
 
 ```ruby
-  gem install capistrano_multiconfig_parallel -v 2.0.0.beta4
+  gem install capistrano_multiconfig_parallel -v 2.0.0.rc1
 ```
 
 Please read [Release Details](https://github.com/bogdanRada/capistrano_multiconfig_parallel/releases) if you are upgrading. We break backward compatibility between large ticks but you can expect it to be specified at release notes.

data/lib/capistrano_multiconfig_parallel/all.rb

@@ -28,7 +28,6 @@ require 'pp'
 require 'yaml'
 require 'stringio'
 require 'io/console'
-require 'shellwords'
 
 # fix error with not files that can not be found
  Gem.find_files('composable_state_machine/**/*.rb').each { |path| require path }

data/lib/capistrano_multiconfig_parallel/base.rb

@@ -51,7 +51,7 @@ module CapistranoMulticonfigParallel
       Celluloid.logger = logger
       Celluloid.task_class = defined?(Celluloid::TaskThread) ? Celluloid::TaskThread : Celluloid::Task::Threaded
       Celluloid.exception_handler do |ex|
-        unless ex.is_a?(Interrupt)
+        unless ex.is_a?(Interrupt) || ex.is_a?(SystemExit) || ex.is_a?(CapistranoMulticonfigParallel::CelluloidWorker::TaskFailed)
           rescue_error(ex, 'stderr')
         end
       end

data/lib/capistrano_multiconfig_parallel/celluloid/bundler_worker.rb

@@ -0,0 +1,34 @@
+require_relative './celluloid_worker'
+require_relative './process_runner'
+require_relative '../classes/runner_status'
+module CapistranoMulticonfigParallel
+  class BundlerWorker
+    include CapistranoMulticonfigParallel::BaseActorHelper
+
+    def work(job, options = {}, &callback)
+      @job = job
+      @options = options.symbolize_keys
+      @job_id = job.id
+      @runner_status = nil
+      check_missing_deps
+    end
+
+    def actor_id
+      "bundler_worker_#{@job_id}".to_sym
+    end
+
+    def check_missing_deps
+      command = @job.fetch_bundler_worker_command
+      log_to_file("bundler worker #{@job_id} executes: #{command}")
+      do_bundle_sync_command(command)
+    end
+
+    def do_bundle_sync_command(command)
+      CapistranoMulticonfigParallel::ProcessRunner.supervise as: actor_id
+      result =  Celluloid::Actor[actor_id].work(@job, command,sync: :sync, :callback => lambda { |runner_status| @runner_status = runner_status } )
+      sleep(0.1) until @runner_status.present?
+      @runner_status.output_text.include?("The Gemfile's dependencies are satisfied")
+    end
+
+  end
+end

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_manager.rb

@@ -21,8 +21,8 @@ module CapistranoMulticonfigParallel
       # Get a handle on the SupervisionGroup::Member
       @mutex = Mutex.new
       # http://rubydoc.info/gems/celluloid/Celluloid/SupervisionGroup/Member
-      setup_pool_of_actor(@worker_supervisor, actor_name: :workers, type: CapistranoMulticonfigParallel::CelluloidWorker, size: 10)
-      @workers = Celluloid::Actor[:workers]
+      @workers = setup_pool_of_actor(@worker_supervisor, actor_name: :workers, type: CapistranoMulticonfigParallel::CelluloidWorker, size: 10)
+      #@workers = Celluloid::Actor[:workers].pool
       Actor.current.link @workers
       setup_actor_supervision(@worker_supervisor, actor_name: :terminal_server, type: CapistranoMulticonfigParallel::TerminalTable, args: [Actor.current, @job_manager, configuration.fetch(:terminal, {})])
       setup_actor_supervision(@worker_supervisor, actor_name: :web_server, type: CapistranoMulticonfigParallel::WebServer, args: websocket_config)
@@ -200,6 +200,7 @@ module CapistranoMulticonfigParallel
       env_opts = options['skip_env_options'].present? ? {} : @job_manager.get_app_additional_env_options(job.app, job.stage)
       new_job_options = job.options.except!('id', 'status', 'exit_status').merge('env_options' => job.env_options.merge(env_opts))
       new_job = CapistranoMulticonfigParallel::Job.new(@job_manager, new_job_options.merge(options))
+      log_to_file("Trying to DiSPATCH new JOB #{new_job.inspect}")
       async.delegate_job(new_job) unless job.rolling_back?
     end
 
@@ -220,9 +221,10 @@ module CapistranoMulticonfigParallel
 
     def worker_died(worker, reason)
       job = @worker_to_job[worker.mailbox.address]
+      mailbox = worker.mailbox
+      log_to_file("worker_died: worker job #{job.inspect} with mailbox #{mailbox.inspect} and #{mailbox.address.inspect} died  for reason:  #{reason}")
       return true if job.blank? || job.rolling_back? || job.action != 'deploy'
       job.rollback_changes_to_application
-      mailbox = worker.mailbox
       @worker_to_job.delete(mailbox.address)
       log_to_file("RESTARTING: worker job #{job.inspect} with mailbox #{mailbox.inspect} and #{mailbox.address.inspect} died  for reason:  #{reason}")
       dispatch_new_job(job, skip_env_options: true, action: 'deploy:rollback')

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_worker.rb

@@ -1,6 +1,7 @@
-require_relative './child_process'
-require_relative './state_machine'
 require_relative '../helpers/base_actor_helper'
+require_relative '../classes/child_process_status'
+require_relative './state_machine'
+require_relative './process_runner'
 module CapistranoMulticonfigParallel
   # worker that will spawn a child process in order to execute a capistrano job and monitor that process
   #
@@ -20,10 +21,16 @@ module CapistranoMulticonfigParallel
     include CapistranoMulticonfigParallel::BaseActorHelper
     class TaskFailed < StandardError; end
 
-    attr_accessor :job, :manager, :job_id, :app_name, :env_name, :action_name, :env_options, :machine, :socket_connection, :task_argv,
-    :rake_tasks, :current_task_number, # tracking tasks
-    :successfull_subscription, :subscription_channel, :publisher_channel, # for subscriptions and publishing events
-    :job_termination_condition, :worker_state, :invocation_chain, :filename, :worker_log, :exit_status
+
+    ATTRIBUTE_LIST = [
+      :job, :manager, :job_id, :app_name, :env_name, :action_name, :env_options, :machine, :socket_connection, :task_argv,
+      :rake_tasks, :current_task_number, # tracking tasks
+      :successfull_subscription, :subscription_channel, :publisher_channel, # for subscriptions and publishing events
+      :job_termination_condition, :invocation_chain, :filename, :worker_log, :exit_status
+    ]
+
+    attr_reader *CapistranoMulticonfigParallel::CelluloidWorker::ATTRIBUTE_LIST
+    attr_accessor *CapistranoMulticonfigParallel::CelluloidWorker::ATTRIBUTE_LIST
 
     def initialize(*args)
     end
@@ -43,7 +50,7 @@ module CapistranoMulticonfigParallel
 
 
     def worker_state
-      if Actor.current.alive?
+      if job.status.to_s.downcase != 'dead' && Actor.current.alive?
         @machine.state.to_s.green
       else
         job.status = 'dead'
@@ -89,14 +96,14 @@ module CapistranoMulticonfigParallel
       check_child_proces
       command = job.fetch_deploy_command
       log_to_file("worker #{@job_id} executes: #{command}")
-      @child_process.async.work(@job, command, actor: Actor.current, silent: true)
+      @child_process.async.work(@job, command, actor: Actor.current, silent: true,sync: :async, runner_status_klass: CapistranoMulticonfigParallel::ChildProcessStatus)
     end
 
     def check_child_proces
-      @child_process = CapistranoMulticonfigParallel::ChildProcess.new
+      @child_process = CapistranoMulticonfigParallel::ProcessRunner.new
       Actor.current.link @child_process
       @child_process
-     end
+    end
 
     def on_close(code, reason)
       log_to_file("worker #{@job_id} websocket connection closed: #{code.inspect}, #{reason.inspect}")
@@ -117,13 +124,13 @@ module CapistranoMulticonfigParallel
       elsif message_is_for_stdout?(message)
         result = Celluloid::Actor[:terminal_server].show_confirmation(message['question'], message['default'])
         publish_rake_event(message.merge('action' => 'stdin', 'result' => result, 'client_action' => 'stdin'))
-    elsif message_from_bundler?(message)
+      elsif message_from_bundler?(message)
 
         #gem_messsage = job.gem_specs.find{|spec| message['task'].include?(spec.name) }
         # if gem_messsage.present?
         #     async.update_machine_state("insta")
         # else
-          async.update_machine_state(message['task'])
+        async.update_machine_state(message['task'])
         #end
       else
         log_to_file(message, job_id: @job_id)
@@ -158,6 +165,7 @@ module CapistranoMulticonfigParallel
       log_to_file("worker #{@job_id} triest to transition from #{@machine.state} to  #{name}") unless options[:bundler]
       @machine.go_to_transition(name.to_s, options)
       error_message = "worker #{@job_id} task #{name} failed "
+#      @manager.worker_died(Actor.current, error_message) if job.failed?
       raise(CapistranoMulticonfigParallel::CelluloidWorker::TaskFailed.new(error_message), error_message) if job.failed? # force worker to rollback
     end
 
@@ -170,15 +178,27 @@ module CapistranoMulticonfigParallel
     def finish_worker(exit_status)
       log_to_file("worker #{job_id} tries to terminate with exit_status #{exit_status}")
       @manager.mark_completed_remaining_tasks(@job) if Actor.current.alive?
-      update_machine_state('FINISHED') if exit_status == 0
+      exit_status == 0 ? update_machine_state('FINISHED') : update_machine_state('DEAD')
+#      @manager.worker_died(Actor.current, exit_status) if exit_status != 0
       @manager.workers_terminated.signal('completed') if @manager.present? && @manager.alive? && @manager.all_workers_finished?
     end
 
     def notify_finished(exit_status)
       finish_worker(exit_status)
-      return if exit_status == 0
-      error_message = "worker #{@job_id} task  failed with exit status #{exit_status.inspect}  "
-      raise(CapistranoMulticonfigParallel::CelluloidWorker::TaskFailed.new(error_message), error_message)
-    end
+       return if exit_status == 0
+       error_message = "worker #{@job_id} task  failed with exit status #{exit_status.inspect}  "
+       raise(CapistranoMulticonfigParallel::CelluloidWorker::TaskFailed.new(error_message), error_message)
+     end
+
+    # def inspect
+    #   to_s
+    # end
+    #
+    # def to_s
+    #    "#<#{self.class}(#{Actor.current.mailbox.address.inspect}) alive>"
+    # rescue
+    #   "#<#{self.class}(#{Actor.current.mailbox.address.inspect}) dead>"
+    # end
+
   end
 end

data/lib/capistrano_multiconfig_parallel/celluloid/process_runner.rb

@@ -0,0 +1,150 @@
+require_relative '../helpers/base_actor_helper'
+module CapistranoMulticonfigParallel
+  class ProcessRunner
+    include CapistranoMulticonfigParallel::BaseActorHelper
+
+    @attrs = [
+      :options,
+      :job,
+      :cmd,
+      :runner_status_klass,
+      :runner_status,
+      :actor,
+      :job_id,
+      :timer,
+      :synchronicity
+    ]
+
+    attr_reader *@attrs
+    attr_accessor *@attrs
+
+    finalizer :process_finalizer
+
+    def work(job, cmd, options = {})
+      @options = options.is_a?(Hash) ? options.symbolize_keys : {}
+      @job = job
+      @cmd = cmd
+
+      @runner_status_klass = @options[:runner_status_klass].present? ? @options[:runner_status_klass] : RunnerStatus
+      @runner_status = @runner_status_klass.new(Actor.current, job, cmd,  @options)
+      @synchronicity = @options[:sync]
+      start_running
+    end
+
+    def start_running
+      setup_attributes
+      run_right_popen3
+      setup_em_error_handler if @synchronicity == :async
+    end
+
+    def setup_attributes
+      @actor = @options.fetch(:actor, nil)
+      @job_id = @job.id
+    end
+
+    def setup_em_error_handler
+      EM.error_handler do|exception|
+        log_error(exception, job_id: @job_id, output: 'stderr')
+        EM.stop
+      end
+    end
+
+    def setup_periodic_timer
+      @timer = EM::PeriodicTimer.new(0.1) do
+        check_exit_status
+        @timer.cancel if @runner_status.exit_status.present?
+      end
+    end
+
+    def check_exit_status
+      return if @runner_status.exit_status.blank?
+      @timer.cancel
+      @job.exit_status = @runner_status.exit_status
+      log_to_file("worker #{@job_id} startsnotify finished with exit status #{@job.exit_status.inspect}")
+      if @actor.present? && @actor.respond_to?(:notify_finished)
+        if @actor.respond_to?(:async) && @synchronicity == :async
+          @actor.async.notify_finished(@job.exit_status)
+        elsif @synchronicity == :sync
+          @actor.notify_finished(@job.exit_status)
+        end
+      end
+    end
+
+    def process_finalizer
+      EM.stop if EM.reactor_running?
+      terminate
+    end
+
+    def run_right_popen3
+      popen3_options = {
+        #  :timeout_seconds  => @options.has_key?(:timeout) ? @options[:timeout] : 2,
+        :size_limit_bytes => @options[:size_limit_bytes],
+        :watch_directory  => @options[:watch_directory],
+        :user             => @options[:user],
+        :group            => @options[:group],
+      }
+      command = @runner_status.command
+      case @synchronicity
+      when :sync
+        run_right_popen3_sync(command, popen3_options)
+      when :async
+        run_right_popen3_async(command, popen3_options)
+      else
+        raise "unknown synchronicity = #{synchronicity.inspect}"
+      end
+    end
+
+    def run_right_popen3_sync(command, popen3_options)
+      do_right_popen3_sync(command, popen3_options)
+      sleep(0.1) until @runner_status.exit_status.present?
+    end
+
+    def run_right_popen3_async(command, popen3_options)
+      EM.run do
+        EM.defer do
+          begin
+            do_right_popen3_async(command, popen3_options)
+          rescue Exception => e
+            log_error(exception, job_id: @job_id, output: 'stderr')
+            EM.stop
+          end
+        end
+        setup_periodic_timer
+      end
+    end
+
+    def do_right_popen3(synchronicity, command, popen3_options)
+      popen3_options = {
+        :target                  => @runner_status,
+        :environment             => @options.fetch(:environment, nil),
+        :input                   => :on_input_stdin,
+        :stdout_handler          => :on_read_stdout,
+        :stderr_handler          => :on_read_stderr,
+        :watch_handler           => :watch_handler,
+        :pid_handler             => :on_pid,
+        :timeout_handler         => :on_timeout,
+        :size_limit_handler      => :on_size_limit,
+        :exit_handler            => :on_exit,
+        :async_exception_handler => :async_exception_handler
+      }.merge(popen3_options)
+      case synchronicity
+      when :sync
+        result = ::RightScale::RightPopen.popen3_sync(command, popen3_options)
+      when :async
+        result = ::RightScale::RightPopen.popen3_async(command, popen3_options)
+      else
+        raise "Uknown synchronicity = #{synchronicity.inspect}"
+      end
+      result == true
+    end
+
+    def do_right_popen3_sync(command, popen3_options)
+      do_right_popen3(:sync, command, popen3_options)
+    end
+
+    def do_right_popen3_async( command, popen3_options)
+      do_right_popen3(:async, command, popen3_options)
+    end
+
+  end
+end

data/lib/capistrano_multiconfig_parallel/celluloid/state_machine.rb

@@ -12,6 +12,7 @@ module CapistranoMulticonfigParallel
     end
 
     def go_to_transition(action, options = {})
+      return if @job.status.to_s.downcase == 'dead'
       transitions.on(action, state.to_s => action)
       @job.status = action
       if options[:bundler]

data/lib/capistrano_multiconfig_parallel/classes/child_process_status.rb

@@ -0,0 +1,72 @@
+require_relative './runner_status'
+module CapistranoMulticonfigParallel
+  # class that is used to execute the capistrano tasks and it is invoked by the celluloid worker
+  class ChildProcessStatus < CapistranoMulticonfigParallel::RunnerStatus
+
+    attr_accessor :show_bundler
+
+    def initialize(process_runner, job, command, options={})
+      super(process_runner, job, command, options)
+      @show_bundler = true
+    end
+
+    def print_error_if_exist
+      return unless development_debug?
+      [@job.stderr_buffer].each do |buffer|
+        buffer.rewind
+        data = buffer.read
+        log_output_error(nil, 'stderr', "Child process for worker #{@job_id} died for reason: #{data}") if data.present?
+      end
+    end
+
+    def on_input_stdin(data)
+      io_callback('stdin', data)
+    end
+
+    def on_read_stdout(data)
+      @show_bundler = false if  data.to_s.include?("The Gemfile's dependencies are satisfied") || data.to_s.include?("Bundle complete")
+      @actor.async.update_machine_state(truncate(data, 40), :bundler => true) if @show_bundler == true && data.strip.present? && data.strip != '.'
+      io_callback('stdout', data)
+    end
+
+    def on_read_stderr(data)
+      @job.save_stderr_error(data) if development_debug?
+      io_callback('stderr', data)
+    end
+
+    def on_timeout
+      log_to_file "Child process for worker #{@job_id} on_timeout  disconnected"
+      @did_timeout = true
+      @callback.call(self) if @expect_timeout
+    end
+
+    def on_size_limit
+      log_to_file "Child process for worker #{@job_id} on_size_limit  disconnected"
+      @did_size_limit = true
+      @callback.call(self) if @expect_size_limit
+    end
+
+    def on_exit(status)
+      log_to_file "Child process for worker #{@job_id} on_exit  disconnected due to error #{exit_status.inspect}"
+      print_error_if_exist
+      @exit_status = status.exitstatus
+      process_runner.check_exit_status
+    end
+
+    def async_exception_handler(*data)
+      log_to_file "Child process for worker #{@job_id} async_exception_handler  disconnected due to error #{data.inspect}"
+      io_callback('stderr', data)
+      @exit_status = 1
+      process_runner.check_exit_status
+    end
+
+    def watch_handler(process)
+      @process ||= process
+      process_runner.check_exit_status
+    end
+
+    def io_callback(io, data)
+      log_to_file("#{io.upcase} ---- #{data}", job_id: @job_id)
+    end
+  end
+end

data/lib/capistrano_multiconfig_parallel/classes/job.rb

@@ -132,7 +132,7 @@ module CapistranoMulticonfigParallel
     end
 
     def worker_died?
-      !worker.alive?
+      worker.blank? || !worker.alive?
     end
 
     def work_done?

data/lib/capistrano_multiconfig_parallel/classes/job_command.rb

@@ -23,6 +23,15 @@ module CapistranoMulticonfigParallel
       end
     end
 
+    def fetch_bundler_check_command(gemfile = job_gemfile)
+      "#{check_rvm_loaded} && if [ `which bundler |wc -l` = 0 ]; then gem install bundler;fi && (#{bundle_gemfile_env(gemfile)} bundle check || #{bundle_gemfile_env(gemfile)} bundle install )"
+    end
+
+    def fetch_bundler_worker_command
+      get_command_script(fetch_bundler_check_command)
+    end
+
+
     def find_capfile(custom_path = job_path)
       @capfile_path ||= Pathname.new(custom_path).children.find { |file| check_file(file, 'capfile') }
     end
@@ -158,7 +167,7 @@ module CapistranoMulticonfigParallel
     end
 
     def create_job_tempfile_command(output)
-      @tempfile ||= Tempfile.new(["multi_cap_#{job.id}_command_", ".rb"], encoding: 'utf-8')
+      @tempfile = Tempfile.new(["multi_cap_#{job.id}_command_", ".rb"], encoding: 'utf-8')
       @tempfile.write(output)
       ObjectSpace.undefine_finalizer(@tempfile) # force garbage collector not to remove automatically the file
       @tempfile.close
@@ -189,21 +198,13 @@ module CapistranoMulticonfigParallel
       rvm_enabled_for_job? ? "bash --login -c '#{command}'" : command
     end
 
-    def fetch_deploy_command
-      prepare_application_for_deployment
-      #  config_flags = CapistranoMulticonfigParallel.configuration_flags.merge("capistrano_version": job_capistrano_version)
-      environment_options = setup_command_line.join(' ')
-      command = "#{check_rvm_loaded} && if [ `which bundler |wc -l` = 0 ]; then gem install bundler;fi && (#{bundle_gemfile_env(@job_final_gemfile)} bundle check || #{bundle_gemfile_env(@job_final_gemfile)} bundle install ) && WEBSOCKET_LOGGING=#{debug_websocket?} LOG_FILE=#{websocket_config.fetch('log_file_path', nil)} #{bundle_gemfile_env(@job_final_gemfile)} bundle exec cap #{job_stage} #{capistrano_action} #{environment_options}"
-
+    def get_command_script(command)
       command = rvm_bash_prefix(command)
       command = command.inspect
-
       command_text =<<-CMD
       require 'rubygems'
       require 'bundler'
       Bundler.with_clean_env {
-        ENV['BUNDLE_GEMFILE'] = '#{job_gemfile_multi}'
-        ENV['#{CapistranoSentinel::RequestHooks::ENV_KEY_JOB_ID}']='#{job.id}'
         Kernel.exec(#{command})
       }
       CMD
@@ -219,6 +220,16 @@ module CapistranoMulticonfigParallel
     end
 
 
+    def fetch_deploy_command
+      prepare_application_for_deployment
+      #  config_flags = CapistranoMulticonfigParallel.configuration_flags.merge("capistrano_version": job_capistrano_version)
+      environment_options = setup_command_line.join(' ')
+      command = "#{fetch_bundler_check_command(@job_final_gemfile)} && WEBSOCKET_LOGGING=#{debug_websocket?} LOG_FILE=#{websocket_config.fetch('log_file_path', nil)} #{bundle_gemfile_env(@job_final_gemfile)} bundle exec cap #{job_stage} #{capistrano_action} #{environment_options}"
+
+      get_command_script(command)
+    end
+
+
     def job_capfile
       File.join(job_path, capfile_name.to_s)
     end
@@ -228,6 +239,10 @@ module CapistranoMulticonfigParallel
     end
 
     def prepare_application_for_deployment
+      if ENV['MULTI_CAP_WEB_APP']
+        bundler_worker = CapistranoMulticonfigParallel::BundlerWorker.new
+        result = bundler_worker.work(job)
+      end
       check_capistrano_sentinel_availability
       prepare_capfile
     end
@@ -290,10 +305,6 @@ module CapistranoMulticonfigParallel
 
     private
 
-    def get_bash_command(command)
-      Shellwords.escape(command)
-    end
-
     def run_shell_command(command)
       sh("#{command}")
     end

data/lib/capistrano_multiconfig_parallel/classes/runner_status.rb

@@ -0,0 +1,123 @@
+require_relative '../helpers/application_helper'
+module CapistranoMulticonfigParallel
+  class RunnerStatus
+    include CapistranoMulticonfigParallel::ApplicationHelper
+
+    ATTRIBUTE_LIST = [
+      :job,
+      :process_runner,
+      :command,
+      :options,
+      :actor,
+      :job_id,
+      :output_text,
+      :error_text,
+      :exit_status,
+      :did_timeout,
+      :callback,
+      :pid,
+      :force_yield,
+      :expect_timeout,
+      :expect_size_limit,
+      :async_exception,
+      :process
+    ]
+
+    attr_reader *CapistranoMulticonfigParallel::RunnerStatus::ATTRIBUTE_LIST
+    attr_accessor *CapistranoMulticonfigParallel::RunnerStatus::ATTRIBUTE_LIST
+
+    def initialize(process_runner, job, command, options={})
+      options = options.is_a?(Hash) ? options : {}
+      @job = job
+      @process_runner = process_runner
+      @command     = command
+      @options = {:repeats=>1, :force_yield=>nil, :timeout=>nil, :expect_timeout=>false}.merge(options)
+      @options = @options.symbolize_keys
+
+      @actor = @options.fetch(:actor, nil)
+      @job_id = @job.id
+      @process_runner = process_runner
+
+
+      @output_text = ""
+      @error_text  = ""
+      @exit_status      = nil
+      @did_timeout = false
+      @callback    = @options[:callback].present? ? @options[:callback] : nil
+      @pid         = nil
+      @force_yield = @options[:force_yield]
+
+      @expect_timeout    = @options[:expect_timeout] || false
+      @expect_size_limit = @options[:expect_size_limit] || false
+      @async_exception   = nil
+    end
+
+    def on_pid(pid)
+      log_to_file "Child process for worker #{@job_id} on_pid  #{pid.inspect}"
+      @pid ||= pid
+    end
+
+
+    def on_input_stdin(data)
+        log_to_file "Child process for worker #{@job_id} on_input_stdin  #{data.inspect}"
+        @output_text << data
+    end
+
+    def on_read_stdout(data)
+      log_to_file "Child process for worker #{@job_id} on_read_stdout  #{data.inspect}"
+      @output_text << data
+    end
+
+    def on_read_stderr(data)
+      log_to_file "Child process for worker #{@job_id} on_read_stderr  #{data.inspect}"
+      @error_text << data
+    end
+
+
+    def on_timeout
+      log_to_file "Child process for worker #{@job_id} on_timeout  disconnected"
+      @did_timeout = true
+      @callback.call(self) if @callback && @expect_timeout
+    end
+
+    def on_size_limit
+      log_to_file "Child process for worker #{@job_id} on_size_limit  disconnected"
+      @did_size_limit = true
+      @callback.call(self) if  @callback && @expect_size_limit
+    end
+
+    def on_exit(status)
+      log_to_file "Child process for worker #{@job_id} on_exit  disconnected due to error #{status.inspect}"
+      @exit_status = status.exitstatus
+      @callback.call(self) if @callback
+    end
+
+    def async_exception_handler(async_exception)
+      @async_exception = async_exception
+      log_to_file "Child process for worker #{@job_id} async_exception_handler  disconnected due to error #{data.inspect}"
+      @exit_status = 1
+    end
+
+    def watch_handler(process)
+      @process ||= process
+    end
+
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      JSON.generate(to_json)
+    end
+
+    def to_json
+      hash = {}
+      CapistranoMulticonfigParallel::RunnerStatus::ATTRIBUTE_LIST.delete_if{|a| [:process_runner].include?(a) }.each do |key|
+        hash[key] = send(key).inspect
+      end
+      hash
+    end
+
+  end
+end

data/lib/capistrano_multiconfig_parallel/helpers/base_actor_helper.rb

@@ -53,9 +53,7 @@ module CapistranoMulticonfigParallel
         if version_less_than_seventeen?
           class_name.supervise_as(*setup_actor_supervision_details(class_name, options))
         else
-          setup_supervision_group do |supervisor|
-            supervisor.supervise setup_actor_supervision_details(class_name, options)
-          end
+          class_name.supervise setup_actor_supervision_details(class_name, options)
         end
       end
 
@@ -63,9 +61,7 @@ module CapistranoMulticonfigParallel
         if version_less_than_seventeen?
           Celluloid::SupervisionGroup.run!
         else
-          Class.new(Celluloid::Supervision::Container) do
-            yield(self) if block_given?
-          end.run!
+          Celluloid::Supervision::Container.run!
         end
       end
 
@@ -73,10 +69,10 @@ module CapistranoMulticonfigParallel
         if version_less_than_seventeen?
           class_name.pool(options[:type], as: options[:actor_name], size:  options.fetch(:size, 10))
         else
+          # config = Celluloid::Supervision::Configuration.new
+          # config.define setup_actor_supervision_details(class_name, options)
           options = setup_actor_supervision_details(class_name, options)
-          setup_supervision_group do |supervisor|
-            supervisor.pool *[options[:type], options.except(:type)]
-          end
+          class_name.pool *[options[:type], options.except(:type)]
         end
       end
     end

data/lib/capistrano_multiconfig_parallel/version.rb

@@ -10,7 +10,7 @@ module CapistranoMulticonfigParallel
     MAJOR = 2
     MINOR = 0
     TINY = 0
-    PRE = 'beta5'
+    PRE = 'rc1'
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano_multiconfig_parallel
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta5
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-14 00:00:00.000000000 Z
+date: 2016-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -484,17 +484,20 @@ files:
 - lib/capistrano_multiconfig_parallel/all.rb
 - lib/capistrano_multiconfig_parallel/application.rb
 - lib/capistrano_multiconfig_parallel/base.rb
+- lib/capistrano_multiconfig_parallel/celluloid/bundler_worker.rb
 - lib/capistrano_multiconfig_parallel/celluloid/celluloid_manager.rb
 - lib/capistrano_multiconfig_parallel/celluloid/celluloid_worker.rb
-- lib/capistrano_multiconfig_parallel/celluloid/child_process.rb
+- lib/capistrano_multiconfig_parallel/celluloid/process_runner.rb
 - lib/capistrano_multiconfig_parallel/celluloid/state_machine.rb
 - lib/capistrano_multiconfig_parallel/celluloid/terminal_table.rb
 - lib/capistrano_multiconfig_parallel/celluloid/web_server.rb
+- lib/capistrano_multiconfig_parallel/classes/child_process_status.rb
 - lib/capistrano_multiconfig_parallel/classes/cursor.rb
 - lib/capistrano_multiconfig_parallel/classes/dependency_tracker.rb
 - lib/capistrano_multiconfig_parallel/classes/interactive_menu.rb
 - lib/capistrano_multiconfig_parallel/classes/job.rb
 - lib/capistrano_multiconfig_parallel/classes/job_command.rb
+- lib/capistrano_multiconfig_parallel/classes/runner_status.rb
 - lib/capistrano_multiconfig_parallel/cli.rb
 - lib/capistrano_multiconfig_parallel/configuration/default.yml
 - lib/capistrano_multiconfig_parallel/helpers/application_helper.rb

data/lib/capistrano_multiconfig_parallel/celluloid/child_process.rb

@@ -1,132 +0,0 @@
-require_relative '../helpers/base_actor_helper'
-module CapistranoMulticonfigParallel
-  # class that is used to execute the capistrano tasks and it is invoked by the celluloid worker
-  class ChildProcess
-    include CapistranoMulticonfigParallel::BaseActorHelper
-
-    attr_accessor :options, :job, :actor, :job_id, :exit_status, :pid, :process
-
-    finalizer :process_finalizer
-
-    def work(job, cmd, options = {})
-      @options = options
-      @job = job
-      @cmd = cmd
-      start_running
-    end
-
-    def start_running
-      setup_attributes
-      run_event_machine
-      setup_em_error_handler
-    end
-
-    def setup_attributes
-      @actor = @options.fetch(:actor, nil)
-      @job_id = @job.id
-      @exit_status = nil
-      @show_bundler = true
-    end
-
-    def setup_em_error_handler
-      EM.error_handler do|exception|
-        log_error(exception, job_id: @job_id, output: 'stderr')
-        EM.stop
-      end
-    end
-
-    def run_event_machine
-      EM.run do
-        EM.next_tick do
-          start_async_deploy
-        end
-        setup_periodic_timer
-      end
-    end
-
-    def setup_periodic_timer
-      @timer = EM::PeriodicTimer.new(0.1) do
-        check_exit_status
-        @timer.cancel if @exit_status.present?
-      end
-    end
-
-    def process_finalizer
-      EM.stop if EM.reactor_running?
-      terminate
-    end
-
-    def check_exit_status
-      return if @exit_status.blank?
-      @timer.cancel
-      @job.exit_status = @exit_status
-      print_error_if_exist
-      log_to_file("worker #{@job_id} startsnotify finished with exit status #{@exit_status.inspect}")
-      @actor.async.notify_finished(@exit_status)
-    end
-
-    def print_error_if_exist
-      return unless development_debug?
-      [@job.stderr_buffer].each do |buffer|
-        buffer.rewind
-        data = buffer.read
-        log_output_error(nil, 'stderr', "Child process for worker #{@job_id} died for reason: #{data}") if data.present?
-      end
-    end
-
-    def start_async_deploy
-      RightScale::RightPopen.popen3_async(
-        @cmd,
-        target: self,
-        environment: @options.fetch(:environment, nil),
-        pid_handler: :on_pid,
-        input: :on_input_stdin,
-        stdout_handler: :on_read_stdout,
-        stderr_handler: :on_read_stderr,
-        watch_handler: :watch_handler,
-        async_exception_handler: :async_exception_handler,
-        exit_handler: :on_exit)
-    end
-
-    def on_pid(pid)
-      @pid ||= pid
-    end
-
-    def on_input_stdin(data)
-      io_callback('stdin', data)
-    end
-
-    def on_read_stdout(data)
-      @show_bundler = false if  data.to_s.include?("The Gemfile's dependencies are satisfied") || data.to_s.include?("Bundle complete")
-      @actor.async.update_machine_state(truncate(data, 40), :bundler => true) if @show_bundler == true && data.strip.present? && data.strip != '.'
-      io_callback('stdout', data)
-    end
-
-    def on_read_stderr(data)
-      @job.save_stderr_error(data) if development_debug?
-      io_callback('stderr', data)
-    end
-
-    def on_exit(status)
-      log_to_file "Child process for worker #{@job_id} on_exit  disconnected due to error #{status.inspect}"
-      @exit_status = status.exitstatus
-      check_exit_status
-    end
-
-    def async_exception_handler(*data)
-      log_to_file "Child process for worker #{@job_id} async_exception_handler  disconnected due to error #{data.inspect}"
-      io_callback('stderr', data)
-      @exit_status = 1
-      check_exit_status
-    end
-
-    def watch_handler(process)
-      @process ||= process
-      check_exit_status
-    end
-
-    def io_callback(io, data)
-      log_to_file("#{io.upcase} ---- #{data}", job_id: @job_id)
-    end
-  end
-end