rutty 1.0.0

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,6 @@
+source :gemcutter
+
+gem "jeweler"
+gem "commander"
+gem "net-ssh"
+gem "net-scp"

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    commander (4.0.3)
+      highline (>= 1.5.0)
+    gemcutter (0.5.0)
+      json_pure
+    git (1.2.5)
+    highline (1.6.1)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.3)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.0.23)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  commander
+  jeweler
+  net-scp
+  net-ssh

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Josh Lindsey at Cloudspace
+
+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,35 @@
+RuTTY
+=====
+
+RuTTY is a DSH implementation in Ruby.
+
+Requirements
+------------
+
+* Ruby >= 1.8.7 (Not tested on 1.9.x)
+* Rubygems >= 1.3.7
+* Bundler >= 1.0.0
+
+Installation
+------------
+
+	$ sudo gem install bundler
+	$ git clone git://github.com/jlindsey/rutty.git
+	$ cd rutty
+	$ bundle install
+	$ ./rutty --help
+
+TODO
+----
+
+* Cleanup dsh action code
+* Expand the tag searching semantics to allow for AND and/or OR queries
+* Add a special printout for > 0 exit codes on dsh action
+* Implement delete_node command
+* Make better printouts
+* Documentation
+
+Copyright
+---------
+
+Copyright (c) 2010 Josh Lindsey at Cloudspace. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rutty"
+    gem.summary = %Q{A DSH implementation in Ruby}
+    gem.description = %Q{
+      RuTTY is a DSH (distributed / dancer's shell) written in Ruby. It's used to run commands 
+      on multiple remote servers at once, based on a tagging system. Also allows for multiple
+      SCP-style uploads.
+    }
+    gem.email = "josh@cloudspace.com"
+    gem.homepage = "http://github.com/jlindsey/rutty"
+    gem.authors = ["Josh Lindsey"]
+    gem.add_development_dependency "bundler", ">= 1.0.0"
+    gem.add_dependency "commander", ">= 0"
+    gem.add_dependency "net-ssh", ">= 0"
+    gem.add_dependency "net-scp", ">= 0"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/rutty

@@ -0,0 +1,299 @@
+#!/usr/bin/env ruby
+
+# Constants
+CONF_DIR = File.join(ENV['HOME'], '.rutty')
+GENERAL_CONF = File.join(CONF_DIR, 'defaults.yaml')
+NODES_CONF = File.join(CONF_DIR, 'nodes.yaml')
+
+# Gems
+require 'rubygems'
+require 'bundler/setup'
+require 'commander/import'
+require 'yaml'
+
+# Helpers
+add_filter_options = lambda { |c| 
+  c.option('--keypath PATH', String, 'Path to a private key')
+  c.option('--user NAME', String, 'User login')
+  c.option('--port NUMBER', Integer, 'SSH port number')
+  c.option('--tags TAG1[,TAG2,...]', Array, 'Comma-separated list of tags')
+}
+
+def update_node_list &block
+  ary = YAML.load(File.open(NODES_CONF).read)
+  
+  yield ary
+  
+  File.open(NODES_CONF, 'w') do |f|
+    YAML.dump(ary, f)
+  end
+  
+  @node_list = false # Force the next call to get_node_list to read from file again
+end
+
+def get_node_list
+  @node_list ||= YAML.load(File.open(NODES_CONF).read)
+end
+
+def get_defaults_config
+  @config ||= YAML.load(File.open(GENERAL_CONF).read)
+end
+
+def check_installed!
+  unless File.exists? CONF_DIR
+    raise "Can't find conf directory at #{CONF_DIR}. Run `rutty init' first. (Or rutty --help for usage)"
+  end
+end
+
+def filter_nodes nodes, options
+  return nodes if options.a === true
+  
+  nodes.delete_if { |node| node[:keypath].nil? or node[:keypath] != options.keypath } unless options.keypath.nil?
+  nodes.delete_if { |node| node[:user].nil? or node[:user] != options.user } unless options.user.nil?
+  nodes.delete_if { |node| node[:port].nil? or node[:port] != options.port } unless options.port.nil?
+  nodes.delete_if { |node| node[:tags].nil? or (node[:tags] & options.tags).empty? } unless options.tags.nil?
+end
+
+def options_for_node node
+  hash = node
+  
+  hash[:user] ||= get_defaults_config[:user]
+  hash[:port] ||= get_defaults_config[:port]
+  hash[:keypath] ||= get_defaults_config[:keypath]
+  # :host will always be set on node
+  
+  hash
+end
+
+# Commander config
+program :name, 'rutty'
+program :description, 'A DSH implementation in Ruby'
+program :version, '1.0.0'
+program :help_formatter, Commander::HelpFormatter::TerminalCompact
+
+default_command :dsh
+
+# Commander commands
+command :init do |c|
+  c.syntax = "rutty init"
+  c.summary = "Creates the default file structure for rutty."
+  c.when_called do
+    if File.exists? CONF_DIR
+      log "exists", CONF_DIR
+    else
+      log "create", CONF_DIR
+      Dir.mkdir CONF_DIR
+    end
+    
+    if File.exists? GENERAL_CONF
+      log "exists", GENERAL_CONF
+    else
+      log "create", GENERAL_CONF
+      
+      defaults_hash = { 
+        :user => 'root', 
+        :keypath => File.join(ENV['HOME'], '.ssh', 'id_rsa'), 
+        :port => 22
+      }
+      
+      File.open(GENERAL_CONF, 'w') do |f|
+        YAML.dump(defaults_hash, f)
+      end
+    end
+    
+    if File.exists? NODES_CONF
+      log "exists", NODES_CONF
+    else
+      log "create", NODES_CONF
+      
+      default_node = [
+        {
+          :host => 'localhost',
+          :port => 2222,
+          :keypath => File.join(ENV['HOME'], '.ssh', 'my_key.pem'),
+          :user => 'nobody',
+          :tags => %w(delete_me example localhost)
+        }
+      ]
+      
+      File.open(NODES_CONF, 'w') do |f|
+        YAML.dump(default_node, f)
+      end
+    end
+  end
+end
+
+command :add_node do |c|
+  c.syntax = "rutty add_node <HOST> [options]"
+  c.summary = "Add a node to the pool."
+  c.description = "#{c.summary} This is just a convenience method, you can also add a node directly to $HOME/.rutty/nodes.yaml"
+  
+  c.example "Add the 'localhost' node with just a keypath", "rutty add_node localhost --keypath ~/.ssh/my_key.pem"
+  c.example "Add a remote IP with all the options", 
+    "rutty add_node 192.168.1.100 --keypath ~/.ssh/my_key.pem --user root --tags local,funtimes,awesome"
+  
+  add_filter_options.call(c)
+  
+  c.when_called do |args, options|
+    check_installed!
+    raise "Must supply a hostname or IP address. See `rutty help add_node' for usage" if args.empty?
+
+    hash = { :host => args.first }
+    hash[:keypath] = options.keypath unless options.keypath.nil?
+    hash[:user] = options.user unless options.user.nil?
+    hash[:port] = options.port unless options.port.nil?
+    hash[:tags] = options.tags unless options.tags.nil?
+    
+    update_node_list { |nodes| nodes << hash }
+  end
+end
+
+command :list_nodes do |c|
+  # TODO: Make tag searching AND or OR, not just OR
+  c.syntax = "rutty list_nodes [options]"
+  c.summary = "List nodes according to [options]."
+  c.description = "#{c.summary} Options are the same as add_node"
+  
+  c.example "List all nodes", "rutty list_nodes"
+  c.example "List all nodes that are tagged with 'web' OR 'db'", "rutty list_nodes --tags web,db"
+  c.example "List all nodes configued to SSH into port 2222", "rutty list_nodes --port 2222"
+  
+  add_filter_options.call(c)
+  
+  c.when_called do |args, options|
+    check_installed!    
+    require 'pp'
+    
+    nodes = get_node_list
+    filter_nodes nodes, options
+
+    pp nodes
+  end
+end
+
+command :dsh do |c|
+  c.syntax = "rutty [dsh] [options] COMMAND"
+  c.summary = "Runs the specified COMMAND across all nodes that match [options]"
+  
+  c.example "Get a list of all users logged in to all your web and app nodes", "rutty --tags web,app w"
+  c.example "See all your nodes' current memory footprint", "rutty -a \"free -m\""
+  
+  c.option('--tags TAG1[,TAG2,...]', Array, 'Comma-separated list of tags to run the command on')
+  c.option('-a', 'Run the command on ALL nodes')
+  
+  c.when_called do |args, options|
+    # TODO: Clean this up, it's pretty hard to read and follow
+    
+    check_installed!
+    raise "Must supply a command to run. See `rutty help dsh' for usage" if args.empty?
+    raise "One of -a or --tags must be passed" if options.a.nil? and options.tags.nil?
+    raise "Use either -a or --tags, not both" if !options.a.nil? and !options.tags.nil?
+    raise "Multi-word commands must be enclosed in quotes (ex. rutty -a \"ps -ef | grep httpd\")" if args.length > 1
+    
+    com_str = args.pop
+    
+    nodes = get_node_list
+    filter_nodes nodes, options
+    
+    require 'logger'
+    require 'net/ssh'
+    require 'pp'
+    
+    @returns = {}
+    connections = []
+    
+    # This is necessary in order to capture exit codes and/or signals, 
+    # which are't passed through when using just the ssh.exec!() semantics.
+    exec_command = lambda { |ssh| 
+      ssh.open_channel do |channel| 
+        channel.exec(com_str) do |ch, success| 
+          unless success 
+            abort "FAILED: couldn't execute command (ssh.channel.exec   
+            failure)" 
+          end 
+          
+          channel.on_data do |ch, data|  # stdout 
+            @returns[ssh.host][:out] << data
+          end 
+          
+          channel.on_extended_data do |ch, type, data| 
+            next unless type == 1  # only handle stderr 
+            @returns[ssh.host][:out] << data
+          end 
+          
+          channel.on_request("exit-status") do |ch, data| 
+            exit_code = data.read_long 
+            @returns[ssh.host][:exit] = exit_code
+          end 
+          
+          channel.on_request("exit-signal") do |ch, data| 
+            @returns[ssh.host][:sig] = data.read_long
+          end 
+        end 
+      end 
+      ssh.loop
+    }
+    
+    nodes.each do |node|
+      params = options_for_node(node)
+      @returns[node[:host]] = { :out => '' }
+      connections << Net::SSH.start(params[:host], params[:user], :port => params[:port], :paranoid => false, 
+        :user_known_hosts_file => '/dev/null', :keys => [params[:keypath]], :logger => Logger.new($stderr),
+        :verbose => Logger::FATAL)
+    end
+    
+    connections.each { |ssh| exec_command.call(ssh) }
+    
+    loop do
+      connections.delete_if { |ssh| !ssh.process(0.1) { |s| s.busy? } }
+      break if connections.empty?
+    end
+    
+    # TODO: Print this out in a better way
+    # TODO: Print a special alert for exit codes > 0
+    
+    pp @returns
+  end
+end
+
+command :scp do |c|
+  c.syntax = "rutty scp [options] LOCAL_PATH REMOTE_PATH"
+  c.summary = "Uploads a file to the nodes according to [options]."
+  c.description = "#{c.summary} Unlike the actual scp command, this action is one-way: upload only."
+  
+  c.option('--tags TAG1[,TAG2,...]', Array, 'Comma-separated list of tags to run the command on')
+  c.option('-a', 'Run the command on ALL nodes')
+  
+  c.when_called do |args, options|
+    check_installed!
+    raise "Must supply a local path and a remote path" unless args.length == 2
+    raise "One of -a or --tags must be passed" if options.a.nil? and options.tags.nil?
+    raise "Use either -a or --tags, not both" if !options.a.nil? and !options.tags.nil?
+    
+    require 'logger'
+    require 'net/ssh'
+    require 'net/scp'
+    require 'pp'
+    
+    connections = []
+    
+    remote_path = args.pop
+    local_path = args.pop
+    
+    nodes = filter_nodes get_node_list, options
+    
+    nodes.each do |node|
+      params = options_for_node(node)
+      connections << Net::SSH.start(params[:host], params[:user], :port => params[:port], :paranoid => false, 
+        :user_known_hosts_file => '/dev/null', :keys => [params[:keypath]], :logger => Logger.new($stderr),
+        :verbose => Logger::FATAL)
+    end
+    
+    connections.each { |ssh| ssh.scp.upload! local_path, remote_path }
+    
+    loop do
+      connections.delete_if { |ssh| !ssh.process(0.1) { |s| s.busy? } }
+      break if connections.empty?
+    end
+  end
+end

data/rutty.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rutty}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Josh Lindsey"]
+  s.date = %q{2010-10-13}
+  s.default_executable = %q{rutty}
+  s.description = %q{
+      RuTTY is a DSH (distributed / dancer's shell) written in Ruby. It's used to run commands 
+      on multiple remote servers at once, based on a tagging system. Also allows for multiple
+      SCP-style uploads.
+    }
+  s.email = %q{josh@cloudspace.com}
+  s.executables = ["rutty"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bin/rutty",
+     "rutty.gemspec"
+  ]
+  s.homepage = %q{http://github.com/jlindsey/rutty}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A DSH implementation in Ruby}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<commander>, [">= 0"])
+      s.add_runtime_dependency(%q<net-ssh>, [">= 0"])
+      s.add_runtime_dependency(%q<net-scp>, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<commander>, [">= 0"])
+      s.add_dependency(%q<net-ssh>, [">= 0"])
+      s.add_dependency(%q<net-scp>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<commander>, [">= 0"])
+    s.add_dependency(%q<net-ssh>, [">= 0"])
+    s.add_dependency(%q<net-scp>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: rutty
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Josh Lindsey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-13 00:00:00 -04:00
+default_executable: rutty
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: commander
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: "\n      RuTTY is a DSH (distributed / dancer's shell) written in Ruby. It's used to run commands \n      on multiple remote servers at once, based on a tagging system. Also allows for multiple\n      SCP-style uploads.\n    "
+email: josh@cloudspace.com
+executables: 
+- rutty
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/rutty
+- rutty.gemspec
+has_rdoc: true
+homepage: http://github.com/jlindsey/rutty
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.3.7
+signing_key: 
+specification_version: 3
+summary: A DSH implementation in Ruby
+test_files: []
+