sshkit 0.0.1

data/lib/sshkit/configuration.rb

@@ -0,0 +1,29 @@
+module SSHKit
+
+  class Configuration
+
+    attr_writer :command_map
+    attr_accessor :output, :format, :runner, :backend
+
+    def initialize
+      @output  = $stdout
+      @format  = :dot
+      @runner  = :parallel
+      @backend = SSHKit::Backend::Netssh
+    end
+
+    def command_map
+      @command_map ||= begin
+        Hash.new do |hash, command|
+          if %w{if test time}.include? command.to_s
+            hash[command] = command.to_s
+          else
+            hash[command] = "/usr/bin/env #{command}"
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/sshkit/connection_manager.rb

@@ -0,0 +1,93 @@
+require 'timeout'
+
+class Runner
+
+  attr_reader :hosts, :block
+
+  def initialize(hosts, &block)
+    @hosts       = Array(hosts)
+    @block       = block
+  end
+
+end
+
+class ParallelRunner < Runner
+  def execute
+    threads = []
+    hosts.each do |host|
+      threads << Thread.new(host) do |h|
+        SSHKit.config.backend.new(host, &block).run
+      end
+    end
+    threads.map(&:join)
+  end
+end
+
+class SequentialRunner < Runner
+  attr_writer :wait_interval
+  def execute
+    hosts.each do |host|
+      SSHKit.config.backend.new(host, &block).run
+      sleep wait_interval
+    end
+  end
+  private
+  def wait_interval
+    @wait_interval ||= 2
+  end
+end
+
+class GroupRunner < SequentialRunner
+  attr_writer :group_size
+  def execute
+    hosts.each_slice(group_size).collect do |group_hosts|
+      ParallelRunner.new(group_hosts, &block).execute
+      sleep wait_interval
+    end.flatten
+  end
+  private
+  def group_size
+    @group_size ||= 2
+  end
+end
+
+module SSHKit
+
+  NoValidHosts = Class.new(StandardError)
+
+  class ConnectionManager
+
+    attr_accessor :hosts
+
+    def initialize(raw_hosts)
+      @raw_hosts = Array(raw_hosts)
+      raise NoValidHosts unless Array(raw_hosts).any?
+      resolve_hosts!
+    end
+
+    def each(options={}, &block)
+      options = default_options.merge(options)
+      case options[:in]
+      when :parallel then ParallelRunner
+      when :sequence then SequentialRunner
+      when :groups   then GroupRunner
+      else
+        raise RuntimeError, "Don't know how to handle run style #{options[:in].inspect}"
+      end.new(hosts, &block).execute
+    end
+
+    private
+
+      attr_accessor :cooldown
+
+      def default_options
+        { in: :parallel }
+      end
+
+      def resolve_hosts!
+        @hosts = @raw_hosts.collect { |rh| rh.is_a?(Host) ? rh : Host.new(rh) }.uniq
+      end
+
+  end
+
+end

data/lib/sshkit/dsl.rb

@@ -0,0 +1,15 @@
+require_relative '../sshkit'
+
+module SSHKit
+
+  module DSL
+
+    def on(hosts, options={}, &block)
+      ConnectionManager.new(hosts).each(options, &block)
+    end
+
+  end
+
+end
+
+include SSHKit::DSL

data/lib/sshkit/host.rb

@@ -0,0 +1,151 @@
+module SSHKit
+
+  UnparsableHostStringError = Class.new(StandardError)
+
+  class Host
+
+    attr_reader :hostname, :port, :username
+
+    attr_accessor :password
+
+    def initialize(host_string)
+
+      suitable_parsers = [
+        SimpleHostParser,
+        HostWithPortParser,
+        IPv6HostWithPortParser,
+        HostWithUsernameParser,
+        HostWithUsernameAndPortParser
+      ].select do |p|
+        p.suitable?(host_string)
+      end
+
+      if suitable_parsers.any?
+        suitable_parsers.first.tap do |parser|
+          @username, @hostname, @port = parser.new(host_string).attributes
+        end
+      else
+        raise UnparsableHostStringError, "Cannot parse host string #{host_string}"
+      end
+
+    end
+
+    def hash
+      username.hash ^ hostname.hash ^ port.hash
+    end
+
+    def eql?(other_host)
+      other_host.hash == hash
+    end
+    alias :== :eql?
+    alias :equal? :eql?
+
+    def to_key
+      to_s.to_sym
+    end
+
+    def to_s
+      sprintf("%s@%s:%d", username, hostname, port)
+    end
+
+  end
+
+  # @private
+  # :nodoc:
+  class SimpleHostParser
+
+    def self.suitable?(host_string)
+      !host_string.match /[:|@]/
+    end
+
+    def initialize(host_string)
+      @host_string = host_string
+    end
+
+    def username
+      `whoami`.chomp
+    end
+
+    def port
+      22
+    end
+
+    def hostname
+      @host_string
+    end
+
+    def attributes
+      [username, hostname, port]
+    end
+
+  end
+
+  # @private
+  # :nodoc:
+  class HostWithPortParser < SimpleHostParser
+
+    def self.suitable?(host_string)
+      !host_string.match /[@|\[|\]]/
+    end
+
+    def port
+      @host_string.split(':').last.to_i
+    end
+
+    def hostname
+      @host_string.split(':').first
+    end
+
+  end
+
+  # @private
+  # :nodoc:
+  class IPv6HostWithPortParser < SimpleHostParser
+
+    def self.suitable?(host_string)
+      host_string.match /[a-fA-F0-9:]+:\d+/
+    end
+
+    def port
+      @host_string.split(':').last.to_i
+    end
+
+    def hostname
+      @host_string.gsub!(/\[|\]/, '')
+      @host_string.split(':')[0..-2].join(':')
+    end
+
+  end
+
+  # @private
+  # :nodoc:
+  class HostWithUsernameParser < SimpleHostParser
+    def self.suitable?(host_string)
+      host_string.match(/@/) && !host_string.match(/\:/)
+    end
+    def username
+      @host_string.split('@').first
+    end
+    def hostname
+      @host_string.split('@').last
+    end
+  end
+
+  # @private
+  # :nodoc:
+  class HostWithUsernameAndPortParser < SimpleHostParser
+    def self.suitable?(host_string)
+      host_string.match /@.*:\d+/
+    end
+    def username
+      @host_string.split(/:|@/)[0]
+    end
+    def hostname
+      @host_string.split(/:|@/)[1]
+    end
+    def port
+      @host_string.split(/:|@/)[2].to_i
+    end
+  end
+
+end

data/lib/sshkit/version.rb

@@ -0,0 +1,3 @@
+module SSHKit
+  VERSION = "0.0.1"
+end

data/lib/sshkit.rb

@@ -0,0 +1,27 @@
+require 'thread'
+require_relative 'sshkit/all'
+
+module SSHKit
+
+  class << self
+    attr_accessor :config
+  end
+
+  def self.capture_output(io, &block)
+    original_io = config.output
+    config.output = io
+    yield
+  ensure
+    config.output = original_io
+  end
+
+  def self.configure
+    @@config ||= Configuration.new
+    yield config
+  end
+
+  def self.config
+    @@config ||= Configuration.new
+  end
+
+end

data/sshkit.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sshkit/version', __FILE__)
+
+Gem::Specification.new do |gem|
+
+  gem.authors       = ["Lee Hambley", "Tom Clements"]
+  gem.email         = ["lee.hambley@gmail.com", "seenmyfate@gmail.com"]
+  gem.summary       = %q{SSHKit makes it easy to write structured, testable SSH commands in Ruby}
+  gem.description   = %q{A comprehensive toolkit for remotely running commands in a structured manner on groups of servers.}
+  gem.homepage      = "http://wacku.github.com/sshkit"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "sshkit"
+  gem.require_paths = ["lib"]
+  gem.version       = SSHKit::VERSION
+
+  gem.add_dependency('net-ssh')
+  gem.add_dependency('term-ansicolor')
+
+  gem.add_development_dependency('minitest', ['>= 2.11.3', '< 2.12.0'])
+  gem.add_development_dependency('autotest')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('turn')
+  gem.add_development_dependency('unindent')
+  gem.add_development_dependency('mocha')
+  gem.add_development_dependency('debugger')
+  gem.add_development_dependency('vagrant')
+
+  gem.add_development_dependency('yard')
+  gem.add_development_dependency('redcarpet')
+
+end

data/test/functional/test_connection_manager.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+module SSHKit
+
+  class TestConnectionManager < FunctionalTest
+
+    def setup
+
+    end
+
+    def test_running_commands_on_real_hosts
+
+    end
+
+  end
+
+end

data/test/functional/test_ssh_server_comes_up_for_functional_tests.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+module SSHKit
+
+  class TestHost < FunctionalTest
+
+    def host
+      @_host ||= Host.new('')
+    end
+
+    def test_that_it_works
+      assert true
+    end
+
+    def test_creating_a_user_gives_us_back_his_private_key_as_a_string
+      keys = create_user_with_key(:peter)
+      assert_equal [:one, :two, :three], keys.keys
+      assert keys.values.all?
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'tempfile'
+require 'minitest/unit'
+require 'mocha'
+require 'turn'
+require 'unindent'
+require 'debugger'
+require 'vagrant'
+require 'stringio'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sshkit'
+
+module Vagrant
+  module Communication
+    class SSH
+      def download(from)
+        scp_connect do |scp|
+          return StringIO.new.tap do |sio|
+            scp.download!(from, sio)
+          end
+        end
+      rescue RuntimeError => e
+        raise if e.message !~ /Permission denied/
+        raise Vagrant::Errors::SCPPermissionDenied, :path => from.to_s
+      end
+      private
+      def scp_connect
+        connect do |connection|
+          scp = Net::SCP.new(connection)
+          return yield scp
+        end
+      rescue Net::SCP::Error => e
+        raise Vagrant::Errors::SCPUnavailable if e.message =~ /\(127\)/
+        raise
+      end
+    end
+  end
+end
+
+class UnitTest < MiniTest::Unit::TestCase
+
+end
+
+class FunctionalTest < MiniTest::Unit::TestCase
+
+  attr_accessor :venv
+
+  def setup
+    @venv = Vagrant::Environment.new
+    venv.vms.each do |name, vm|
+      warn "#{name} (of #{venv.vms.size}) needs to be booted, please wait" unless vm.state == :running
+    end
+    venv.cli "up"
+  end
+
+  private
+
+  def vm_hosts
+    venv.vms.collect do |name, vm|
+      port = vm.env.config.for_vm(name).vm.forwarded_ports.first[:hostport]
+      SSHKit::Host.new("vagrant@localhost:#{port}").tap do |h|
+        h.password = 'vagrant'
+      end
+    end
+  end
+
+  def create_user_with_key(username, password = :secret)
+    username, password = username.to_s, password.to_s
+    keys = venv.vms.collect do |hostname, vm|
+
+      # Remove the user, make it again, force-generate a key for him
+      # short keys save us a few microseconds
+      vm.channel.sudo("userdel -rf #{username}; true") # The `rescue nil` of the shell world
+      vm.channel.sudo("useradd -m #{username}")
+      vm.channel.sudo("echo y | ssh-keygen -b 1024 -f #{username} -N ''")
+      vm.channel.sudo("chown vagrant:vagrant #{username}*")
+      vm.channel.sudo("echo #{username}:#{password} | chpasswd")
+
+      # Make the .ssh directory, change the ownership and the
+      vm.channel.sudo("mkdir -p /home/#{username}/.ssh")
+      vm.channel.sudo("chown #{username}:#{username} /home/#{username}/.ssh")
+      vm.channel.sudo("chmod 700 /home/#{username}/.ssh")
+
+      # Move the key to authorized keys and chown and chmod it
+      vm.channel.sudo("cat #{username}.pub > /home/#{username}/.ssh/authorized_keys")
+      vm.channel.sudo("chown #{username}:#{username} /home/#{username}/.ssh/authorized_keys")
+      vm.channel.sudo("chmod 600 /home/#{username}/.ssh/authorized_keys")
+
+      sio = vm.channel.download("/home/vagrant/#{username}")
+
+      # Clean Up Files
+      vm.channel.sudo("rm #{username} #{username}.pub")
+
+      # Rewind the stringio, and read it as a string
+      sio.tap { |s| s.rewind }.read
+
+    end
+
+    Hash[venv.vms.collect { |n,vm| n }.zip(keys)]
+
+  end
+
+end
+
+class IntegrationTest < MiniTest::Unit::TestCase
+
+end
+
+#
+# Force colours in Autotest
+#
+Turn.config.ansi = true
+Turn.config.format = :pretty
+
+MiniTest::Unit.autorun

data/test/integration/backends/test_netssh.rb

@@ -0,0 +1,99 @@
+require 'helper'
+
+module SSHKit
+
+  module Backend
+
+    class ToSIoFormatter < StringIO
+      extend Forwardable
+      attr_reader :original_output
+      def_delegators :@original_output, :read, :rewind
+      def initialize(oio)
+        @original_output = oio
+      end
+      def write(obj)
+        warn "What: #{obj.to_hash}"
+        original_output.write "> Executing #{obj}\n"
+      end
+    end
+
+    class TestPrinter < FunctionalTest
+
+      def block_to_run
+        lambda do |host|
+          execute 'date'
+          execute :ls, '-l', '/some/directory'
+          with rails_env: :production do
+            within '/tmp' do
+              as :root do
+                execute :touch, 'restart.txt'
+              end
+            end
+          end
+        end
+      end
+
+      def a_host
+        vm_hosts.first
+      end
+
+      def printer
+        Netssh.new(a_host, &block_to_run)
+      end
+
+      def simple_netssh
+        sio = ToSIoFormatter.new(StringIO.new)
+        SSHKit.capture_output(sio) do
+          printer.run
+        end
+        sio.rewind
+        result = sio.read
+        assert_equal <<-EOEXPECTED.unindent, result
+          > Executing if test ! -d /opt/sites/example.com; then echo "Directory does not exist '/opt/sites/example.com'" 2>&1; false; fi
+          > Executing cd /opt/sites/example.com && /usr/bin/env date
+          > Executing cd /opt/sites/example.com && /usr/bin/env ls -l /some/directory
+          > Executing if test ! -d /opt/sites/example.com/tmp; then echo "Directory does not exist '/opt/sites/example.com/tmp'" 2>&1; false; fi
+          > Executing if ! sudo su -u root whoami > /dev/null; then echo "You cannot switch to user 'root' using sudo, please check the sudoers file" 2>&1; false; fi
+          > Executing cd /opt/sites/example.com/tmp && ( RAILS_ENV=production ( sudo su -u root /usr/bin/env touch restart.txt ) )
+        EOEXPECTED
+      end
+
+      def test_capture
+        File.open('/dev/null', 'w') do |dnull|
+          SSHKit.capture_output(dnull) do
+            captured_command_result = ""
+            Netssh.new(a_host) do |host|
+              captured_command_result = capture(:hostname)
+            end.run
+            assert_equal "lucid32", captured_command_result
+          end
+        end
+      end
+
+      def test_exit_status
+
+      end
+
+      def test_raising_an_error_if_a_command_returns_a_bad_exit_status
+        skip "Where to implement this?"
+        # NOTE: I think that it might be wise to have Command raise when
+        # Command#exit_status=() is called, it would allow an option to
+        # be passed to command (raise_errors: false), which could also be
+        # inherited through Backend#command and specified on the (not yet
+        # existing) backend configurations.
+        assert_raises RuntimeError do
+          File.open('/dev/null', 'w') do |dnull|
+            SSHKit.capture_output(dnull) do
+              Netssh.new(a_host) do |host|
+                execute :false
+              end.run
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/unit/backends/test_netssh.rb

@@ -0,0 +1,14 @@
+require 'helper'
+
+module SSHKit
+  module Backend
+    class TestNetssh < UnitTest
+      def backend
+        Netssh.new(Host.new('example.com'), Proc.new)
+      end
+      def test_net_ssh_configuration_timeout
+        skip "No configuration on the Netssh class yet"
+      end
+    end
+  end
+end

data/test/unit/backends/test_printer.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+module SSHKit
+
+  module Backend
+
+    class ToSIoFormatter < StringIO
+      extend Forwardable
+      attr_reader :original_output
+      def_delegators :@original_output, :read, :rewind
+      def initialize(oio)
+        @original_output = oio
+      end
+      def write(obj)
+        original_output.write "> Executing #{obj}\n"
+      end
+    end
+
+    class TestPrinter < UnitTest
+
+      def block_to_run
+        lambda do |host|
+          within '/opt/sites/example.com' do
+            execute 'date'
+            execute :ls, '-l', '/some/directory'
+            with rails_env: :production do
+              within :tmp do
+                as :root do
+                  execute :touch, 'restart.txt'
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def printer
+        Printer.new(Host.new(:'example.com'), &block_to_run)
+      end
+
+      def test_simple_printing
+        sio = ToSIoFormatter.new(StringIO.new)
+        SSHKit.capture_output(sio) do
+          printer.run
+        end
+        sio.rewind
+        result = sio.read
+        assert_equal <<-EOEXPECTED.unindent, result
+          > Executing if test ! -d /opt/sites/example.com; then echo "Directory does not exist '/opt/sites/example.com'" 1>&2; false; fi
+          > Executing cd /opt/sites/example.com && /usr/bin/env date
+          > Executing cd /opt/sites/example.com && /usr/bin/env ls -l /some/directory
+          > Executing if test ! -d /opt/sites/example.com/tmp; then echo "Directory does not exist '/opt/sites/example.com/tmp'" 1>&2; false; fi
+          > Executing if ! sudo su root -c whoami > /dev/null; then echo "You cannot switch to user 'root' using sudo, please check the sudoers file" 1>&2; false; fi
+          > Executing cd /opt/sites/example.com/tmp && ( RAILS_ENV=production sudo su root -c /usr/bin/env touch restart.txt )
+        EOEXPECTED
+      end
+
+    end
+
+  end
+
+end