smart_proxy_remote_execution_ssh 0.0.13 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91afb2738282d322802d7b56291b5240cb62b478
-  data.tar.gz: b42e795f671e0165e60fe821ca12de4c70884fd1
+  metadata.gz: f230840d2fd18a938ceef7c2258a7d9e5aa39531
+  data.tar.gz: 4ceec21bcf79ac48db17d515ea22c160453d61ae
 SHA512:
-  metadata.gz: 17ce48cae4e47ebb886157156f0d5e35271b184f84e07762dff735bbe32ae458a907a6956a20d1f18c686dc24802f48018eff8ec8a341071f1c65a5a6bd7f4ca
-  data.tar.gz: bb75cd72b3fbb5a28c63c7b28a6067ac02d6f568ed40bd759dcdd3102b4b4cae5af24e4631276a2220dd8b094553fc0c83697bccc6ba597114b8a351ff520e25
+  metadata.gz: 0e451301babf18b38cfa04af50849e8f07ab90fb6ca24a31a775670165e71b4631ce259524b701b96e77c0b241e70b7a84fe04f7a61ae25ad91e69b574eb5fe7
+  data.tar.gz: 5585a0c4eff8a6d77131cd46bf1312d6cf8ca3e676d204772537246033da031aac73c21e20c46e5906a85edf64df0ff3d386914a05cb48d7861a323e5fa3fc0b

data/bundler.d/Gemfile.local.rb

@@ -0,0 +1 @@
+gem 'pry'

data/lib/smart_proxy_remote_execution_ssh/plugin.rb

@@ -13,11 +13,14 @@ module Proxy::RemoteExecution::Ssh
     after_activation do
       require 'smart_proxy_dynflow'
       require 'smart_proxy_remote_execution_ssh/version'
-      require 'smart_proxy_remote_execution_ssh/connector'
-      require 'smart_proxy_remote_execution_ssh/command_update'
-      require 'smart_proxy_remote_execution_ssh/dispatcher'
-      require 'smart_proxy_remote_execution_ssh/command_action'
       require 'smart_proxy_remote_execution_ssh/api'
+
+      begin
+        require 'smart_proxy_remote_execution_ssh_core'
+      rescue LoadError
+      end
+
+      Proxy::RemoteExecution::Ssh.validate!
     end
   end
 end

data/lib/smart_proxy_remote_execution_ssh/version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module RemoteExecution
     module Ssh
-      VERSION = '0.0.13'
+      VERSION = '0.1.0'
     end
   end
 end

data/lib/smart_proxy_remote_execution_ssh.rb

@@ -5,7 +5,7 @@ require 'smart_proxy_remote_execution_ssh/plugin'
 module Proxy::RemoteExecution
   module Ssh
     class << self
-      def initialize
+      def validate!
         unless private_key_file
           raise "settings for `ssh_identity_key` not set"
         end
@@ -18,18 +18,10 @@ module Proxy::RemoteExecution
         unless File.exist?(public_key_file)
           raise "Ssh public key file #{public_key_file} doesn't exist"
         end
-
-        @dispatcher = Proxy::RemoteExecution::Ssh::Dispatcher.spawn('proxy-ssh-dispatcher',
-                                                                    :clock  => Proxy::Dynflow.instance.world.clock,
-                                                                    :logger => Proxy::Dynflow.instance.world.logger)
-      end
-
-      def dispatcher
-        @dispatcher || initialize
       end
 
       def private_key_file
-        File.expand_path(Ssh::Plugin.settings.ssh_identity_key_file)
+        File.expand_path(Plugin.settings.ssh_identity_key_file)
       end
 
       def public_key_file
@@ -38,5 +30,3 @@ module Proxy::RemoteExecution
     end
   end
 end
-
-Proxy::Dynflow.after_initialize { Proxy::RemoteExecution::Ssh.initialize }

data/settings.d/smart_proxy_remote_execution_ssh.yml.example

@@ -0,0 +1,5 @@
+---
+:enabled: true
+:ssh_identity_key_file: '~/.ssh/id_rsa_foreman_proxy'
+:local_working_dir: '/var/tmp'
+:remote_working_dir: '/var/tmp'

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_remote_execution_ssh
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.1.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-16 00:00:00.000000000 Z
+date: 2016-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -112,46 +112,17 @@ dependencies:
   name: smart_proxy_dynflow
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.3
-- !ruby/object:Gem::Dependency
-  name: net-ssh
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: net-scp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: |2
-      Ssh remote execution provider for Foreman Smart-Proxy
+        version: 0.1.0
+description: "    Ssh remote execution provider for Foreman Smart-Proxy\n"
 email:
 - inecas@redhat.com
 executables: []
@@ -162,18 +133,15 @@ extra_rdoc_files:
 files:
 - LICENSE
 - README.md
+- bundler.d/Gemfile.local.rb
 - bundler.d/remote_execution_ssh.rb
 - lib/smart_proxy_remote_execution_ssh.rb
 - lib/smart_proxy_remote_execution_ssh/api.rb
-- lib/smart_proxy_remote_execution_ssh/command_action.rb
-- lib/smart_proxy_remote_execution_ssh/command_update.rb
-- lib/smart_proxy_remote_execution_ssh/connector.rb
-- lib/smart_proxy_remote_execution_ssh/dispatcher.rb
 - lib/smart_proxy_remote_execution_ssh/http_config.ru
 - lib/smart_proxy_remote_execution_ssh/plugin.rb
-- lib/smart_proxy_remote_execution_ssh/session.rb
 - lib/smart_proxy_remote_execution_ssh/version.rb
 - settings.d/remote_execution_ssh.yml.example
+- settings.d/smart_proxy_remote_execution_ssh.yml.example
 homepage: https://github.com/theforeman/smart_proxy_remote_execution_ssh
 licenses:
 - GPLv3
@@ -184,12 +152,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -199,3 +167,4 @@ signing_key:
 specification_version: 4
 summary: Ssh remote execution provider for Foreman Smart-Proxy
 test_files: []
+has_rdoc: 

data/lib/smart_proxy_remote_execution_ssh/command_action.rb

@@ -1,82 +0,0 @@
-module Proxy::RemoteExecution::Ssh
-  class CommandAction < ::Dynflow::Action
-    include Dynflow::Action::Cancellable
-    include ::Proxy::Dynflow::Callback::PlanHelper
-
-    def plan(input)
-      if callback = input['callback']
-        input[:task_id] = callback['task_id']
-      else
-        input[:task_id] ||= SecureRandom.uuid
-      end
-      plan_with_callback(input)
-    end
-
-    def run(event = nil)
-      case event
-      when nil
-        init_run
-      when CommandUpdate
-        process_update(event)
-      when Dynflow::Action::Cancellable::Cancel
-        kill_run
-      when Dynflow::Action::Skip
-        # do nothing
-      else
-        raise "Unexpected event #{event.inspect}"
-      end
-    rescue => e
-      action_logger.error(e)
-      process_update(CommandUpdate.new(CommandUpdate.encode_exception("Proxy error", e)))
-    end
-
-    def finalize
-      # To mark the task as a whole as failed
-      error! "Script execution failed" if failed_run?
-    end
-
-    def rescue_strategy_for_self
-      Dynflow::Action::Rescue::Skip
-    end
-
-    def command
-      @command ||= Dispatcher::Command.new(:id                    => input[:task_id],
-                                           :host                  => input[:hostname],
-                                           :ssh_user              => input[:ssh_user] || 'root',
-                                           :effective_user        => input[:effective_user],
-                                           :script                => input[:script],
-                                           :effective_user_method => input[:effective_user_method],
-                                           :host_public_key       => input[:host_public_key],
-                                           :verify_host           => input[:verify_host],
-                                           :suspended_action      => suspended_action)
-    end
-
-    def init_run
-      output[:result] = []
-      Proxy::RemoteExecution::Ssh.dispatcher.tell([:initialize_command, command])
-      suspend
-    end
-
-    def kill_run
-      Proxy::RemoteExecution::Ssh.dispatcher.tell([:kill, command])
-      suspend
-    end
-
-    def finish_run(update)
-      output[:exit_status] = update.exit_status
-    end
-
-    def process_update(update)
-      output[:result].concat(update.buffer_to_hash)
-      if update.exit_status
-        finish_run(update)
-      else
-        suspend
-      end
-    end
-
-    def failed_run?
-      output[:exit_status] != 0
-    end
-  end
-end

data/lib/smart_proxy_remote_execution_ssh/command_update.rb

@@ -1,74 +0,0 @@
-module Proxy::RemoteExecution::Ssh
-  # update sent back to the suspended action
-  class CommandUpdate
-    attr_reader :buffer, :exit_status
-
-    def initialize(buffer)
-      @buffer = buffer
-      extract_exit_status
-    end
-
-    def extract_exit_status
-      @buffer.delete_if do |data|
-        if data.is_a? StatusData
-          @exit_status = data.data
-          true
-        end
-      end
-    end
-
-    def buffer_to_hash
-      buffer.map(&:to_hash)
-    end
-
-    def self.encode_exception(description, exception, fatal = true)
-      ret = [DebugData.new("#{description}\n#{exception.class} #{exception.message}")]
-      ret << StatusData.new('EXCEPTION') if fatal
-      return ret
-    end
-
-    class Data
-      attr_reader :data, :timestamp
-
-      def initialize(data, timestamp = Time.now)
-        @data = data
-        @data = @data.force_encoding('UTF-8') if @data.is_a? String
-        @timestamp = timestamp
-      end
-
-      def data_type
-        raise NotImplemented
-      end
-
-      def to_hash
-        { :output_type => data_type,
-          :output => data,
-          :timestamp => timestamp.to_f }
-      end
-    end
-
-    class StdoutData < Data
-      def data_type
-        :stdout
-      end
-    end
-
-    class StderrData < Data
-      def data_type
-        :stderr
-      end
-    end
-
-    class DebugData < Data
-      def data_type
-        :debug
-      end
-    end
-
-    class StatusData < Data
-      def data_type
-        :status
-      end
-    end
-  end
-end

data/lib/smart_proxy_remote_execution_ssh/connector.rb

@@ -1,147 +0,0 @@
-require 'net/ssh'
-require 'net/scp'
-
-module Proxy::RemoteExecution::Ssh
-  # Service that handles running external commands for Actions::Command
-  # Dynflow action. It runs just one (actor) thread for all the commands
-  # running in the system and updates the Dynflow actions periodically.
-  class Connector
-    MAX_PROCESS_RETRIES = 3
-
-    def initialize(host, user, options = {})
-      @host = host
-      @user = user
-      @logger = options[:logger] || Logger.new($stderr)
-      @client_private_key_file = options[:client_private_key_file]
-      @known_hosts_file = options[:known_hosts_file]
-    end
-
-    # Initiates run of the remote command and yields the data when
-    # available. The yielding doesn't happen automatically, but as
-    # part of calling the `refresh` method.
-    def async_run(command)
-      started = false
-      session.open_channel do |channel|
-        channel.request_pty
-
-        channel.on_data { |ch, data| yield CommandUpdate::StdoutData.new(data) }
-
-        channel.on_extended_data { |ch, type, data| yield CommandUpdate::StderrData.new(data) }
-
-        # standard exit of the command
-        channel.on_request("exit-status") { |ch, data| yield CommandUpdate::StatusData.new(data.read_long) }
-
-        # on signal: sedning the signal value (such as 'TERM')
-        channel.on_request("exit-signal") do |ch, data|
-          yield(CommandUpdate::StatusData.new(data.read_string))
-          ch.close
-          # wait for the channel to finish so that we know at the end
-          # that the session is inactive
-          ch.wait
-        end
-
-        channel.exec(command) do |ch, success|
-          started = true
-          unless success
-            CommandUpdate.encode_exception("Error initializing command #{command}", e).each do |data|
-              yield data
-            end
-          end
-        end
-      end
-      session.process(0) until started
-      return true
-    end
-
-    def run(command)
-      output = ""
-      exit_status = nil
-      channel = session.open_channel do |ch|
-        ch.on_data { |data| output.concat(data) }
-
-        ch.on_extended_data { |_, _, data| output.concat(data) }
-
-        ch.on_request("exit-status") { |_, data| exit_status = data.read_long }
-
-        # on signal: sedning the signal value (such as 'TERM')
-        ch.on_request("exit-signal") do |_, data|
-          exit_status = data.read_string
-          ch.close
-          ch.wait
-        end
-
-        ch.exec command do |_, success|
-          raise "could not execute command" unless success
-        end
-      end
-      channel.wait
-      return exit_status, output
-    end
-
-    # calls the callback registered in the `async_run` when some data
-    # for the session are available
-    def refresh
-      return if @session.nil?
-      tries = 0
-      begin
-        session.process(0)
-      rescue Net::SSH::Disconnect => e
-        session.shutdown!
-        raise e
-      rescue => e
-        @logger.error("Error while processing ssh channel: #{e.class} #{e.message}\n #{e.backtrace.join("\n")}")
-        tries += 1
-        if tries <= MAX_PROCESS_RETRIES
-          retry
-        else
-          raise e
-        end
-      end
-    end
-
-    def upload_file(local_path, remote_path)
-      ensure_remote_directory(File.dirname(remote_path))
-      scp = Net::SCP.new(session)
-      upload_channel = scp.upload(local_path, remote_path)
-      upload_channel.wait
-    ensure
-      if upload_channel
-        upload_channel.close
-        upload_channel.wait
-      end
-    end
-
-    def ensure_remote_directory(path)
-      exit_code, output = run("mkdir -p #{path}")
-      if exit_code != 0
-        raise "Unable to create directory on remote system #{path}: exit code: #{exit_code}\n #{output}"
-      end
-    end
-
-    def close
-      @logger.debug("closing session to #{@user}@#{@host}")
-      @session.close unless @session.nil? || @session.closed?
-    end
-
-    private
-
-    def session
-      @session ||= begin
-                     @logger.debug("opening session to #{@user}@#{@host}")
-                     Net::SSH.start(@host, @user, ssh_options)
-                   end
-    end
-
-    def ssh_options
-      ssh_options = {}
-      ssh_options[:keys] = [@client_private_key_file] if @client_private_key_file
-      ssh_options[:user_known_hosts_file] = @known_hosts_file if @known_hosts_file
-      ssh_options[:keys_only] = true
-      # if the host public key is contained in the known_hosts_file,
-      # verify it, otherwise, if missing, import it and continue
-      ssh_options[:paranoid] = true
-      ssh_options[:auth_methods] = ["publickey"]
-      return ssh_options
-    end
-  end
-end

data/lib/smart_proxy_remote_execution_ssh/dispatcher.rb

@@ -1,93 +0,0 @@
-require 'smart_proxy_remote_execution_ssh/session'
-
-module Proxy::RemoteExecution::Ssh
-  # Service that handles running external commands for Actions::Command
-  # Dynflow action. It runs just one (actor) thread for all the commands
-  # running in the system and updates the Dynflow actions periodically.
-  class Dispatcher < ::Dynflow::Actor
-    # command comming from action
-    class Command
-      attr_reader :id, :host, :ssh_user, :effective_user, :effective_user_method, :script, :host_public_key, :suspended_action
-
-      def initialize(data)
-        validate!(data)
-
-        @id                    = data[:id]
-        @host                  = data[:host]
-        @ssh_user              = data[:ssh_user]
-        @effective_user        = data[:effective_user]
-        @effective_user_method = data[:effective_user_method] || 'su'
-        @script                = data[:script]
-        @host_public_key       = data[:host_public_key]
-        @suspended_action      = data[:suspended_action]
-      end
-
-      def validate!(data)
-        required_fields = [:id, :host, :ssh_user, :script, :suspended_action]
-        missing_fields = required_fields.find_all { |f| !data[f] }
-        raise ArgumentError, "Missing fields: #{missing_fields}" unless missing_fields.empty?
-      end
-    end
-
-    def initialize(options = {})
-      @clock                   = options[:clock] || Dynflow::Clock.spawn('proxy-dispatcher-clock')
-      @logger                  = options[:logger] || Logger.new($stderr)
-
-      @session_args = { :logger => @logger,
-                        :clock => @clock,
-                        :connector_class => options[:connector_class] || Connector,
-                        :local_working_dir => options[:local_working_dir] || ::Proxy::RemoteExecution::Ssh::Plugin.settings.local_working_dir,
-                        :remote_working_dir => options[:remote_working_dir] || ::Proxy::RemoteExecution::Ssh::Plugin.settings.remote_working_dir,
-                        :client_private_key_file => Proxy::RemoteExecution::Ssh.private_key_file,
-                        :refresh_interval => options[:refresh_interval] || 1 }
-
-      @sessions = {}
-    end
-
-    def initialize_command(command)
-      @logger.debug("initalizing command [#{command}]")
-      open_session(command)
-    rescue => exception
-      handle_command_exception(command, exception)
-    end
-
-    def kill(command)
-      @logger.debug("killing command [#{command}]")
-      session = @sessions[command.id]
-      session.tell(:kill) if session
-    rescue => exception
-      handle_command_exception(command, exception, false)
-    end
-
-    def finish_command(command)
-      close_session(command)
-    rescue => exception
-      handle_command_exception(command, exception)
-    end
-
-    private
-
-    def handle_command_exception(command, exception, fatal = true)
-      @logger.error("error while dispatching command #{command} to session:"\
-                    "#{exception.class} #{exception.message}:\n #{exception.backtrace.join("\n")}")
-      command_data = CommandUpdate.encode_exception("Failed to dispatch the command", exception, fatal)
-      command.suspended_action << CommandUpdate.new(command_data)
-      close_session(command) if fatal
-    end
-
-    def open_session(command)
-      raise "Session already opened for command #{command}" if @sessions[command.id]
-      options = { :name => "proxy-ssh-session-#{command.host}-#{command.ssh_user}-#{command.id}",
-                  :args => [@session_args.merge(:command => command)],
-                  :supervise => true }
-      @sessions[command.id] = Proxy::RemoteExecution::Ssh::Session.spawn(options)
-    end
-
-    def close_session(command)
-      session = @sessions.delete(command.id)
-      return unless session
-      @logger.debug("closing session for command [#{command}], #{@sessions.size} session(s) left ")
-      session.tell([:start_termination, Concurrent.future])
-    end
-  end
-end

data/lib/smart_proxy_remote_execution_ssh/session.rb

@@ -1,213 +0,0 @@
-require 'smart_proxy_remote_execution_ssh/session'
-
-module Proxy::RemoteExecution::Ssh
-  # Service that handles running external commands for Actions::Command
-  # Dynflow action. It runs just one (actor) thread for all the commands
-  # running in the system and updates the Dynflow actions periodically.
-  class Session < ::Dynflow::Actor
-    EXPECTED_POWER_ACTION_MESSAGES = ["restart host", "shutdown host"]
-
-    def initialize(options = {})
-      @clock = options[:clock] || Dynflow::Clock.spawn('proxy-dispatcher-clock')
-      @logger = options[:logger] || Logger.new($stderr)
-      @connector_class = options[:connector_class] || Connector
-      @local_working_dir = options[:local_working_dir] || ::Proxy::RemoteExecution::Ssh::Plugin.settings.local_working_dir
-      @remote_working_dir = options[:remote_working_dir] || ::Proxy::RemoteExecution::Ssh::Plugin.settings.remote_working_dir
-      @refresh_interval = options[:refresh_interval] || 1
-      @client_private_key_file = Proxy::RemoteExecution::Ssh.private_key_file
-      @command = options[:command]
-
-      @command_buffer = []
-      @refresh_planned = false
-
-      reference.tell(:initialize_command)
-    end
-
-    def initialize_command
-      @logger.debug("initalizing command [#{@command}]")
-      open_connector
-      remote_script = cp_script_to_remote
-      output_path = File.join(File.dirname(remote_script), 'output')
-
-      # pipe the output to tee while capturing the exit code
-      script = <<-SCRIPT
-        exec 4>&1
-        exit_code=`((#{su_prefix}#{remote_script}; echo $?>&3 ) | /usr/bin/tee #{output_path} ) 3>&1 >&4`
-        exec 4>&-
-        exit $exit_code
-      SCRIPT
-      @logger.debug("executing script:\n#{script.lines.map { |line| "  | #{line}" }.join}")
-      @connector.async_run(script) do |data|
-        @command_buffer << data
-      end
-    rescue => e
-      @logger.error("error while initalizing command #{e.class} #{e.message}:\n #{e.backtrace.join("\n")}")
-      @command_buffer.concat(CommandUpdate.encode_exception("Error initializing command #{@command}", e))
-      refresh
-    ensure
-      plan_next_refresh
-    end
-
-    def refresh
-      @connector.refresh if @connector
-
-      unless @command_buffer.empty?
-        status = refresh_command_buffer
-        if status
-          finish_command
-        end
-      end
-    rescue Net::SSH::Disconnect => e
-      check_expecting_disconnect
-      if @expecting_disconnect
-        @command_buffer << CommandUpdate::StatusData.new(0)
-      else
-        @command_buffer.concat(CommandUpdate.encode_exception("Failed to refresh the connector", e, true))
-      end
-      refresh_command_buffer
-      finish_command
-    rescue => e
-      @command_buffer.concat(CommandUpdate.encode_exception("Failed to refresh the connector", e, false))
-    ensure
-      @refresh_planned = false
-      plan_next_refresh
-    end
-
-    def refresh_command_buffer
-      @logger.debug("command #{@command} got new output: #{@command_buffer.inspect}")
-      command_update = CommandUpdate.new(@command_buffer)
-      check_expecting_disconnect
-      @command.suspended_action << command_update
-      @command_buffer = []
-      if command_update.exit_status
-        @logger.debug("command [#{@command}] finished with status #{command_update.exit_status}")
-        return command_update.exit_status
-      end
-    end
-
-    def kill
-      @logger.debug("killing command [#{@command}]")
-      if @connector
-        @connector.run("pkill -f #{remote_command_file('script')}")
-      else
-        @logger.debug("connection closed")
-      end
-    rescue => e
-      @command_buffer.concat(CommandUpdate.encode_exception("Failed to kill the command", e, false))
-      plan_next_refresh
-    end
-
-    def finish_command
-      close
-      dispatcher.tell([:finish_command, @command])
-    end
-
-    def dispatcher
-      self.parent
-    end
-
-    def start_termination(*args)
-      super
-      close
-      finish_termination
-    end
-
-    private
-
-    def su_prefix
-      return if @command.effective_user.nil? || @command.effective_user == @command.ssh_user
-      case @command.effective_user_method
-      when 'sudo'
-        "sudo -n -u #{@command.effective_user} "
-      when 'su'
-        "su - #{@command.effective_user} -c "
-      else
-        raise "effective_user_method ''#{@command.effective_user_method}'' not supported"
-      end
-    end
-
-    def open_connector
-      raise 'Connector already opened' if @connector
-      options = { :logger => @logger }
-      options[:known_hosts_file] = prepare_known_hosts
-      options[:client_private_key_file] = @client_private_key_file
-      @connector = @connector_class.new(@command.host, @command.ssh_user, options)
-    end
-
-    def local_command_dir
-      File.join(@local_working_dir, 'foreman-proxy', "foreman-ssh-cmd-#{@command.id}")
-    end
-
-    def local_command_file(filename)
-      File.join(local_command_dir, filename)
-    end
-
-    def remote_command_dir
-      File.join(@remote_working_dir, "foreman-ssh-cmd-#{@command.id}")
-    end
-
-    def remote_command_file(filename)
-      File.join(remote_command_dir, filename)
-    end
-
-    def ensure_local_directory(path)
-      if File.exist?(path)
-        raise "#{path} expected to be a directory" unless File.directory?(path)
-      else
-        FileUtils.mkdir_p(path)
-      end
-      return path
-    end
-
-    def cp_script_to_remote
-      local_script_file = write_command_file_locally('script', sanitize_script(@command.script))
-      File.chmod(0777, local_script_file)
-      remote_script_file = remote_command_file('script')
-      @connector.upload_file(local_script_file, remote_script_file)
-      return remote_script_file
-    end
-
-    def sanitize_script(script)
-      script.tr("\r", '')
-    end
-
-    def write_command_file_locally(filename, content)
-      path = local_command_file(filename)
-      ensure_local_directory(File.dirname(path))
-      File.write(path, content)
-      return path
-    end
-
-    def prepare_known_hosts
-      path = local_command_file('known_hosts')
-      if @command.host_public_key
-        write_command_file_locally('known_hosts', "#{@command.host} #{@command.host_public_key}")
-      end
-      return path
-    end
-
-    def close
-      @connector.close if @connector
-      @connector = nil
-    end
-
-    def plan_next_refresh
-      if @connector && !@refresh_planned
-        @logger.debug("planning to refresh")
-        @clock.ping(reference, Time.now + @refresh_interval, :refresh)
-        @refresh_planned = true
-      end
-    end
-
-    # when a remote server disconnects, it's hard to tell if it was on purpose (when calling reboot)
-    # or it's an error. When it's expected, we expect the script to produce 'restart host' as
-    # its last command output
-    def check_expecting_disconnect
-      last_output = @command_buffer.reverse.find { |d| d.is_a? CommandUpdate::StdoutData }
-      return unless last_output
-      if EXPECTED_POWER_ACTION_MESSAGES.any? { |message| last_output.data =~ /^#{message}/ }
-        @expecting_disconnect = true
-      end
-    end
-  end
-end