sshwrap 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sshwrap.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jason Heiss
+
+MIT License
+
+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,36 @@
+# SSHwrap
+
+This provides a wrapper for ssh that execute a command on multiple machines,
+optionally in parallel, and handles any sudo prompts that result.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sshwrap'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sshwrap
+
+## Usage
+
+    Usage: sshwrap [options]
+      -c, --command, --cmd=CMD Command to run
+      -u, --user=USER          SSH as specified user
+      -k, --ssh-key=KEY        Use the specified SSH private key
+          --abort-on-failure   Abort if connection or command fails with any target
+          --max-workers=NUM    Use specified number of parallel connections
+          --debug              Enable debugging
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  # t.verbose = true
+end

data/TODO

@@ -0,0 +1,11 @@
+Options for displaying the output as the command runs on the various targets:
+
+* Immediate (lines from various targets intermingled)
+* Immediate, prefaced by hostname
+* Captured (lines for a target displayed together once command completes)
+
+Other ways of specifying targets:
+
+* stdin
+* groups, with user-supplied group expansion script
+* read from file

data/bin/sshwrap

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'sshwrap'
+require 'optparse'
+
+@options = {}
+@cmd = nil
+
+opts = OptionParser.new(nil, 24, '  ')
+opts.banner = 'Usage: sshwrap [options]'
+opts.on('--command', '--cmd', '-c', '=CMD', 'Command to run') do |opt|
+  @cmd = opt
+end
+opts.on('--user', '-u', '=USER', 'SSH as specified user') do |opt|
+  @options[:user] = opt
+end
+opts.on('--ssh-key', '-k', '=KEY', 'Use the specified SSH private key') do |opt|
+  @options[:ssh_key] = opt
+end
+opts.on('--abort-on-failure', 'Abort if connection or command fails with any target') do |opt|
+  options[:abort_on_failure] = opt
+end
+opts.on('--max-workers', '=NUM', 'Use specified number of parallel connections') do |opt|
+  options[:max_workers] = opt
+end
+opts.on('--debug', 'Enable debugging') do |opt|
+  @options[:debug] = opt
+end
+
+leftovers = nil
+begin
+  leftovers = opts.parse(ARGV)
+rescue OptionParser::ParseError => e
+  $stderr.puts "Error parsing arguments, try --help"
+  $stderr.puts e.message
+  exit 1
+end
+@targets = leftovers
+
+sshwrap = SSHwrap::Main.new(@options)
+sshwrap.sshwrap(@cmd, @targets)

data/lib/sshwrap/main.rb

@@ -0,0 +1,151 @@
+require 'net/ssh'
+require 'highline/import'
+
+class SSHwrap::Main
+  def initialize(options={})
+    @mutex = Mutex.new
+    @max_workers = options[:max_workers] || 1
+    @abort_on_failure = options[:abort_on_failure]
+    @user = options[:user] || Etc.getlogin
+    @ssh_key = options[:ssh_key]
+    @debug = options[:debug]
+    @password = nil
+  end
+  
+  def get_password
+    @mutex.synchronize do
+      if !@password
+        @password = ask("Password for #{@user}: ") { |q| q.echo = "x" }
+      end
+    end
+    @password
+  end
+  
+  def ssh_execute(cmd, target)
+    exitstatus = nil
+    stdout = []
+    stderr = []
+    
+    params = {}
+    if @ssh_key
+      params[:keys] = [@ssh_key]
+    end
+    using_password = false
+    if @password
+      using_password = true
+      params[:password] = @password
+    end
+    
+    begin
+      Net::SSH.start(target, @user, params) do |ssh|
+        puts "Connecting to #{target}" if @debug
+        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_pty, success|
+            if !success
+              raise "Could not obtain pty (interactive ssh session) on #{target}"
+            end
+          end
+          
+          channel.exec(cmd) do |ch_exec, success|
+            puts "Executing '#{cmd}' on #{target}" if @debug
+            # 'success' isn't related to process exit codes or anything, but
+            # more about ssh internals.  Not sure why it would fail at such
+            # a basic level, but it seems smart to do something about it.
+            if !success
+              raise "SSH unable to execute command on #{target}"
+            end
+            
+            # on_data is a hook that fires when ssh returns output 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, data|
+              # This is the standard sudo password prompt
+              if data =~ /Password:/
+                channel.send_data "#{get_password}\n"
+              else
+                stdout << data unless (data.nil? or data.empty?)
+              end
+            end
+            
+            channel.on_extended_data do |ch_onextdata, type, data|
+              stderr << data unless (data.nil? or data.empty?)
+            end
+            
+            channel.on_request "exit-status" do |ch_onreq, data|
+              exitstatus = data.read_long
+            end
+          end
+        end
+        ch.wait
+        ssh.loop
+      end
+    rescue Net::SSH::AuthenticationFailed
+      if !using_password
+        get_password
+        return ssh_execute(cmd, target)
+      else
+        stderr << "Authentication failed to #{target}"
+      end
+    rescue Exception => e
+      stderr << "SSH connection error: #{e.message}"
+    end
+    
+    [exitstatus, stdout, stderr]
+  end
+  
+  # cmd is a string or array of strings containing the command and arguments
+  # targets is an array of remote system hostnames
+  def sshwrap(cmd, targets)
+    cmdstring = nil
+    if cmd.kind_of?(Array)
+      cmdstring = cmd.join(' ')
+    else
+      cmdstring = cmd.to_s
+    end
+    
+    statuses = {}
+    
+    threads = (1..@max_workers).map do |i|
+      Thread.new("worker#{i}") do |tname|
+        while true
+          target = nil
+          @mutex.synchronize do
+            target = targets.shift
+          end
+          if !target
+            break
+          end
+          puts "Thread #{tname} processing target #{target}" if @debug
+          
+          exitstatus, stdout, stderr = ssh_execute(cmdstring, target)
+          statuses[target] = exitstatus
+          
+          @mutex.synchronize do
+            puts '=================================================='
+            if !stdout.empty?
+              puts "Output from #{target}:"
+              puts stdout.join
+            end
+            if !stderr.empty?
+              puts "Error from #{target}:"
+              puts stderr.join
+            end
+            puts "Exit status from #{target}: #{exitstatus}"
+          end
+          
+          if @abort_on_failure && exitstatus != 0
+            exit exitstatus
+          end
+        end
+      end
+    end
+    
+    threads.each(&:join)
+    
+    statuses
+  end
+end

data/lib/sshwrap/version.rb

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

data/lib/sshwrap.rb

@@ -0,0 +1,5 @@
+require 'sshwrap/version'
+require 'sshwrap/main'
+
+module SSHwrap
+end

data/sshwrap.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sshwrap/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Jason Heiss']
+  gem.email         = ['jheiss@aput.net']
+  gem.description   = File.read('README.md')
+  gem.summary       = 'Perform batch SSH operations, handling sudo prompts'
+  gem.homepage      = 'https://github.com/jheiss/sshwrap'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'sshwrap'
+  gem.require_paths = ['lib']
+  gem.version       = SSHwrap::VERSION
+  gem.add_dependency('net-ssh')
+  gem.add_dependency('highline')
+end

data/test/test_options.rb

@@ -0,0 +1,72 @@
+#
+# Test sshwrap command line options
+#
+
+require 'test/unit'
+require 'open4'
+require 'rbconfig'
+
+RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) +
+         RbConfig::CONFIG["EXEEXT"]
+LIBDIR = File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+SSHWRAP = File.expand_path('../bin/sshwrap', File.dirname(__FILE__))
+
+class SSHwrapOptionTests < Test::Unit::TestCase
+  def test_help
+    output = nil
+    IO.popen("#{RUBY} -I #{LIBDIR} #{SSHWRAP} --help") do |pipe|
+      output = pipe.readlines
+    end
+    # Make sure at least something resembling help output is there
+    assert(output.any? {|line| line.include?('Usage: sshwrap [options]')}, 'help output content')
+    # Make sure it fits on the screen
+    assert(output.all? {|line| line.length <= 80}, 'help output columns')
+    assert(output.size <= 23, 'help output lines')
+  end
+  
+  def test_command_arg_required
+  end
+  def test_command
+  end
+  
+  def test_user_arg_required
+  end
+  def test_user
+  end
+  
+  def test_ssh_key_arg_required
+    output = nil
+    error = nil
+    status = Open4.popen4("#{RUBY} -I #{LIBDIR} #{SSHWRAP} --ssh-key") do |pid, stdin, stdout, stderr|
+      stdin.close
+      output = stdout.readlines
+      error = stderr.readlines
+    end
+    assert_equal(1, status.exitstatus, "-ssh-key arg required exitstatus")
+    # Make sure the expected lines are there
+    assert(error.any? {|line| line.include?('missing argument: --ssh-key')})
+  end
+  def test_ssh_key_bogus_file
+    # error = nil
+    # status = Open4.popen4("#{RUBY} -I #{LIBDIR} #{SSHWRAP} --ssh-key bogus") do |pid, stdin, stdout, stderr|
+    #   stdin.close
+    #   error = stderr.readlines
+    # end
+    # # Make sure the expected lines are there
+    # assert(error.any? {|line| line.include?('Unable to read ssh key from bogus')})
+  end
+  def test_ssh_key
+  end
+  
+  def test_abort_on_failure
+  end
+  
+  def test_max_workers_arg_required
+  end
+  def test_max_workers
+  end
+  
+  def test_debug
+  end
+end
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: sshwrap
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jason Heiss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "# SSHwrap\n\nThis provides a wrapper for ssh that execute a command
+  on multiple machines,\noptionally in parallel, and handles any sudo prompts that
+  result.\n\n## Installation\n\nAdd this line to your application's Gemfile:\n\n    gem
+  'sshwrap'\n\nAnd then execute:\n\n    $ bundle\n\nOr install it yourself as:\n\n
+  \   $ gem install sshwrap\n\n## Usage\n\n    Usage: sshwrap [options]\n      -c,
+  --command, --cmd=CMD Command to run\n      -u, --user=USER          SSH as specified
+  user\n      -k, --ssh-key=KEY        Use the specified SSH private key\n          --abort-on-failure
+  \  Abort if connection or command fails with any target\n          --max-workers=NUM
+  \   Use specified number of parallel connections\n          --debug              Enable
+  debugging\n\n## Contributing\n\n1. Fork it\n2. Create your feature branch (`git
+  checkout -b my-new-feature`)\n3. Commit your changes (`git commit -am 'Added some
+  feature'`)\n4. Push to the branch (`git push origin my-new-feature`)\n5. Create
+  new Pull Request\n"
+email:
+- jheiss@aput.net
+executables:
+- sshwrap
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- bin/sshwrap
+- lib/sshwrap.rb
+- lib/sshwrap/main.rb
+- lib/sshwrap/version.rb
+- sshwrap.gemspec
+- test/test_options.rb
+homepage: https://github.com/jheiss/sshwrap
+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: Perform batch SSH operations, handling sudo prompts
+test_files:
+- test/test_options.rb
+has_rdoc: