capistrano_multiconfig_parallel 1.7.2 → 2.0.0.beta1

data/lib/capistrano_multiconfig_parallel/base.rb

@@ -1,6 +1,5 @@
 # base module that has the statis methods that this gem is using
 module CapistranoMulticonfigParallel
-  ENV_KEY_JOB_ID = 'multi_cap_job_id'
   GITFLOW_TAG_STAGING_TASK = 'gitflow:tag_staging'
   GITFLOW_CALCULATE_TAG_TASK = 'gitflow:calculate_tag'
   GITFLOW_VERIFY_UPTODATE_TASK = 'gitflow:verify_up_to_date'
@@ -15,6 +14,10 @@ module CapistranoMulticonfigParallel
       @config
     end
 
+    def env_job_key_id
+      CapistranoSentinel::RequestHooks::ENV_KEY_JOB_ID
+    end
+
     def configuration_flags
       default_internal_config.each_with_object({}) do |array_item, hash|
         key = array_item[0].to_s
@@ -29,21 +32,18 @@ module CapistranoMulticonfigParallel
       set_celluloid_exception_handling
     end
 
-    def job_id
-      original_args_hash.fetch(CapistranoMulticonfigParallel::ENV_KEY_JOB_ID, nil)
-    end
-
     def original_args_hash
       multi_fetch_argv((original_args || ARGV).dup)
     end
 
-    def capistrano_version
-      find_loaded_gem_property('capistrano', 'version')
-    end
+    # def capistrano_version
+    #   find_loaded_gem_property('capistrano', 'version')
+    # end
+    #
+    # def capistrano_version_2?
+    #   capistrano_version.blank? ? false : verify_gem_version(capistrano_version, '3.0', operator: '<')
+    # end
 
-    def capistrano_version_2?
-      capistrano_version.blank? ? false : verify_gem_version(capistrano_version, '3.0', operator: '<')
-    end
 
   private
 

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_manager.rb

@@ -6,7 +6,7 @@ module CapistranoMulticonfigParallel
   # manager class that handles workers
   class CelluloidManager
     include CapistranoMulticonfigParallel::BaseActorHelper
-    attr_accessor :jobs, :job_to_worker, :worker_to_job, :job_to_condition, :mutex, :registration_complete, :workers_terminated, :stderr_buffer
+   attr_accessor :jobs, :job_to_worker, :worker_to_job, :job_to_condition, :mutex, :registration_complete, :workers_terminated, :stderr_buffer
 
     attr_reader :worker_supervisor, :workers
     trap_exit :worker_died
@@ -26,10 +26,10 @@ module CapistranoMulticonfigParallel
       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)
-
       # Get a handle on the PoolManager
       # http://rubydoc.info/gems/celluloid/Celluloid/PoolManager
       # @workers = workers_pool.actor
+
       @stderr_buffer = StringIO.new
       @conditions = []
       @jobs = {}
@@ -221,6 +221,7 @@ module CapistranoMulticonfigParallel
     def worker_died(worker, reason)
       job = @worker_to_job[worker.mailbox.address]
       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}")

data/lib/capistrano_multiconfig_parallel/celluloid/celluloid_worker.rb

@@ -20,10 +20,10 @@ module CapistranoMulticonfigParallel
     include CapistranoMulticonfigParallel::BaseActorHelper
     class TaskFailed < StandardError; end
 
-    attr_accessor :job, :manager, :job_id, :app_name, :env_name, :action_name, :env_options, :machine, :client, :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
+    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
 
     def initialize(*args)
     end
@@ -35,12 +35,13 @@ module CapistranoMulticonfigParallel
       @manager = manager
       @job_confirmation_conditions = []
       log_to_file("worker #{@job_id} received #{job.inspect}")
-      @subscription_channel = "worker_#{@job_id}"
+      @subscription_channel = "#{CapistranoSentinel::RequestHooks::PUBLISHER_PREFIX}#{@job_id}"
       @machine = CapistranoMulticonfigParallel::StateMachine.new(@job, Actor.current)
       @manager.setup_worker_conditions(@job)
       manager.register_worker_for_job(job, Actor.current)
     end
 
+
     def worker_state
       if Actor.current.alive?
         @machine.state.to_s.green
@@ -51,21 +52,18 @@ module CapistranoMulticonfigParallel
     end
 
     def start_task
-      log_to_file("exec worker #{@job_id} starts task")
-      @client = CelluloidPubsub::Client.new(actor: Actor.current, enable_debug: debug_websocket?, channel: subscription_channel, log_file_path: websocket_config.fetch('log_file_path', nil))
+      log_to_file("exec worker #{@job_id} starts task and subscribes to #{@subscription_channel}")
+      @socket_connection = CelluloidPubsub::Client.new(actor: Actor.current, enable_debug: debug_websocket?, channel: subscription_channel, log_file_path: websocket_config.fetch('log_file_path', nil))
     end
 
     def publish_rake_event(data)
-      @client.publish(rake_actor_id(data), data)
-    end
-
-    def rake_actor_id(_data)
-      "rake_worker_#{@job_id}"
+      log_to_file("worker #{@job_id} rties to publish into channel #{CapistranoSentinel::RequestHooks::SUBSCRIPTION_PREFIX}#{@job_id} data #{data.inspect}")
+      @socket_connection.publish("#{CapistranoSentinel::RequestHooks::SUBSCRIPTION_PREFIX}#{@job_id}", data)
     end
 
     def on_message(message)
       log_to_file("worker #{@job_id} received:  #{message.inspect}")
-      if @client.succesfull_subscription?(message)
+      if @socket_connection.succesfull_subscription?(message)
         @successfull_subscription = true
         execute_after_succesfull_subscription
       else
@@ -89,7 +87,8 @@ module CapistranoMulticonfigParallel
     def execute_deploy
       log_to_file("invocation chain #{@job_id} is : #{@rake_tasks.inspect}")
       check_child_proces
-      command = job.command.to_s
+      job.command.prepare_application_for_deployment
+      command = job.command.fetch_deploy_command
       log_to_file("worker #{@job_id} executes: #{command}")
       @child_process.async.work(@job, command, actor: Actor.current, silent: true)
     end
@@ -98,7 +97,7 @@ module CapistranoMulticonfigParallel
       @child_process = CapistranoMulticonfigParallel::ChildProcess.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}")
@@ -119,18 +118,29 @@ 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)
+
+        #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'])
+        #end
       else
-        log_to_file(message, @job_id)
+        log_to_file(message, job_id: @job_id)
       end
     end
 
+
     def executed_task?(task)
       rake_tasks.present? && rake_tasks.index(task.to_s).present?
     end
 
     def task_approval(message)
       job_conditions = @manager.job_to_condition[@job_id]
+      log_to_file("worker #{@job_id} checks if task : #{message['task'].inspect} is included in #{configuration.task_confirmations.inspect}")
       if job_conditions.present? && configuration.task_confirmations.include?(message['task']) && message['action'] == 'invoke'
+        log_to_file("worker #{@job_id} signals approval for task : #{message['task'].inspect}")
         task_confirmation = job_conditions[message['task']]
         task_confirmation[:status] = 'confirmed'
         task_confirmation[:condition].signal(message['task'])
@@ -145,15 +155,17 @@ module CapistranoMulticonfigParallel
       invocation_chain << message['task'] if invocation_chain.last != message['task']
     end
 
-    def update_machine_state(name)
-      log_to_file("worker #{@job_id} triest to transition from #{@machine.state} to  #{name}")
-      @machine.go_to_transition(name.to_s)
+    def update_machine_state(name, options = {})
+      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 "
       raise(CapistranoMulticonfigParallel::CelluloidWorker::TaskFailed.new(error_message), error_message) if job.failed? # force worker to rollback
     end
 
     def send_msg(channel, message = nil)
-      publish channel, message.present? && message.is_a?(Hash) ? { job_id: @job_id }.merge(message) : { job_id: @job_id, time: Time.now }
+      message = message.present? && message.is_a?(Hash) ? { job_id: @job_id }.merge(message) : { job_id: @job_id, message: message }
+      log_to_file("worker #{@job_id} triest to send to #{channel} #{message}")
+      publish channel, message
     end
 
     def finish_worker(exit_status)

data/lib/capistrano_multiconfig_parallel/celluloid/child_process.rb

@@ -25,6 +25,7 @@ module CapistranoMulticonfigParallel
       @actor = @options.fetch(:actor, nil)
       @job_id = @job.id
       @exit_status = nil
+      @show_bundler = true
     end
 
     def setup_em_error_handler
@@ -96,6 +97,8 @@ module CapistranoMulticonfigParallel
     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
 

data/lib/capistrano_multiconfig_parallel/celluloid/state_machine.rb

@@ -11,15 +11,21 @@ module CapistranoMulticonfigParallel
       machine
     end
 
-    def go_to_transition(action)
+    def go_to_transition(action, options = {})
       transitions.on(action, state.to_s => action)
       @job.status = action
-      machine.trigger(action)
+      if options[:bundler]
+        @job.bundler_status = action
+        actor_notify_state_change(state, "preparing_app_bundle_install", action)
+      else
+        @job.bundler_status = nil
+        machine.trigger(action)
+      end
     end
 
     def machine
       @machine ||= ComposableStateMachine::MachineWithExternalState.new(
-        model, method(:state), method(:state=), state: @initial_state.to_s, callback_runner: self)
+      model, method(:state), method(:state=), state: @initial_state.to_s, callback_runner: self)
       @machine
     end
 
@@ -30,23 +36,24 @@ module CapistranoMulticonfigParallel
 
     def model
       ComposableStateMachine.model(
-        transitions: transitions,
-        behaviors: {
-          enter: {
-            any: proc do |current_state, event, new_state|
-              actor_notify_state_change(current_state, event, new_state)
-            end
-          }
-        },
-        initial_state: @initial_state
+      transitions: transitions,
+      behaviors: {
+        enter: {
+          any: proc do |current_state, event, new_state|
+            actor_notify_state_change(current_state, event, new_state)
+          end
+        }
+      },
+      initial_state: @initial_state
       )
     end
 
-  private
+    private
 
     def actor_notify_state_change(current_state, event, new_state)
       return unless @actor.alive?
-      @actor.send_msg(CapistranoMulticonfigParallel::TerminalTable.topic, type: 'event', new_state: new_state, message: "Going from #{current_state} to #{new_state}  due to a #{event} event")
+      @actor.log_to_file("statemachine #{@job.id} triest to transition from #{@current_state} to  #{new_state} for event #{event}")
+      @actor.async.send_msg(CapistranoMulticonfigParallel::TerminalTable.topic, type: 'event', new_state: new_state , current_state: current_state, event: event, message: "Going from #{current_state} to #{new_state}  due to a #{event} event")
     end
   end
 end

data/lib/capistrano_multiconfig_parallel/celluloid/terminal_table.rb

@@ -28,6 +28,7 @@ module CapistranoMulticonfigParallel
       @screen_erased = false
       async.run
     rescue => ex
+      puts ex.inspect
       rescue_exception(ex)
     end
 
@@ -39,7 +40,7 @@ module CapistranoMulticonfigParallel
       subscribe(CapistranoMulticonfigParallel::TerminalTable.topic, :notify_time_change)
     end
 
-    def notify_time_change(_channel, _message)
+    def notify_time_change(_channel, message)
       table = Terminal::Table.new(title: 'Deployment Status Table', headings: default_heaadings)
       jobs = setup_table_jobs(table)
       display_table_on_terminal(table, jobs)
@@ -90,12 +91,12 @@ module CapistranoMulticonfigParallel
     end
 
     def managers_alive?
-      @job_manager.alive? && @manager.alive?
+       @manager.alive?
     end
 
     def signal_complete
       if managers_alive? && @manager.all_workers_finished? && workers_terminated.instance_variable_get("@waiters").blank?
-        condition.signal('completed') if @job_manager.alive? && condition.instance_variable_get("@waiters").present?
+        condition.signal('completed') if condition.instance_variable_get("@waiters").present?
       elsif !managers_alive?
         terminate
       end

data/lib/capistrano_multiconfig_parallel/classes/cursor.rb

@@ -6,8 +6,12 @@ module CapistranoMulticonfigParallel
     include CapistranoMulticonfigParallel::ApplicationHelper
 
     def display_on_screen(string, options = {})
-      options = options.is_a?(Hash) ? options.stringify_keys : {}
-      handle_string_display(string, options)
+      begin
+        options = options.is_a?(Hash) ? options.stringify_keys : {}
+        handle_string_display(string, options)
+      rescue => ex
+        rescue_error(ex, 'stderr')
+      end
     end
 
     private

data/lib/capistrano_multiconfig_parallel/classes/dependency_tracker.rb

@@ -11,7 +11,7 @@ module CapistranoMulticonfigParallel
     end
 
     def fetch_apps_needed_for_deployment(application, action)
-      return [[], {}] unless @job_manager.multi_apps?
+      return [[], {}] unless @job_manager.send(:multi_apps?)
       if @job_manager.custom_command?
         show_interactive_menu(action)
       else

data/lib/capistrano_multiconfig_parallel/classes/job.rb

@@ -5,18 +5,21 @@ module CapistranoMulticonfigParallel
   class Job
     include CapistranoMulticonfigParallel::ApplicationHelper
 
-    attr_reader :options, :application, :manager
-    attr_writer :status, :exit_status
+    attr_reader :options, :application, :manager, :bundler_status
+    attr_writer :status, :exit_status, :bundler_status
 
     delegate :job_stage,
-             :capistrano_action,
-             :execute_standard_deploy,
-             :setup_command_line,
-             :gem_specs,
-             to: :command
+    :capistrano_action,
+    :execute_standard_deploy,
+    :setup_command_line,
+    :job_capistrano_version,
+    :gem_specs,
+    :job_stage_for_terminal,
+    :rollback_changes_to_application,
+    to: :command
 
     delegate :stderr_buffer,
-             to: :manager
+    to: :manager
 
     def initialize(application, options)
       @options = options.stringify_keys
@@ -25,6 +28,7 @@ module CapistranoMulticonfigParallel
       @gitflow ||= command.gitflow_enabled?
     end
 
+
     def save_stderr_error(data)
       return unless development_debug?
       return unless @manager.alive?
@@ -35,7 +39,7 @@ module CapistranoMulticonfigParallel
     end
 
     def env_variable
-      CapistranoMulticonfigParallel::ENV_KEY_JOB_ID
+      CapistranoMulticonfigParallel.env_job_key_id
     end
 
     def command
@@ -47,12 +51,27 @@ module CapistranoMulticonfigParallel
     end
 
     def terminal_row
+      if bundler_status
+        bundler_terminal_row
+      else
+        [
+          { value: id.to_s },
+          { value: wrap_string(job_stage_for_terminal) },
+          { value: wrap_string(capistrano_action) },
+          { value: terminal_env_variables.map { |str| wrap_string(str) }.join("\n") },
+          { value: wrap_string(worker_state) }
+        ]
+      end
+    end
+
+
+    def bundler_terminal_row
       [
         { value: id.to_s },
-        { value: wrap_string(job_stage) },
-        { value: wrap_string(capistrano_action) },
+        { value: wrap_string(job_stage_for_terminal) },
+        { value: "Preparing app...setting up gems" },
         { value: terminal_env_variables.map { |str| wrap_string(str) }.join("\n") },
-        { value: wrap_string(worker_state) }
+        { value: wrap_string(status.to_s.green) }
       ]
     end
 
@@ -90,12 +109,18 @@ module CapistranoMulticonfigParallel
     ].each do |hash|
       define_method hash[:name] do
         value = @options.fetch(hash[:name], hash[:default])
-        value["#{env_variable}"] = id if hash[:name] == 'env_options'
+        setup_additional_env_variables(value) if hash[:name] == 'env_options'
         value = verify_empty_options(value)
         instance_variable_set("@#{hash[:name]}", instance_variable_get("@#{hash[:name]}") || value)
       end
     end
 
+
+    def setup_additional_env_variables(value)
+      value["#{env_variable}"] = id
+      value["capistrano_version"] = job_capistrano_version
+    end
+
     def finished?
       status == 'finished'
     end

data/lib/capistrano_multiconfig_parallel/classes/job_command.rb

@@ -6,7 +6,7 @@ module CapistranoMulticonfigParallel
     include FileUtils
     include CapistranoMulticonfigParallel::ApplicationHelper
 
-    attr_reader :job, :job_capistrano_version, :legacy_capistrano
+    attr_reader :job, :job_capistrano_version, :legacy_capistrano, :tempfile
     delegate :id, :app, :stage, :action, :task_arguments, :env_options, :path, to: :job
 
     def initialize(job)
@@ -43,15 +43,29 @@ module CapistranoMulticonfigParallel
       %w(STAGES ACTION)
     end
 
-    def bundle_gemfile_env
-      "BUNDLE_GEMFILE=#{job_gemfile}"
+    def bundle_gemfile_env(gemfile = job_gemfile)
+      "BUNDLE_GEMFILE=#{gemfile}"
     end
 
+
     def gitflow_enabled?
-     gitflow_version = job_gem_version("capistrano-gitflow")
+      gitflow_version = job_gem_version("capistrano-gitflow")
       gitflow_version.present? ? true : false
     end
 
+    def request_handler_gem_name
+      "capistrano_sentinel"
+    end
+
+    def request_handler_gem_available?
+      gitflow_version = job_gem_version(request_handler_gem_name)
+      gitflow_version.present? ? true : false
+    end
+
+    def job_stage_for_terminal
+      app.present? ? "#{app}:#{stage}" : "#{stage}"
+    end
+
     def job_stage
       multi_apps?(job_path) && app.present? ? "#{app}:#{stage}" : "#{stage}"
     end
@@ -96,29 +110,154 @@ module CapistranoMulticonfigParallel
       path || detect_root
     end
 
-    def command_prefix
-      bundle_install = path.present? ? "&& #{bundle_gemfile_env} bundle install" : ''
-      "cd #{job_path} #{bundle_install}"
+    def user_home_directory
+      user = Etc.getlogin
+      Dir.home(user)
+    end
+
+    def rvm_bin_path
+      @rvm_path ||= `which rvm`
     end
 
-    def to_s
-      config_flags = CapistranoMulticonfigParallel.configuration_flags
-      environment_options = setup_command_line(config_flags).join(' ')
-      "#{command_prefix} && #{bundle_gemfile_env} bundle exec multi_cap #{job_stage} #{capistrano_action} #{environment_options}"
+    def bash_bin_path
+      @bash_bin_path ||= `which bash`
     end
 
-    def to_json
-      { command: to_s }
+    def rvm_installed?
+      rvm_bin_path.present?
+    end
+
+    def create_job_tempfile_command(output)
+      @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
+    end
+
+    def rvm_scripts_path
+      File.join(File.dirname(File.dirname(rvm_bin_path)), 'scripts', 'rvm')
+    end
+
+    def job_rvmrc_file
+      File.join(job_path, '.rvmrc')
+    end
+
+    def job_rvmrc_enabled?
+      File.exists?(job_rvmrc_file)
+    end
+
+    def rvm_enabled_for_job?
+      job_rvmrc_enabled? && rvm_installed? && bash_bin_path.present?
+    end
+
+    def check_rvm_loaded
+      return  "cd #{job_path}" unless rvm_enabled_for_job?
+      "source #{rvm_scripts_path} && rvm rvmrc trust #{job_path} && cd #{job_path} && source #{job_rvmrc_file}"
+    end
+
+    def fetch_deploy_command
+      #  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_gemfile_multi)} bundle check || #{bundle_gemfile_env(job_gemfile_multi)} bundle install ) && WEBSOCKET_LOGGING=#{debug_websocket?} LOG_FILE=#{websocket_config.fetch('log_file_path', nil)} #{bundle_gemfile_env(job_gemfile_multi)} bundle exec cap #{job_stage} #{capistrano_action} #{environment_options}"
+
+      command = "bash --login -c '#{command}'"  if rvm_enabled_for_job?
+      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
+
+      if rvm_enabled_for_job?
+        create_job_tempfile_command(command_text)
+        "ruby #{@tempfile.path}"
+      else
+        <<-CMD
+        cd #{job_path} && bundle exec ruby -e "#{command_text}"
+        CMD
+      end
+    end
+
+
+    def job_capfile
+      File.join(job_path, "Capfile")
+    end
+
+    def job_gemfile_multi
+      File.join(job_path, "Gemfile.multi_cap")
+    end
+
+    def prepare_application_for_deployment
+      check_handler_available
+      prepare_capfile
+    end
+
+    def check_handler_available
+      #  '#{find_loaded_gem_property(request_handler_gem_name)}'
+      #  path: '/home/raul/workspace/github/capistrano_sentinel'
+      FileUtils.rm_rf(job_gemfile_multi) if File.exists?(job_gemfile_multi)
+      FileUtils.touch(job_gemfile_multi)
+      if request_handler_gem_available?
+        FileUtils.copy(File.join(job_path, 'Gemfile'), job_gemfile_multi)
+      else
+        File.open(job_gemfile_multi, 'w') do |f|
+          cmd=<<-CMD
+          source "https://rubygems.org" do
+            gem "#{request_handler_gem_name}", '#{find_loaded_gem_property(request_handler_gem_name)}'
+          end
+          instance_eval(File.read(File.dirname(__FILE__) + "/Gemfile"))
+          CMD
+          f.write(cmd)
+        end
+      end
+      FileUtils.copy(File.join(job_path, 'Gemfile.lock'), "#{job_gemfile_multi}.lock")
+    end
+
+    def prepare_capfile
+      return if File.foreach(job_capfile).grep(/#{request_handler_gem_name}/).any?
+      File.open(job_capfile, 'a+') do |f|
+        cmd=<<-CMD
+        require "#{request_handler_gem_name}"
+        CMD
+        f.write(cmd)
+      end
+    end
+
+
+    def rollback_changes_to_application
+      FileUtils.rm_rf(job_gemfile_multi)
+      FileUtils.rm_rf("#{job_gemfile_multi}.lock")
+      unless request_handler_gem_available?
+        File.open(job_capfile, 'r') do |f|
+          File.open("#{job_capfile}.tmp", 'w') do |f2|
+            f.each_line do |line|
+              f2.write(line) unless line.include?(request_handler_gem_name)
+            end
+          end
+        end
+        FileUtils.mv "#{job_capfile}.tmp", job_capfile
+        FileUtils.rm_rf("#{job_capfile}.tmp")
+      end
+      FileUtils.rm_rf(@tempfile.path) if defined?(@tempfile) && @tempfile
     end
 
     def execute_standard_deploy(action = nil)
-      run_shell_command(to_s)
+      run_shell_command(fetch_deploy_command)
     rescue => ex
       rescue_error(ex, 'stderr')
       execute_standard_deploy('deploy:rollback') if action.blank? && @name == 'deploy'
     end
 
-  private
+    private
+
+    def get_bash_command(command)
+      Shellwords.escape(command)
+    end
 
     def run_shell_command(command)
       sh("#{command}")