net-ssh-session 0.1.0

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+*.swp
+*.tmproj
+*~
+.DS_Store
+.\#*
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+\#*
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tmtags

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=nested

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Dan Sosedoff.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# Net::SSH::Session
+
+A wrapper on top of `Net::SSH` and `Net::SSH::Shell` to provide a set of tools for ssh sessions
+
+## Install
+
+Install with rubygems:
+
+```
+gem install net-ssh-session
+```
+
+Install with bundler:
+
+```
+gem 'net-ssh-session', :github => 'sosedoff/net-ssh-session'
+```
+
+## Usage
+
+Basic usage:
+
+```ruby
+require 'net/ssh/session'
+
+# Establish a connection
+session = Net::SSH::Session.new(host, user, password)
+session.open
+
+# If you want to set a connection timeout in seconds
+# it will raise Timeout::Error 
+session.open(10)
+
+# Execute a remote command
+result = session.run("free -m")
+
+# Net::SSH::SessionCommand helpers
+result.success?  # => true
+result.failure?  # => false
+result.exit_code # => 0
+result.output    # => command output text
+result.duration  # => execution time, seconds
+
+# Capture command output
+session.capture('cat /etc/lsb-release')
+
+# File helpers
+session.file_exists?('/path')
+session.directory_exists?('/path')
+session.read_file('/path')
+
+# Process helpers
+session.process_exists?(PID)
+session.kill_process(PID) # => true
+session.kill_process(PID, 'SIGINT') # => false
+session.last_exit_code # => 1
+
+# Environment helpers
+session.env('RAILS_ENV') # => production
+session.export('RAILS_ENV', 'production')
+session.export_hash(
+  'RAILS_ENV' => 'test',
+  'RACK_ENV'  => 'test'
+)
+
+# Execute a batch of commands
+session.run_multiple(
+  'git clone git@foobar.com:project.git',
+  'cd project',
+  'bundle install',
+  'rake test'
+)
+
+# Execute with time limit (10s)
+begin
+  session.with_timeout(10) do
+    session.run('some long job')
+  end
+rescue Timeout::Error
+  puts "Operation took too long :("
+end
+
+# Execute a long command and show ongoing process
+session.run("rake test") do |str|
+  puts str
+end
+
+# Get history, returns an array with Net::SSH::SessionCommand objects
+session.history.each do |cmd|
+  puts cmd.to_s # => I, [2012-11-08T00:10:48.229986 #51878]  INFO -- : [bundle install --path .bundle] => 10, 35 bytes
+  if cmd.success?
+    # do your thing
+  end
+end
+
+# Close current session
+session.close
+```
+
+## Advanced Usage
+
+### Running multiple commands
+
+By default multiple command execution will not break if one of the commands fails. If you want to break the chain on the first failure, supply `:break => true` option:
+
+```ruby
+session.run_multiple(commands, :break => true)
+```
+
+To get each command result after execution, you can supply a block:
+
+```ruby
+session.run_multiple(commands) do |cmd|
+  puts "Original command: #{cmd.command}"
+  puts "Exit code: #{cmd.exit_code}"
+  puts "Output: #{cmd.output}"
+end
+```
+
+### Using session logger
+
+If you want to log command execution for the whole session you can assign a logger:
+
+```ruby
+require 'logger'
+require 'net/ssh/session'
+
+s = Net::SSH::Session.new(host, user, password)
+s.logger = Logger.new(STDOUT)
+s.open
+
+s.run("cd /tmp")
+s.run("git clone git://github.com/sosedoff/net-ssh-session.git")
+s.run("bundle install --path .bundle")
+
+s.close
+```
+
+Since the logger is set to write to `STDOUT` you'll see something like this:
+
+```
+I, [2012-11-08T00:10:47.605916 #51878]  INFO -- : [cd /tmp] => 0, 0 bytes
+I, [2012-11-08T00:10:48.038294 #51878]  INFO -- : [git clone git://github.com/sosedoff/net-ssh-session.git] => 0, 7795 bytes
+I, [2012-11-08T00:10:48.229986 #51878]  INFO -- : [bundle install --path .bundle] => 10, 35 bytes
+```
+
+### Execution history
+
+By default each session command (`Net::SSH::SessionCommand`) will be recorded in 
+session history. Example how to skip history tracking:
+
+```ruby
+require 'net/ssh/session'
+
+s = Net::SSH::Session.new(host, user, password)
+s.open
+
+# Run commands with no history
+s.run("export RAILS_ENV=test", :history => false)
+r.run("mysqlcheck --repair mysql proc -u root", :history => false)
+
+# Rest will be recorded
+s.run("git clone git://github.com/sosedoff/net-ssh-session.git")
+s.run("bundler install --path .")
+
+s.close
+```
+
+## Credits
+
+Library code was extracted and modified from multiple sources:
+
+- Dan Sosedoff (@sosedoff)
+- Mitchell Hashimoto (@mitchellh)
+- Michael Klishin (@michaelklishin)
+- Sven Fuchs (@svenfuchs)
+- Travis-CI (@travis-ci)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/net-ssh-session/version.rb

@@ -0,0 +1,7 @@
+module Net
+  module SSH
+    class Session
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/net/ssh/session.rb

@@ -0,0 +1,125 @@
+require 'open3'
+require 'net/ssh'
+require 'net/ssh/shell'
+require 'net/ssh/session_helpers'
+require 'net/ssh/session_command'
+
+module Net
+  module SSH
+    class Session
+      include Net::SSH::SessionHelpers
+
+      attr_reader :host, :user, :password
+      attr_reader :connection, :shell
+      attr_reader :options
+      attr_reader :logger
+      attr_reader :history
+
+      # Initialize a new ssh session
+      # @param host [String] remote hostname or ip address
+      # @param user [String] remote account username
+      # @param password [String] remote account password
+      def initialize(host, user, password='')
+        @host     = host
+        @user     = user
+        @password = password
+        @history  = []
+      end
+
+      # Establish connection with remote server
+      # @param timeout [Integer] max timeout in seconds
+      # @return [Boolean]
+      def open(timeout=nil)
+        if timeout && timeout > 0
+          with_timeout(timeout) { establish_connection }
+        else
+          establish_connection
+        end
+      end
+
+      # Close connection with remote server
+      # @return [Boolean]
+      def close
+        shell.close!
+      end
+
+      def on_output(&block)
+        @on_output = block
+      end
+
+      # Execute command
+      # @param command [String] command to execute
+      # @param on_output [Block] output event block
+      # @return [Integer] command execution exit code
+      def exec(command, &on_output)
+        status = nil
+        shell.execute(command) do |process|
+          process.on_output(&on_output)
+          process.on_error_output(&on_output)
+          process.on_finish { |p| status = p.exit_status }
+        end
+        shell.session.loop(1) { status.nil? }
+        status
+      end
+
+      # Execute a single command
+      # @param command [String] comand to execute
+      # @param options [Hash] execution options
+      # @return [SessionCommand]
+      def run(command, options={})
+        output  = ''
+        t_start = Time.now
+
+        exit_code = exec(command) do |process, data|
+          output << data
+          yield data if block_given?
+        end
+
+        t_end = Time.now
+
+        cmd = SessionCommand.new(
+          command, output, exit_code, 
+          t_end - t_start
+        )
+
+        history << cmd unless options[:history] == false
+        logger.info(cmd.to_s) if logger
+
+        cmd
+      end
+
+      # Execute multiple commands
+      # @param commands [Array] set of commands to execute
+      # @param options [Hash] execution options
+      # @return [Array] set of command execution results
+      # 
+      # Execution options are the following:
+      # options[:break] - If set to `true`, execution chain will break on first failed command
+      #
+      def run_multiple(commands=[], options={})
+        results = []
+
+        [commands].flatten.compact.each do |cmd|
+          result = run(cmd)
+          yield(result) if block_given?
+          results << result
+          break if results.last.failure? && options[:break] == true
+        end
+
+        results
+      end
+
+      # Set a global session logger for commands
+      def logger=(log)
+        @logger = log
+      end
+
+      private
+
+      def establish_connection
+        @connection = Net::SSH.start(host, user, :password => password)
+        @shell = @connection.shell
+      end
+    end
+  end
+end

data/lib/net/ssh/session_command.rb

@@ -0,0 +1,39 @@
+module Net
+  module SSH
+    class SessionCommand
+      attr_reader   :command, :output, :exit_code
+      attr_reader   :duration
+      attr_accessor :start_time, :finish_time
+      
+      # Initialize a new session command
+      # @param command [String] original command
+      # @param output [String] command execution output
+      # @param exit_code [Integer] command execution exit code
+      # @param duration [Float] execution time in seconds
+      def initialize(command, output, exit_code, duration=0)
+        @command   = command
+        @output    = output || ''
+        @exit_code = Integer(exit_code) rescue 1
+        @duration  = Float(duration)
+      end
+
+      # Check if exit code is successful
+      # @return [Boolean]
+      def success?
+        exit_code == 0
+      end
+
+      # Check if exit code is not successful
+      # @return [Boolean]
+      def failure?
+        exit_code != 0
+      end
+
+      # Get command string representation
+      # @return [String]
+      def to_s
+        "[#{command}] => #{exit_code}, #{output.to_s.bytesize} bytes, #{duration} seconds"
+      end
+    end
+  end
+end

data/lib/net/ssh/session_helpers.rb

@@ -0,0 +1,104 @@
+require 'timeout'
+
+module Net
+  module SSH
+    module SessionHelpers
+      # Swith current directory
+      # @param path [String] directory path
+      # @return [Boolean] execution result
+      def chdir(path)
+        run("cd #{path}").success?
+      end
+
+      # Get current directory
+      # @return [String]
+      def pwd
+        capture("pwd")
+      end
+
+      # Execute command and capture any output
+      # @param command [String] command to execute
+      # @return [String] execution result
+      def capture(command)
+        run(command).output.strip
+      end
+
+      # Read remote file contents
+      # @path [String] file path
+      # @return [String] file contents
+      def read_file(path)
+        result = run("cat #{path}")
+        result.success? ? result.output : ''
+      end
+
+      # Check if remote directory exists
+      # @param path [String] directory path
+      # @return [Boolean] execution result
+      def directory_exists?(path)
+        run("test -d #{path}").success?
+      end
+
+      # Check if remote file exists
+      # @param path [String] file path
+      # @return [Boolean] execution result
+      def file_exists?(path)
+        run("test -f #{path}").success?
+      end
+
+      # Check if process with PID is running
+      # @param pid [String] process id
+      # @return [Boolean] execution result
+      def process_exists?(pid)
+        run("ps -p #{pid}").success?
+      end
+
+      # Kill a process with the signal
+      # @param pid [String] process id
+      # @param signal [String] signal to send
+      # @return [Boolean] exection result
+      def kill_process(pid, signal='SIGTERM')
+        run("kill -#{signal} #{pid}")
+        process_exists?(pid)
+      end
+
+      # Export an environment variable
+      # @param key [String] variable name
+      # @param value [String] variable value
+      # @return [Boolean] execution result
+      def export(key, value)
+        run("export #{key}=#{value}").success?
+      end
+
+      # Export environment vars from hash
+      # @param data [Hash]
+      # @return [Boolean] execution result
+      def export_hash(data={})
+        data.each_pair do |k, v|
+          export(k, v)
+        end
+      end
+
+      # Get an environment variable
+      # @param key [String] variable name
+      # @return [String] variable value
+      def env(key)
+        capture("echo $#{key}")
+      end
+
+      # Get last executed command exit code
+      # @return [Integer] exit code
+      def last_exit_code
+        Integer(capture("echo $?"))
+      end
+
+      # Set a timeout context for execution
+      # @param time [Integer] max time for execution in seconds
+      # @param block [Block] block to execute
+      def with_timeout(time, &block)
+        Timeout.timeout(time) do
+          block.call(self)
+        end
+      end
+    end
+  end
+end

data/lib/net/ssh/shell.rb

@@ -0,0 +1,190 @@
+require 'digest/sha1'
+require 'net/ssh'
+require 'net/ssh/shell/process'
+require 'net/ssh/shell/subshell'
+
+module Net
+  module SSH
+    class Shell
+      attr_reader :session
+      attr_reader :channel
+      attr_reader :state
+      attr_reader :shell
+      attr_reader :processes
+      attr_accessor :default_process_class
+
+      def initialize(session, shell=:default)
+        @session = session
+        @shell = shell
+        @state = :closed
+        @processes = []
+        @when_open = []
+        @on_process_run = nil
+        @default_process_class = Net::SSH::Shell::Process
+        open
+      end
+
+      def open(&callback)
+        if closed?
+          @state = :opening
+          @channel = session.open_channel(&method(:open_succeeded))
+          @channel.on_open_failed(&method(:open_failed))
+          @channel.on_request('exit-status', &method(:on_exit_status))
+        end
+        when_open(&callback) if callback
+        self
+      end
+
+      def open!
+        if !open?
+          open if closed?
+          session.loop { opening? }
+        end
+        self
+      end
+
+      def when_open(&callback)
+        if open?
+          yield self
+        else
+          @when_open << callback
+        end
+        self
+      end
+
+      def open?
+        state == :open
+      end
+
+      def closed?
+        state == :closed
+      end
+
+      def opening?
+        !open? && !closed?
+      end
+
+      def on_process_run(&callback)
+        @on_process_run = callback
+      end
+
+      def execute(command, *args, &callback)
+        # The class is an optional second argument.
+        klass = default_process_class
+        klass = args.shift if args.first.is_a?(Class)
+
+        # The properties are expected to be the next argument.
+        props = {}
+        props = args.shift if args.first.is_a?(Hash)
+
+        process = klass.new(self, command, props, callback)
+        processes << process
+        run_next_process if processes.length == 1
+        process
+      end
+
+      def subshell(command, &callback)
+        execute(command, Net::SSH::Shell::Subshell, &callback)
+      end
+
+      def execute!(command, &callback)
+        process = execute(command, &callback)
+        wait!
+        process
+      end
+
+      def busy?
+        opening? || processes.any?
+      end
+
+      def wait!
+        session.loop { busy? }
+      end
+
+      def close!
+        channel.close if channel
+      end
+
+      def child_finished(child)
+        channel.on_close(&method(:on_channel_close)) if !channel.nil?
+        processes.delete(child)
+        run_next_process
+      end
+
+      def separator
+        @separator ||= begin
+          s = Digest::SHA1.hexdigest([session.object_id, object_id, Time.now.to_i, Time.now.usec, rand(0xFFFFFFFF)].join(":"))
+          s << Digest::SHA1.hexdigest(s)
+        end
+      end
+
+      def on_channel_close(channel)
+        @state = :closed
+        @channel = nil
+      end
+
+      private
+
+      def run_next_process
+        if processes.any?
+          process = processes.first
+          @on_process_run.call(self, process) if @on_process_run
+          process.run
+        end
+      end
+
+      def open_succeeded(channel)
+        @state = :pty
+        channel.on_close(&method(:on_channel_close))
+        channel.request_pty(:modes => { Net::SSH::Connection::Term::ECHO => 0 }, &method(:pty_requested))
+      end
+
+      def open_failed(channel, code, description)
+        @state = :closed
+        raise "could not open channel for process manager (#{description}, ##{code})"
+      end
+
+      def on_exit_status(channel, data)
+        unless data.read_long == 0
+          raise "the shell exited unexpectedly"
+        end
+      end
+
+      def pty_requested(channel, success)
+        @state = :shell
+        raise "could not request pty for process manager" unless success
+        if shell == :default
+          channel.send_channel_request("shell", &method(:shell_requested))
+        else
+          channel.exec(shell, &method(:shell_requested))
+        end
+      end
+
+      def shell_requested(channel, success)
+        @state = :initializing
+        raise "could not request shell for process manager" unless success
+        channel.on_data(&method(:look_for_initialization_done))
+        channel.send_data "export PS1=; echo #{separator} $?\n"
+      end
+
+      def look_for_initialization_done(channel, data)
+        if data.include?(separator)
+          @state = :open
+          @when_open.each { |callback| callback.call(self) }
+          @when_open.clear
+        end
+      end
+    end
+  end
+end
+
+class Net::SSH::Connection::Session
+  # Provides a convenient way to initialize a shell given a Net::SSH
+  # session. Yields the new shell if a block is given. Returns the shell
+  # instance.
+  def shell(*args)
+    shell = Net::SSH::Shell.new(self, *args)
+    yield shell if block_given?
+    shell
+  end
+end

data/lib/net/ssh/shell/process.rb

@@ -0,0 +1,120 @@
+module Net; module SSH; class Shell
+  class Process
+    attr_reader :state
+    attr_reader :command
+    attr_reader :manager
+    attr_reader :callback
+    attr_reader :exit_status
+    attr_reader :properties
+
+    def initialize(manager, command, properties, callback)
+      @command = command
+      @manager = manager
+      @callback = callback
+      @properties = properties
+      @on_output = nil
+      @on_error_output = nil
+      @on_finish = nil
+      @state = :new
+    end
+
+    def [](key)
+      @properties[key]
+    end
+
+    def []=(key, value)
+      @properties[key] = value
+    end
+
+    def send_data(data)
+      manager.channel.send_data(data)
+    end
+
+    def run
+      if state == :new
+        state = :starting
+        manager.open do
+          state = :running
+          manager.channel.on_data(&method(:on_stdout))
+          manager.channel.on_extended_data(&method(:on_stderr))
+          manager.channel.on_close(&method(:on_close))
+
+          callback.call(self) if callback
+
+          cmd = command.dup
+          cmd << ";" if cmd !~ /[;&]$/
+          cmd << " DONTEVERUSETHIS=$?; echo #{manager.separator} $DONTEVERUSETHIS; echo \"exit $DONTEVERUSETHIS\"|sh"
+
+          send_data(cmd + "\n")
+        end
+      end
+
+      self
+    end
+
+    def starting?
+      state == :starting
+    end
+
+    def running?
+      state == :running
+    end
+
+    def finished?
+      state == :finished
+    end
+
+    def busy?
+      starting? || running?
+    end
+
+    def wait!
+      manager.session.loop { busy? }
+      self
+    end
+
+    def on_output(&callback)
+      @on_output = callback
+    end
+
+    def on_error_output(&callback)
+      @on_error_output = callback
+    end
+
+    def on_finish(&callback)
+      @on_finish = callback
+    end
+
+    protected
+
+    def output!(data)
+      @on_output.call(self, data) if @on_output
+    end
+
+    def on_stdout(ch, data)
+      if data.strip =~ /#{manager.separator} (\d+)$/
+        before = $`
+        output!(before) unless before.empty?
+        finished!($1)
+      else
+        output!(data)
+      end
+    end
+
+    def on_stderr(ch, type, data)
+      @on_error_output.call(self, data) if @on_error_output
+    end
+
+    def on_close(ch)
+      manager.on_channel_close(ch)
+      finished!(-1)
+    end
+
+    def finished!(status)
+      @state = :finished
+      @exit_status = status.to_i
+      @on_finish.call(self) if @on_finish
+      manager.child_finished(self)
+    end
+  end
+end; end; end

data/lib/net/ssh/shell/subshell.rb

@@ -0,0 +1,21 @@
+require 'net/ssh/shell/process'
+
+module Net; module SSH; class Shell
+  class Subshell < Process
+    protected
+
+    def on_stdout(ch, data)
+      if !output!(data)
+        ch.on_data(&method(:look_for_finalize_initializer))
+        ch.send_data("export PS1=; echo #{manager.separator} $?\n")
+      end
+    end
+
+    def look_for_finalize_initializer(ch, data)
+      if data =~ /#{manager.separator} (\d+)/
+        ch.on_close(&@master_onclose)
+        finished!($1)
+      end
+    end
+  end
+end; end; end

data/lib/net/ssh/shell/version.rb

@@ -0,0 +1,7 @@
+module Net
+  module SSH
+    class Shell
+      VERSION = "0.3.0.dev"
+    end
+  end
+end

data/net-ssh-session.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path('../lib/net-ssh-session/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "net-ssh-session"
+  s.version     = Net::SSH::Session::VERSION
+  s.summary     = "Shell session for Net::SSH connections"
+  s.description = "Shell interface with helper methods to work with Net::SSH connections"
+  s.homepage    = "https://github.com/sosedoff/net-ssh-session"
+  s.authors     = ["Dan Sosedoff"]
+  s.email       = ["dan.sosedoff@gmail.com"]
+  
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec',     '~> 2.11'
+  s.add_development_dependency 'simplecov', '~> 0.4'
+
+  s.add_dependency 'net-ssh', '~> 2.6'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.require_paths = ["lib"]
+end

data/spec/session_command_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Net::SSH::SessionCommand do
+  describe '#initialize' do
+    it 'assigns attributes' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '128', 1.5)
+
+      cmd.command.should be_a String
+      cmd.output.should be_a String
+      cmd.exit_code.should be_a Fixnum
+      cmd.duration.should be_a Float
+    end
+
+    it 'sets exit code to 1 on invalid value' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', 'ohai')
+      cmd.exit_code.should eq(1)
+    end
+  end
+
+  describe '#success?' do
+    it 'returns true for successful exit codes' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '0')
+      cmd.success?.should be_true
+    end
+
+    it 'returns false for failed exit codes' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '1')
+      cmd.success?.should be_false
+
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '128')
+      cmd.success?.should be_false
+    end
+  end
+
+  describe '#failure?' do
+    it 'returns true for non-zero exit codes' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '1')
+      cmd.failure?.should be_true
+
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '128')
+      cmd.failure?.should be_true
+    end
+
+    it 'returns false for successful exit codes' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '0')
+      cmd.failure?.should be_false
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns command string representation' do
+      cmd = Net::SSH::SessionCommand.new('cmd', 'output', '0', 1.234)
+      cmd.to_s.should eq("[cmd] => 0, 6 bytes, 1.234 seconds")
+    end
+  end
+end

data/spec/session_helpers_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Net::SSH::SessionHelpers do
+  let(:session) do
+    class Session
+      include Net::SSH::SessionHelpers
+    end
+    Session.new
+  end
+
+  describe '#chdir' do
+    before do
+      session.stub(:run).with("cd /tmp").
+        and_return(fake_run("cd /tmp", "", 0))
+
+      session.stub(:run).with("cd /foo/bar").
+        and_return(fake_run("cd /foo/bar", "-bash: cd: /foo/bar: No such file or directory\r\n", 1))
+    end
+
+    it 'returns true if directory was changed' do
+      session.chdir("/tmp").should eq(true)
+    end
+
+    it 'returns false if unable to change directory' do
+      session.chdir("/foo/bar").should eq(false)
+    end
+  end
+
+  describe '#pwd' do
+    before do
+      session.stub(:run).with("pwd").and_return(fake_run("pwd", "/tmp\r\n", 0))
+    end
+
+    it 'returns current work directory' do
+      session.pwd.should eq("/tmp")
+    end
+  end
+
+  describe '#capture' do
+    before do
+      session.stub(:run).with("uname").and_return(fake_run("uname", "Linux\r\n"))
+      session.stub(:run).with("ls").and_return(fake_run("ls", "\r\n", 1))
+      session.stub(:run).with("date").and_return(fake_run("date", nil, 1))
+    end
+
+    it 'returns command output' do
+      session.capture("uname").should eq("Linux")
+      session.capture("ls").should eq("")
+      session.capture("date").should eq("")
+    end
+  end
+
+  describe '#read_file' do
+    before do
+      session.stub(:run).with('cat /tmp/file').
+        and_return(fake_run('cat /tmp/file', "Hello\n\n", 0))
+
+      session.stub(:run).with('cat /foo').
+        and_return(fake_run('cat /foo', nil, 1))
+    end
+
+    it 'returns file contents as is' do
+      session.read_file("/tmp/file").should eq("Hello\n\n")
+    end
+
+    it 'returns empty string if files does not exist' do
+      session.read_file("/foo").should eq("")
+    end
+  end
+
+  describe '#directory_exists?' do
+    before do
+      session.stub(:run).with('test -d /tmp').and_return(fake_run('test -d /tmp', nil, 0))
+      session.stub(:run).with('test -d /foo').and_return(fake_run('test -d /foo', nil, 1))
+    end
+
+    it 'returns true if directory exists' do
+      session.directory_exists?('/tmp').should be_true
+    end
+
+    it 'returns false if directory does not exist' do
+      session.directory_exists?('/foo').should be_false
+    end
+  end
+
+  describe '#file_exists?' do
+    before do
+      session.stub(:run).with('test -f /f1').and_return(fake_run('test -f /f1', nil, 0))
+      session.stub(:run).with('test -f /f2').and_return(fake_run('test -f /f2', nil, 1))
+    end
+
+    it 'returns true if file exists' do
+      session.file_exists?('/f1').should be_true
+    end
+
+    it 'returns false if file does not exist' do
+      session.file_exists?('/f2').should be_false
+    end
+  end
+
+  describe '#process_exists?' do
+    before do
+      session.stub(:run).with('ps -p 123').and_return(fake_run('ps -p 123', nil, 0))
+      session.stub(:run).with('ps -p 345').and_return(fake_run('ps -p 345', nil, 1))
+    end
+
+    it 'returns true if process exists' do
+      session.process_exists?(123).should be_true
+    end
+
+    it 'returns true if process does not exist' do
+      session.process_exists?(345).should be_false
+    end
+  end
+
+  describe '#kill_process' do
+    before do
+      session.stub(:run).with('kill -SIGTERM 123').and_return(fake_run('kill -SIGTERM 123', nil, 0))
+      session.stub(:run).with('ps -p 123').and_return(fake_run('ps -p 123', nil, 0))
+
+      session.stub(:run).with('kill -SIGTERM 345').and_return(fake_run('kill -SIGTERM 345', nil, 0))
+      session.stub(:run).with('ps -p 345').and_return(fake_run('ps -p 345', nil, 1))
+    end
+
+    it 'returns true if process was killed and does not exist' do
+      session.kill_process(123).should be_true
+    end
+
+    it 'returns false if process is still alive' do
+      session.kill_process(345).should be_false
+    end
+  end
+
+  describe '#with_timeout' do
+    let(:worker) do
+      proc { sleep 1 }
+    end
+
+    it 'raises timeout error if exceded' do
+      expect { session.with_timeout(0.5, &worker) }.to raise_error Timeout::Error
+    end
+
+    it 'runs normally' do
+      expect { session.with_timeout(2, &worker) }.not_to raise_error Timeout::Error
+    end
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Net::SSH::Session do
+  # TODO
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$:.unshift File.expand_path("../..", __FILE__)
+
+require 'net/ssh/session'
+
+def fixture_path(filename=nil)
+  path = File.expand_path("../fixtures", __FILE__)
+  filename.nil? ? path : File.join(path, filename)
+end
+
+def fixture(file)
+  File.read(File.join(fixture_path, file))
+end
+
+def fake_run(command, output, exit_code=0, duration=0)
+  Net::SSH::SessionCommand.new(command, output, exit_code, duration)
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: net-ssh-session
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dan Sosedoff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.11"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.6"
+  type: :runtime
+  version_requirements: *id004
+description: Shell interface with helper methods to work with Net::SSH connections
+email: 
+- dan.sosedoff@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/net-ssh-session/version.rb
+- lib/net/ssh/session.rb
+- lib/net/ssh/session_command.rb
+- lib/net/ssh/session_helpers.rb
+- lib/net/ssh/shell.rb
+- lib/net/ssh/shell/process.rb
+- lib/net/ssh/shell/subshell.rb
+- lib/net/ssh/shell/version.rb
+- net-ssh-session.gemspec
+- spec/fixtures/.gitkeep
+- spec/session_command_spec.rb
+- spec/session_helpers_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sosedoff/net-ssh-session
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Shell session for Net::SSH connections
+test_files: 
+- spec/fixtures/.gitkeep
+- spec/session_command_spec.rb
+- spec/session_helpers_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+has_rdoc: