ssh_voodoo 0.0.1

data/README.md

@@ -0,0 +1,23 @@
+# ssh_voodoo
+ssh_voodo is a Ruby script to help with the task of running commands on remote machines via ssh. It allows you to run commands remotely in parallel and helps cache your password (including sudo) so you don't have to keep on entering your password. There's also an option to use ssh key.
+
+## Installation
+It's hosted on rubygems.org
+
+    sudo gem install ssh_voodoo
+
+## Usage
+
+```
+   ssh_voodoo -h
+   Usage: ssh_voodoo [options]
+     -s, --servers=SERVERS    Servers to apply the actions to
+         --debug              Print lots of messages
+         --use-ssh-key [FILE] Use ssh key instead of password
+     -c, --command=STRING     What command to run on the remote server
+         --username=USERNAME  What username to use for connecting to remote servers
+         --dw=INTEGER         Number of workers for parallel ssh connections
+         --connectiontimeout=INTEGER
+                              Connection timeout
+     -h, --help               Show this message
+```

data/bin/ssh_voodoo

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'ssh_voodoo'
+require 'optparse'
+
+options = {}    # options for how to running ssh_voodoo
+servers = nil
+cmd = nil
+
+opts = OptionParser.new(nil, 24, '  ')
+opts.banner = 'Usage: ssh_voodoo [options]'
+opts.on('--servers', '-s', '=SERVERS', Array, 'Servers to apply the actions to') do |opt|
+  servers = opt
+end
+opts.on('--debug', 'Print lots of messages') do |opt|
+  options["debug"] = opt
+end
+opts.on('--use-ssh-key [FILE]', 'Use ssh key instead of password') do |opt|
+  options["use-ssh-key"] = true
+  options["ssh-key"] = opt
+end
+
+opts.on('--command', '-c', '=STRING', 'What command to run on the remote server') do |opt|
+  cmd = opt
+end
+opts.on('--username', '=USERNAME', 'What username to use for connecting to remote servers') do |opt|
+  options["username"] = opt
+end
+opts.on('--dw', '=INTEGER', 'Number of workers for parallel ssh connections') do |opt|
+  options["max-worker"] = opt.to_i
+end
+opts.on('--connectiontimeout', '=INTEGER', 'Connection timeout') do |opt|
+  options["connectiontimeout"] = opt.to_i
+end
+opts.on_tail("-h", "--help", "Show this message") do
+  puts opts
+  exit 
+end
+
+leftovers = opts.parse(ARGV)
+
+if cmd.nil? or servers.nil?
+  puts opts
+  exit
+end
+
+ssh_voodoo = SshVoodoo.new(options)
+ssh_voodoo.perform_magic(cmd, servers)

data/lib/ssh_voodoo.rb

@@ -0,0 +1,192 @@
+require 'thread_pool'
+require 'rubygems'
+require 'net/ssh'
+require 'thread'
+
+require 'etc'
+
+class SshVoodoo
+  
+  def initialize(options = nil)
+    @sudo_pw = nil
+    @pw_prompts = {}
+    @mutex = Mutex.new
+    @max_worker = 4
+    @abort_on_failure = false
+    @use_ssh_key = false
+    @user = Etc.getlogin
+    @password = nil
+    @connectiontimeout = options["connectiontimeout"]
+    @debug = false
+    unless options.nil? or options.empty?
+      @user = options["username"] unless options["username"].nil?
+      @password = options["deploy-password"] unless options["deploy-password"].nil?
+      @max_worker = options["max-worker"] unless options["max-worker"].nil?
+      @abort_on_failure = options["abort-on-failure"] unless options["abort-on-failure"].nil?
+      @use_ssh_key = options["use-ssh-key"] unless options["use-ssh-key"].nil?
+      @ssh_key = options["ssh-key"] unless options["ssh-key"].nil?
+      @debug = options["debug"] unless options["debug"].nil?
+    end
+  end
+
+  def prompt_username
+    ask("Username: ")
+  end     
+         
+  def prompt_password
+    ask("SSH Password (leave blank if using ssh key): ", true) 
+  end
+
+  def ask(str,mask=false)
+    begin
+      print str
+      system 'stty -echo;' if mask
+      input = STDIN.gets.chomp
+    ensure
+      system 'stty echo; echo ""'
+    end  
+    return input
+  end
+
+  def get_sudo_pw
+    @mutex.synchronize {
+      if @sudo_pw.nil?
+        @sudo_pw = ask("Sudo password: ", true)
+      else
+        return @sudo_pw
+      end    
+    }
+  end
+
+  # Prompt user for input and cache it. If in the future, we see
+  # the same prompt again, we can reuse the existing inputs. This saves
+  # the users from having to type in a bunch of inputs (such as password)
+  def get_input_for_pw_prompt(prompt)
+    @mutex.synchronize {
+      if @pw_prompts[prompt].nil?
+        @pw_prompts[prompt] = ask(prompt, true)
+      end
+      return @pw_prompts[prompt]
+    }
+  end
+
+  # Return a block that can be used for executing a cmd on the remote server
+  def ssh_execute(server, username, password, key, cmd)
+    return lambda { 
+      exit_status = 0
+      result = []
+
+      params = {}
+      params[:password] = password if password
+      params[:keys] = [key] if key
+      params[:timeout] = @connectiontimeout if @connectiontimeout
+
+      begin
+        Net::SSH.start(server, username, params) do |ssh|
+          puts "Connecting to #{server}"
+          ch = ssh.open_channel do |channel|
+            # now we request a "pty" (i.e. interactive) session so we can send data
+            # back and forth if needed. it WILL NOT WORK without this, and it has to
+            # be done before any call to exec.
+  
+            channel.request_pty do |ch, success|
+              raise "Could not obtain pty (i.e. an interactive ssh session)" if !success
+            end
+  
+            channel.exec(cmd) do |ch, success|
+              puts "Executing #{cmd} on #{server}" if @debug
+              # 'success' isn't related to bash exit codes or anything, but more
+              # about ssh internals (i think... not bash related anyways).
+              # not sure why it would fail at such a basic level, but it seems smart
+              # to do something about it.
+              abort "could not execute command" unless success
+  
+              # on_data is a hook that fires when the loop that this block is fired
+              # in (see below) returns data. This is what we've been doing all this
+              # for; now we can check to see if it's a password prompt, and
+              # interactively return data if so (see request_pty above).
+              channel.on_data do |ch, data|
+                if data =~ /Password:/
+                  password = get_sudo_pw unless !password.nil? && password != ""
+                  channel.send_data "#{password}\n"
+                elsif data =~ /password/i or data  =~ /passphrase/i or 
+                      data =~ /pass phrase/i or data =~ /incorrect passphrase/i
+                  input = get_input_for_pw_prompt(data)
+                  channel.send_data "#{input}\n"
+                else
+                  result << data unless data.nil? or data.empty?
+                end
+              end
+  
+              channel.on_extended_data do |ch, type, data|
+                print "SSH command returned on stderr: #{data}"
+              end
+  
+              channel.on_request "exit-status" do |ch, data| 
+                exit_status = data.read_long
+              end
+            end
+          end
+          ch.wait
+          ssh.loop
+        end  
+        puts "==================================================\nResult from #{server}:" 
+        puts result.join 
+        puts "=================================================="
+
+      rescue Net::SSH::AuthenticationFailed
+        exit_status = 1
+        puts "Bad username/password combination for host #{server}"
+      rescue Exception => e
+        exit_status = 1
+        puts e.inspect if @debug
+        puts e.backtrace if @debug
+        puts "Can't connect to #{server}"
+      end
+
+      return exit_status
+    }
+  end
+
+  # servers is an array, a filename or a callback that list the remote servers where we want to ssh to
+  def perform_magic(cmd, servers)
+    user = @user
+
+    if @user.nil?  && !@use_ssh_key
+      @user = prompt_username
+    end
+
+    if @password.nil? && !@use_ssh_key
+      @password = prompt_password
+    end
+
+    tp = ThreadPool.new(@max_worker)
+    statuses = {}
+    ssh_to = []
+    if servers.kind_of?(Proc)
+      ssh_to = servers.call
+    elsif servers.size == 1 && File.exists?(servers[0])
+      puts "Reading server list from file #{servers[0]}"
+      File.open(servers[0], 'r') do |f|
+        while line = f.gets
+          ssh_to << line.chomp.split(",")
+        end
+      end
+      ssh_to.flatten!
+    else
+      ssh_to = servers
+    end
+
+    ssh_to.each do | server |
+      tp.process(server) do
+        status = ssh_execute(server, @user, @password, @ssh_key, cmd).call
+        statuses[server] = status
+      end
+    end
+    tp.shutdown
+    puts "Exit statuses: "
+    puts statuses.inspect
+    
+    return statuses
+  end
+end

data/lib/thread_pool.rb

@@ -0,0 +1,103 @@
+require 'thread'
+
+class ThreadPool
+  class Worker
+    def initialize(thread_queue)
+      @block = nil
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @queue = thread_queue
+      @running = true
+      @thread = Thread.new do
+        @mutex.synchronize do
+          while @running
+            @cv.wait(@mutex)
+            block = get_block
+            if block
+              @mutex.unlock
+              block.call
+              @mutex.lock
+              reset_block
+            end
+            @queue << self
+          end
+        end
+      end
+    end
+
+    def name
+      @thread.inspect
+    end
+
+    def get_block
+      @block
+    end
+
+    def set_block(block)
+      @mutex.synchronize do
+        raise RuntimeError, "Thread already busy." if @block
+        @block = block
+        # Signal the thread in this class, that there's a job to be done
+        @cv.signal
+      end
+    end
+
+    def reset_block
+      @block = nil
+    end
+
+    def busy?
+      @mutex.synchronize { !@block.nil? }
+    end
+
+    def stop
+      @mutex.synchronize do
+        @running = false
+        @cv.signal
+      end
+      @thread.join
+    end
+  end
+
+  attr_accessor :max_size
+
+  def initialize(max_size = 10)
+    @max_size = max_size
+    @queue = Queue.new
+    @workers = []
+  end
+
+  def size
+    @workers.size
+  end
+
+  def busy?
+    @queue.size < @workers.size
+  end
+
+  def shutdown
+    @workers.each { |w| w.stop }
+    @workers = []
+  end
+
+  alias :join :shutdown
+
+  def process(block=nil,&blk)
+    block = blk if block_given?
+    worker = get_worker
+    worker.set_block(block)
+  end
+
+  private
+
+  def get_worker
+    if !@queue.empty? or @workers.size == @max_size
+      return @queue.pop
+    else
+      worker = Worker.new(@queue)
+      @workers << worker
+      worker
+    end
+  end
+
+end

data/ssh_voodoo.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "ssh_voodoo"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Darren Dao"]
+  s.email       = ["darrendao@gmail.com"]
+  s.homepage    = "https://github.com/darrendao/ssh_voodoo"
+  s.summary     = %q{Ruby script to help with the task of running commands on remote machines via ssh.}
+  s.description = %q{Ruby script to help with the task of running commands on remote machines via ssh. It supports password caching and ssh keys. You can specify the remote hosts on the cmd option, or via a file.}
+
+  s.add_dependency 'net-ssh', '~> 2.3'
+  s.add_development_dependency 'yard', '~> 0.7'
+
+  s.files            = `git ls-files`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+end
+

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: ssh_voodoo
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Darren Dao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 7
+        version: "0.7"
+  type: :development
+  version_requirements: *id002
+description: Ruby script to help with the task of running commands on remote machines via ssh. It supports password caching and ssh keys. You can specify the remote hosts on the cmd option, or via a file.
+email: 
+- darrendao@gmail.com
+executables: 
+- ssh_voodoo
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- bin/ssh_voodoo
+- lib/ssh_voodoo.rb
+- lib/thread_pool.rb
+- ssh_voodoo.gemspec
+homepage: https://github.com/darrendao/ssh_voodoo
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Ruby script to help with the task of running commands on remote machines via ssh.
+test_files: []
+
+has_rdoc: