remote-exec 0.0.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8abbf419411c6fb963244ec42deb4c7d9703d1c4
-  data.tar.gz: 684effcebaabb98fa386ca30691c65ac455e5978
+  metadata.gz: ca220332149439af73e75f9c632cf6387ae16970
+  data.tar.gz: 7f5b2ac70fb84011a475b9bfee2d4e079103ec2b
 SHA512:
-  metadata.gz: c22eefd7ccc0b51b8f9cdc336ad2f7bd08729678731b24ea1e5b7e176524d9ab0a31ccba44b0aa8602f23b39d3c9bac4c2de41b0a11bdd72313acd8d24180f7a
-  data.tar.gz: b5b45613930e25e460b8c03f2adc66315e614fd9a920878d08d04515862f55584767eeeb200ba6bdb2156652eb849a68e77da04834d60d30bd3c4da676d5a796
+  metadata.gz: aa812243644b3eebfda7b71741ba1f9556090835cc7759b1a84e09edbbbfbbd9f5f904e2a07e792f598cc876b94170bddebe8f4c561d51cfb68204454bb55e82
+  data.tar.gz: f731278f988714a0232ee75ca89653caae39519f0f04ea25a1f9b1ddd84e7fad2898aa227a7d676e04954d4bf5cbba3bf08230da4d7956aaa94a935a85528b50

data/lib/remote-exec.rb

@@ -0,0 +1,4 @@
+require "remote_exec/version"
+require "remote_exec/fake"
+require "remote_exec/local"
+require "remote_exec/ssh"

data/lib/remote_exec/base.rb

@@ -0,0 +1,70 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require 'ruby/hooks'
+require "remote_exec/version"
+
+# Define minimal interface for execution handlers
+class RemoteExec::Base
+  extend Ruby::Hooks::InstanceHooks
+
+  # called before connection attempt will be made, used when connection may fail
+  # @param object [Object] the target that invoked the method
+  define_hook :before_connect
+
+  # called when connection attempt failed and we are about to sleep and retry
+  # @param object    [Object]    the target that invoked the method
+  # @param exception [Exception] exception that made the connection attempt fail
+  # @param retries   [Integer]   number of retries left
+  define_hook :on_connect_retry
+
+  # called when connection attempt failed and we no more retries left
+  # @param object    [Object]    the target that invoked the method
+  # @param exception [Exception] exception that made the connection attempt fail
+  define_hook :on_connect_fail
+
+  # called after connection / session is esatablished
+  # @param object [Object] the target that invoked the method
+  define_hook :after_connect
+
+  # called before terminating connection - only when needed
+  # @param object [Object] the target that invoked the method
+  define_hook :before_shutdown
+
+  # called before executing command
+  # @param object  [Object] the target that invoked the method
+  # @param command [String] the command to execute
+  define_hook :before_execute
+
+  # called before executing command
+  # @param object [Object] the target that invoked the method
+  # @param stdout [String] standard output of the command, can be nil
+  # @param stderr [String] standard error output of the command, can be nil
+  define_hook :on_execute_data
+
+  # called after executing command
+  # @param object  [Object]  the target that invoked the method
+  # @param command [String]  the executed command
+  # @param result  [Integer] the executed command status code (0 - ok, >0 - fail)
+  define_hook :after_execute
+
+  # standard in place handler that ensures shutdown is called
+  def initialize
+    if block_given?
+      begin
+        yield self
+      ensure
+        shutdown
+      end
+    end
+  end
+
+  # minimal handler for shutdown
+  def shutdown
+    before_shutdown.changed_and_notify(self)
+  end
+
+end

data/lib/remote_exec/fake.rb

@@ -0,0 +1,45 @@
+require "remote_exec/base"
+
+# Class to fake running commands and transfering files.
+class RemoteExec::Fake < RemoteExec::Base
+
+  ##
+  # The story to tell in +execute+, take an array
+  #
+  # @example usage
+  #
+  #   [1, [[nil,"error\n"]]
+  #
+  # consist of an array: [ return_status, [[ stdout, stderr],...] ]
+
+  attr_accessor :story
+
+  # Constructs a new Fake object.
+  #
+  # @yield       [self]   if a block is given then the constructed
+  # object yields itself and calls `#shutdown` at the end, closing the
+  # remote connection
+
+  def initialize
+    after_connect.changed_and_notify(self)
+    super
+  end
+
+  ##
+  # Execute fake command
+  #
+  # @param command [String]  command string to execute
+  # @return        [Integer] exit status of the command
+
+  def execute(command)
+    before_execute.changed_and_notify(self, command)
+    last_status, outputs = @story
+    outputs.each do |out, err|
+      on_execute_data.changed_and_notify(self, out, err)
+      yield(out, err) if block_given?
+    end
+    after_execute.changed_and_notify(self, command, last_status)
+    last_status
+  end
+
+end

data/lib/remote_exec/local.rb

@@ -0,0 +1,45 @@
+require 'session'
+require "remote_exec/base"
+
+# Class to run local commands and transfer files localy.
+class RemoteExec::Local < RemoteExec::Base
+  # name of the shell to run
+  attr_reader :shell
+
+  # Constructs a new Local object.
+  #
+  # @param shell [String] name of the shell to run
+  # @yield       [self]   if a block is given then the constructed
+  # object yields itself and calls `#shutdown` at the end, closing the
+  # remote connection
+
+  def initialize(shell = "sh")
+    @shell = shell
+    super()
+  end
+
+  ##
+  # Execute command locally
+  #
+  # @param command [String]  command string to execute
+  # @return        [Integer] exit status of the command
+
+  def execute(command)
+    before_execute.changed_and_notify(self, command)
+    shell_session.execute(command) do |out,err|
+      on_execute_data.changed_and_notify(self, out, err)
+      yield(out, err) if block_given?
+    end
+    last_status = shell_session.status
+    after_execute.changed_and_notify(self, command, last_status)
+    last_status
+  end
+
+private
+
+  def shell_session
+    @shell_session ||= Session::Sh.new(:prog => shell).tap do |shell|
+      after_connect.changed_and_notify(self)
+    end
+  end
+end

data/lib/remote_exec/ssh.rb

@@ -0,0 +1,139 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+
+Partially based on test-kitchen by Fletcher Nichol <fnichol@nichol.ca>
+License: https://github.com/test-kitchen/test-kitchen/blob/459238b88c/LICENSE
+=end
+
+require 'net/ssh'
+require 'ruby/hooks'
+require "remote_exec/base"
+
+# Class to help establish SSH connections, issue remote commands, and
+# transfer files between a local system and remote node.
+class RemoteExec::Ssh < RemoteExec::Base
+  # hostname for the connection
+  attr_reader :hostname
+  # username for the connection
+  attr_reader :username
+  # options for the connection
+  attr_accessor :options
+
+  # Constructs a new Ssh object.
+  #
+  # @param hostname [String] the remote hostname (IP address, FQDN, etc.)
+  # @param username [String] the username for the remote host
+  # @param options  [Hash]   configuration options for ssh
+  # @yield          [self]   if a block is given then the constructed
+  # object yields itself and calls `#shutdown` at the end, closing the
+  # remote connection
+  def initialize(hostname, username, options = {})
+    @hostname = hostname
+    @username = username
+    @options = options
+    super()
+  end
+
+  # Shuts down the session connection, if it is still active.
+  def shutdown
+    super
+    return if @ssh.nil?
+    ssh.shutdown!
+  ensure
+    @ssh = nil
+  end
+
+  ##
+  # Execute command on remote host
+  #
+  # @param command [String]  command string to execute
+  # @return        [Integer] exit status of the command
+
+  def execute(command)
+    # TODO: make it run in one session
+    @last_status = nil
+    @command     = command
+    ssh.open_channel(&method(:execute_open_channel))
+    ssh.loop
+    @last_status
+  end
+
+private
+
+  def execute_open_channel(channel)
+    before_execute.changed_and_notify(self, @command)
+    channel.request_pty
+    channel.exec(@command, &method(:execute_channel_exec))
+    channel.wait
+    after_execute.changed_and_notify(self, @command, @last_status)
+  end
+
+  def execute_channel_exec(channel, success)
+    channel.on_data(&method(:execute_on_stdout))
+    channel.on_extended_data(&method(:execute_on_stderr))
+    channel.on_request("exit-status") do |channel, data|
+      @last_status = data.read_long
+    end
+  end
+
+  def execute_on_stdout(channel, data)
+    on_execute_data.changed_and_notify(self, data, nil)
+    yield(data, nil) if block_given?
+  end
+
+  def execute_on_stderr(channel, type, data)
+    case type
+    when 1
+      on_execute_data.changed_and_notify(self, nil, data)
+      yield(nil, data) if block_given?
+    else
+      raise "Unsupported SSH extended_data type: #{type.inspect}"
+    end
+  end
+
+  def ssh
+    @ssh ||= establish_connection
+  end
+
+  RESCUE_EXCEPTIONS = [
+    Errno::EACCES,
+    Errno::EADDRINUSE,
+    Errno::ECONNREFUSED,
+    Errno::ECONNRESET,
+    Errno::ENETUNREACH,
+    Errno::EHOSTUNREACH,
+    Net::SSH::Disconnect,
+  ]
+
+  # Establish a connection session to the remote host.
+  #
+  # @return [Net::SSH::Connection::Session] the SSH connection session
+  # @api private
+  def establish_connection
+    @retries = options[:ssh_retries] || 2
+    begin
+      before_connect.changed_and_notify(self)
+      ssh = Net::SSH.start(hostname, username, options)
+    rescue *RESCUE_EXCEPTIONS => exception
+      handle_exception_retry(exception)
+      retry
+    end
+    after_connect.changed_and_notify(self)
+    ssh
+  end
+
+  def handle_exception_retry(exception)
+    if @retries > 0
+      on_connect_retry.changed_and_notify(self, exception, @retries)
+      sleep options[:ssh_timeout] || 1
+      @retries -= 1
+    else
+      on_connect_fail.changed_and_notify(self, exception)
+      # TODO: should we wrap the error in some other common class?
+      raise exception
+    end
+  end
+
+end

data/lib/remote_exec/version.rb

@@ -0,0 +1,5 @@
+# Unified handling of remote execution and file transfer
+module RemoteExec
+  # Version of this gem
+  VERSION = '0.5.0'
+end

data/test/remote_exec/fake_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'remote_exec/fake'
+
+describe RemoteExec::Fake do
+  subject do
+    RemoteExec::Fake.new
+  end
+
+  it "runs true" do
+    test_command = "true"
+    subject.story = [0,[]]
+    called = 0
+    status =
+    subject.execute(test_command) do |out, err|
+      called+=1
+    end
+    called.must_equal(0)
+    status.must_equal(0)
+  end
+
+  it "runs false" do
+    test_command = "false"
+    subject.story = [1,[]]
+    called = 0
+    status =
+    subject.execute(test_command) do |out, err|
+      called+=1
+    end
+    called.must_equal(0)
+    status.must_equal(1)
+  end
+
+  it "runs echo test" do
+    test_command = "echo test"
+    subject.story = [0,[["test\n",nil]]]
+    called = 0
+    status =
+    subject.execute(test_command) do |out, err|
+      out.must_equal "test\n"
+      err.must_be_nil
+      called+=1
+    end
+    called.must_equal(1)
+    status.must_equal(0)
+  end
+end

data/test/remote_exec/local_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'remote_exec/local'
+
+describe RemoteExec::Local do
+  subject do
+    RemoteExec::Local.new
+  end
+
+  it "runs true" do
+    subject.execute("true").must_equal(0)
+  end
+
+  it "runs false" do
+    subject.execute("false").must_equal(1)
+  end
+
+  it "runs echo test" do
+    test_command = "echo test"
+    @called = 0
+    status =
+    subject.execute(test_command) do |out, err|
+      assert_equal out.strip, "test"
+      assert_equal err, nil
+      @called+=1
+    end
+    @called.must_equal(1)
+    status.must_equal(0)
+  end
+end

data/test/remote_exec/ssh_test.rb

@@ -0,0 +1,271 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+
+Partially based on test-kitchen by Fletcher Nichol <fnichol@nichol.ca>
+License: https://github.com/test-kitchen/test-kitchen/blob/459238b88c/LICENSE
+=end
+
+require 'test_helper'
+require 'remote_exec/ssh'
+require 'net/ssh/test'
+
+module Net
+  module SSH
+    module Test
+      class Channel
+
+        def sends_request_pty
+          pty_data = ["xterm", 80, 24, 640, 480, "\0"]
+          script.events << Class.new(Net::SSH::Test::LocalPacket) do
+            def types
+              if
+                @type == 98 && @data[1] == "pty-req"
+              then
+                @types ||= [
+                  :long, :string, :bool, :string,
+                  :long, :long, :long, :long, :string
+                ]
+              else
+                super
+              end
+            end
+          end.new(:channel_request, remote_id, "pty-req", false, *pty_data)
+        end
+
+      end
+    end
+  end
+end
+
+class ErrorCounter
+  attr_reader :errors
+  def on_error(method, *args)
+    @errors ||= {}
+    @errors[method] ||= 0
+    @errors[method] += 1
+  end
+  def on_connect_retry(*args)
+    on_error(:on_connect_retry, *args)
+  end
+  def on_connect_fail(*args)
+    on_error(:on_connect_fail, *args)
+  end
+end
+
+class ExecutaDataHook < Struct.new(:object, :stdout, :stderr)
+  attr_reader :results
+  def initialize(*args)
+    @results = []
+    super
+  end
+  def update(*args)
+    @results << self.class.new(*args)
+  end
+end
+
+describe RemoteExec::Ssh do
+  include Net::SSH::Test
+
+  subject do
+    RemoteExec::Ssh.allocate.tap do |ssh|
+      ssh.instance_variable_set(:@ssh, connection)
+      ssh.instance_variable_set(:@options, {})
+    end
+  end
+
+  describe "#initialize" do
+
+    it "sets default variables" do
+      subject.send(:initialize, 1, 2, 3)
+      subject.hostname.must_equal 1
+      subject.username.must_equal 2
+      subject.options.must_equal 3
+    end
+
+    it "executes initialize block once" do
+      calls = 0
+      subject.send(:initialize, 1, 2, 3) { calls+=1 }
+      calls.must_equal 1
+    end
+
+  end #initialize
+
+  describe "#execute" do
+    let(:hook) { ExecutaDataHook.new }
+
+    it "executes true" do
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_request_pty
+        channel.sends_exec "true"
+        channel.gets_exit_status(0)
+        channel.gets_close
+        channel.sends_close
+      end
+
+      assert_scripted do
+        subject.execute("true").must_equal 0
+      end
+    end
+
+    it "executes false" do
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_request_pty
+        channel.sends_exec "false"
+        channel.gets_exit_status(1)
+        channel.gets_close
+        channel.sends_close
+      end
+
+      assert_scripted do
+        subject.execute("false").must_equal 1
+      end
+    end
+
+    it "executes echo test" do
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_request_pty
+        channel.sends_exec "echo test me"
+        channel.gets_data("test me\n")
+        channel.gets_exit_status(0)
+        channel.gets_close
+        channel.sends_close
+      end
+
+      assert_scripted do
+        subject.on_execute_data.add_observer(hook, :update)
+        subject.execute("echo test me") do |out, err|
+          out.must_equal "test me\n"
+          err.must_be_nil
+        end.must_equal 0
+        hook.results.must_equal([ExecutaDataHook.new(subject, "test me\n", nil)])
+      end
+    end
+
+    it "executes echo test>&2" do
+      story do |session|
+        channel = session.opens_channel
+        channel.sends_request_pty
+        channel.sends_exec "echo test me>&2"
+        channel.gets_extended_data("test me\n")
+        channel.gets_exit_status(0)
+        channel.gets_close
+        channel.sends_close
+      end
+
+      assert_scripted do
+        subject.on_execute_data.add_observer(hook, :update)
+        subject.execute("echo test me>&2") do |out, err|
+          out.must_be_nil
+          err.must_equal "test me\n"
+        end.must_equal 0
+        hook.results.must_equal([ExecutaDataHook.new(subject, nil, "test me\n")])
+      end
+    end
+
+  end #execute
+
+  describe "#execute methods" do
+    let(:hook) { ExecutaDataHook.new }
+
+    it "handles stdout" do
+      subject.on_execute_data.add_observer(hook, :update)
+      subject.send(:execute_on_stdout, :channel, "some text") do |stdout, stderr|
+        stdout.must_equal("some text")
+        stderr.must_be_nil
+      end
+      hook.results.must_equal([ExecutaDataHook.new(subject, "some text", nil)])
+    end
+
+    it "handles stderr" do
+      subject.on_execute_data.add_observer(hook, :update)
+      subject.send(:execute_on_stderr, :channel, 1, "some text") do |stdout, stderr|
+        stdout.must_be_nil
+        stderr.must_equal("some text")
+      end
+      hook.results.must_equal([ExecutaDataHook.new(subject, nil, "some text")])
+    end
+
+    it "does not handle extended data other then stderr" do
+      subject.on_execute_data.add_observer(hook, :update)
+      lambda {
+        subject.send(:execute_on_stderr, :channel, 666, "some text")
+      }.must_raise(RuntimeError, "Unsupported SSH extended_data type: 666")
+      hook.results.must_be_empty
+    end
+
+  end #execute methods
+
+  describe "#establish_connection" do
+    it "does connect" do
+      Net::SSH.unstub(:start)
+      Net::SSH.stubs(:start).returns(connection)
+      subject.send(:establish_connection).must_equal(connection)
+    end
+  end
+
+  describe "exception in establishing connection" do
+
+    [
+      Errno::EACCES, Errno::EADDRINUSE, Errno::ECONNREFUSED,
+      Errno::ECONNRESET, Errno::ENETUNREACH, Errno::EHOSTUNREACH,
+      Net::SSH::Disconnect
+    ].each do |klass|
+      describe "raising #{klass}" do
+
+        before do
+          @error_counter = ErrorCounter.new
+          Net::SSH.unstub(:start)
+          Net::SSH.stubs(:start).raises(klass)
+          subject.instance_variable_set(:@ssh, nil)
+          subject.options[:ssh_retries] = 2
+        end
+
+        it "reraises the #{klass} exception" do
+          subject.stubs(:sleep)
+          proc { subject.send(:establish_connection) }.must_raise klass
+        end
+
+        it "sleeps for 1 second between retries" do
+          subject.expects(:sleep).with(1).twice
+          begin
+            subject.send(:establish_connection)
+          rescue
+          end
+        end
+
+        it "calls hooks on retry/fail ':ssh_retries' times" do
+          subject.stubs(:sleep)
+          subject.on_connect_retry.add_observer(@error_counter, :on_connect_retry)
+          subject.on_connect_fail.add_observer(@error_counter, :on_connect_fail)
+          begin
+            subject.send(:establish_connection)
+          rescue
+          end
+          @error_counter.errors.must_equal({:on_connect_retry=>2, :on_connect_fail=>1})
+        end
+
+      end
+    end
+
+  end #"exception in establishing connection"
+
+  describe "#handle_exception_retry" do
+    it "does decrease reties count" do
+      subject.instance_variable_set(:@retries, 2)
+      subject.send(:handle_exception_retry, "exception_test")
+      subject.instance_variable_get(:@retries).must_equal(1)
+      subject.send(:handle_exception_retry, "exception_test")
+      subject.instance_variable_get(:@retries).must_equal(0)
+      lambda {
+        subject.send(:handle_exception_retry, "exception_test")
+      }.must_raise(RuntimeError, "exception_test")
+      subject.instance_variable_get(:@retries).must_equal(0)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "rubygems"
+gem "minitest"
+
+if
+  RUBY_VERSION == "2.0.0" && # check Gemfile
+  $0 != "-e" # do not do that in guard
+then
+  require "coveralls"
+  require "simplecov"
+
+  SimpleCov.start do
+    formatter SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter,
+    ]
+    command_name "Unit Tests"
+    add_filter "/test/"
+  end
+
+  Coveralls.noisy = true unless ENV["CI"]
+end
+
+# Autoload all lib/**/*.rb files so simplecov does not misses anything
+Dir[File.expand_path("../../lib/**/*.rb", __FILE__)].each{|f| require f }
+
+require "minitest/autorun" unless $0=="-e" # skip in guard
+require "minitest/unit"
+require "mocha/setup"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: remote-exec
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Michal Papis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-04 00:00:00.000000000 Z
+date: 2014-10-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: session
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-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: guard-yard
+  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: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +94,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Invoke commands on remote hosts
 email:
 - mpapis@gmail.com
@@ -59,10 +129,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/remote/exec/fake.rb
-- lib/remote/exec/local.rb
-- lib/remote/exec/ssh.rb
-- lib/remote/exec/version.rb
+- lib/remote-exec.rb
+- lib/remote_exec/base.rb
+- lib/remote_exec/fake.rb
+- lib/remote_exec/local.rb
+- lib/remote_exec/ssh.rb
+- lib/remote_exec/version.rb
+- test/remote_exec/fake_test.rb
+- test/remote_exec/local_test.rb
+- test/remote_exec/ssh_test.rb
+- test/test_helper.rb
 homepage: https://github.com/remote-exec/remote-exec
 licenses:
 - MIT
@@ -83,9 +159,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Invoke commands on remote hosts
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/remote_exec/local_test.rb
+- test/remote_exec/ssh_test.rb
+- test/remote_exec/fake_test.rb
 has_rdoc: 

data/lib/remote/exec/fake.rb

@@ -1,15 +0,0 @@
-class Remote::Exec::Fake
-  attr_reader :last_status
-
-  def execute(command)
-    @last_status, outputs = @respond.call(command)
-    outputs.each do |out, err|
-      yield(out, err)
-    end
-    @last_status
-  end
-
-  def respond(&block)
-    @respond = block
-  end
-end

data/lib/remote/exec/local.rb

@@ -1,21 +0,0 @@
-require 'session'
-
-class Remote::Exec::Local
-  attr_reader :shell, :last_status
-
-  def initialize(shell = "sh")
-    @shell = shell
-  end
-
-  def execute(command)
-    @last_status = nil
-    shell_session.execute(command) do |out, err|
-      yield(out, err)
-    end
-    @last_status = shell_session.status
-  end
-
-  def shell_session
-    @shell_session ||= Session::Sh.new(:prog => shell)
-  end
-end

data/lib/remote/exec/ssh.rb

@@ -1,36 +0,0 @@
-require 'net/ssh'
-
-class Remote::Exec::Ssh
-  attr_reader :host, :user, :last_status
-
-  def initialize(host, user = nil)
-    @host = host
-    @user = user
-  end
-
-  # TODO: make it run in one session
-  def execute(command)
-    @last_status = nil
-    ssh.open_channel do |channel|
-      channel.request_pty
-      channel.exec command do |ch, success|
-        channel.on_data do |ch, data|
-          yield(data, nil)
-        end
-        channel.on_extended_data do |ch, type, data|
-          yield(nil, data)
-        end
-        channel.on_request("exit-status") do |ch, data|
-          @last_status = data.read_long
-        end
-      end
-      channel.wait
-    end
-    ssh.loop
-    @last_status
-  end
-
-  def ssh
-    @ssh ||= Net::SSH.start(host, user)
-  end
-end

data/lib/remote/exec/version.rb

@@ -1,6 +0,0 @@
-module Remote
-  class Exec
-    VERSION = '0.0.1'
-  end
-end
-