aleksi-rush 0.6.6

data/README.rdoc

@@ -0,0 +1,89 @@
+= rush -- manage your unix systems with pure Ruby
+
+rush is a unix integration library and an interactive shell which uses pure Ruby syntax.  Walk directory trees; create, copy, search, and destroy files; find and kill processes - everything you'd normally do with shell commands, now in the strict and elegant world of Ruby.
+
+== Usage
+
+Count the number of classes in your project using bash:
+
+  find myproj -name \*.rb | xargs grep '^\s*class' | wc -l
+
+In rush, this is:
+
+  myproj['**/*.rb'].search(/^\s*class/).lines.size
+
+Pesky stray mongrels?  In bash:
+
+  kill `ps aux | grep mongrel_rails | grep -v grep | cut -c 10-20`
+
+In rush:
+
+  processes.filter(:cmdline => /mongrel_rails/).kill
+
+== As a library
+
+  require 'rubygems'
+  require 'rush'
+
+  file = Rush['/tmp/myfile']
+  file.write "hello"
+  puts file.contents
+  file.destroy
+
+  puts Rush.my_process.pid
+  puts Rush.processes.size
+  puts Rush.bash("echo SHELL COMMAND | tr A-Z a-z")
+  puts Rush.launch_dir['*.rb'].search(/Rush/).entries.inspect
+
+== Invoking the shell
+
+Run the "rush" binary to enter the interactive shell.
+
+== Remote access and clustering
+
+rush can control any number of remote machines from a single location. Copy files or directories between servers as seamlessly as if it was all local.
+
+Example of remote access:
+
+  local = Rush::Box.new('localhost')
+  remote = Rush::Box.new('my.remote.server.com')
+  local_dir = local['/Users/adam/myproj/']
+  remote_dir = remote['/home/myproj/app/']
+
+  local_dir.copy_to remote_dir
+  remote_dir['**/.svn/'].each { |d| d.destroy }
+
+Clustering:
+
+  local_dir = Rush::Box.new('localhost')['/Users/adam/server_logs/'].create
+  servers = %w(www1 www2 www3).map { |n| Rush::Box.new(n) }
+  servers.each { |s| s['/var/log/nginx/access.log'].copy_to local_dir["#{s.host}_access.log"] }
+
+== Reference
+
+For more details on syntax and commands, see:
+
+* Rush
+* Rush::Entry
+* Rush::File
+* Rush::Dir
+* Rush::Commands
+* Rush::Box
+* Rush::Process
+
+== Meta
+
+Created by Adam Wiggins
+
+Patches contributed by Chihiro Ito, Gabriel Ware, Michael Schutte, Ricardo Chimal Jr., and Nicholas Schlueter, Pedro Belo, and Martin Kuehl
+
+Forked by Aleksey Palazhchenko.
+
+Logo by James Lindenbaum
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://rush.heroku.com
+
+http://groups.google.com/group/ruby-shell
+

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rake'
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "aleksi-rush"
+	s.summary = "A Ruby replacement for bash+ssh."
+	s.description = "A Ruby replacement for bash+ssh, providing both an interactive shell and a library.  Manage both local and remote unix systems from a single client."
+	s.author = "Adam Wiggins, Aleksey Palazhchenko"
+	s.email = "aleksey.palazhchenko@gmail.com"
+	s.homepage = "http://github.com/AlekSi/rush"
+	s.executables = [ "rush", "rushd" ]
+	s.has_rdoc = true
+
+	s.add_dependency 'session'
+	
+	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
+end
+
+Jeweler::GemcutterTasks.new
+
+######################################################
+
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = true
+	t.rcov_opts = ['--exclude', 'examples']
+end
+
+task :default => :spec
+
+######################################################
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'rdoc'
+	t.title    = "rush, a Ruby replacement for bash+ssh"
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('lib/rush.rb')
+	t.rdoc_files.include('lib/rush/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.6.6

data/bin/rush

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/rush'
+require File.dirname(__FILE__) + '/../lib/rush/shell'
+
+shell = Rush::Shell.new
+
+if ARGV.size > 0
+	shell.execute ARGV.join(' ')
+else
+	shell.run
+end
+

data/bin/rushd

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/rush'
+require File.dirname(__FILE__) + '/../lib/rush/server'
+
+RushServer.new.run
+

data/lib/rush.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+
+# The top-level Rush module has some convenience methods for accessing the
+# local box.
+module Rush
+	# Access the root filesystem of the local box.  Example:
+	#
+	#   Rush['/etc/hosts'].contents
+	#
+	def self.[](key)
+		box[key]
+	end
+
+	# Create a dir object from the path of a provided file.  Example:
+	#
+	#   Rush.dir(__FILE__).files
+	#
+	def self.dir(filename)
+		box[::File.expand_path(::File.dirname(filename)) + '/']
+	end
+
+	# Create a dir object based on the shell's current working directory at the
+	# time the program was run.  Example:
+	#
+	#   Rush.launch_dir.files
+	#
+	def self.launch_dir
+		box[::Dir.pwd + '/']
+	end
+
+	# Run a bash command in the root of the local machine.  Equivalent to
+	# Rush::Box.new.bash.
+	def self.bash(command, options={})
+		box.bash(command, options)
+	end
+
+	# Pull the process list for the local machine.  Example:
+   #
+   #   Rush.processes.filter(:cmdline => /ruby/)
+	#
+	def self.processes
+		box.processes
+	end
+
+	# Get the process object for this program's PID.  Example:
+   #
+   #   puts "I'm using #{Rush.my_process.mem} blocks of memory"
+	#
+	def self.my_process
+		box.processes.filter(:pid => ::Process.pid).first
+	end
+
+	# Create a box object for localhost.
+	def self.box
+		@@box = Rush::Box.new
+	end
+
+	# Quote a path for use in backticks, say.
+	def self.quote(path)
+		path.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
+	end
+end
+
+module Rush::Connection; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rush/exceptions'
+require 'rush/config'
+require 'rush/commands'
+require 'rush/access'
+require 'rush/entry'
+require 'rush/file'
+require 'rush/dir'
+require 'rush/search_results'
+require 'rush/head_tail'
+require 'rush/find_by'
+require 'rush/string_ext'
+require 'rush/fixnum_ext'
+require 'rush/array_ext'
+require 'rush/process'
+require 'rush/process_set'
+require 'rush/local'
+require 'rush/remote'
+require 'rush/ssh_tunnel'
+require 'rush/box'
+require 'rush/embeddable_shell'

data/lib/rush/access.rb

@@ -0,0 +1,130 @@
+# A class to hold permissions (read, write, execute) for files and dirs.
+# See Rush::Entry#access= for information on the public-facing interface.
+class Rush::Access
+	attr_accessor :user_can_read, :user_can_write, :user_can_execute
+	attr_accessor :group_can_read, :group_can_write, :group_can_execute
+	attr_accessor :other_can_read, :other_can_write, :other_can_execute
+
+	def self.roles
+		%w(user group other)
+	end
+
+	def self.permissions
+		%w(read write execute)
+	end
+
+	def parse(options)
+		options.each do |key, value|
+			next unless m = key.to_s.match(/(.*)_can$/)
+			key = m[1].to_sym
+			roles = extract_list('role', key, self.class.roles)
+			perms = extract_list('permission', value, self.class.permissions)
+			set_matrix(perms, roles)
+		end
+		self
+	end
+
+	def self.parse(options)
+		new.parse(options)
+	end
+
+	def apply(full_path)
+		FileUtils.chmod(octal_permissions, full_path)
+	rescue Errno::ENOENT
+		raise Rush::DoesNotExist, full_path
+	end
+
+	def to_hash
+		hash = {}
+		self.class.roles.each do |role|
+			self.class.permissions.each do |perm|
+				key = "#{role}_can_#{perm}".to_sym
+				hash[key] = send(key) ? 1 : 0
+			end
+		end
+		hash
+	end
+
+	def display_hash
+		hash = {}
+		to_hash.each do |key, value|
+			hash[key] = true if value == 1
+		end
+		hash
+	end
+
+	def from_hash(hash)
+		self.class.roles.each do |role|
+			self.class.permissions.each do |perm|
+				key = "#{role}_can_#{perm}"
+				send("#{key}=".to_sym, hash[key.to_sym].to_i == 1 ? true : false)
+			end
+		end
+		self
+	end
+
+	def self.from_hash(hash)
+		new.from_hash(hash)
+	end
+
+	def octal_permissions
+		perms = [ 0, 0, 0 ]
+		perms[0] += 4 if user_can_read
+		perms[0] += 2 if user_can_write
+		perms[0] += 1 if user_can_execute
+		
+		perms[1] += 4 if group_can_read
+		perms[1] += 2 if group_can_write
+		perms[1] += 1 if group_can_execute
+
+		perms[2] += 4 if other_can_read
+		perms[2] += 2 if other_can_write
+		perms[2] += 1 if other_can_execute
+
+		eval("0" + perms.join)
+	end
+
+	def from_octal(mode)
+		perms = octal_integer_array(mode)
+
+		self.user_can_read = (perms[0] & 4) > 0 ? true : false
+		self.user_can_write = (perms[0] & 2) > 0 ? true : false
+		self.user_can_execute = (perms[0] & 1) > 0 ? true : false
+	
+		self.group_can_read = (perms[1] & 4) > 0 ? true : false
+		self.group_can_write = (perms[1] & 2) > 0 ? true : false
+		self.group_can_execute = (perms[1] & 1) > 0 ? true : false
+
+		self.other_can_read = (perms[2] & 4) > 0 ? true : false
+		self.other_can_write = (perms[2] & 2) > 0 ? true : false
+		self.other_can_execute = (perms[2] & 1) > 0 ? true : false
+
+		self
+	end
+
+	def octal_integer_array(mode)
+		mode %= 01000                      # filter out everything but the bottom three digits
+		mode = sprintf("%o", mode)         # convert to string
+		mode.split("").map { |p| p.to_i }  # and finally, array of integers
+	end
+
+	def set_matrix(perms, roles)
+		perms.each do |perm|
+			roles.each do |role|
+				meth = "#{role}_can_#{perm}=".to_sym
+				send(meth, true)
+			end
+		end
+	end
+
+	def extract_list(type, value, choices)
+		list = parts_from(value)
+		list.each do |value|
+			raise(Rush::BadAccessSpecifier, "Unrecognized #{type}: #{value}") unless choices.include? value
+		end
+	end
+
+	def parts_from(value)
+		value.to_s.split('_').reject { |r| r == 'and' }
+	end
+end

data/lib/rush/array_ext.rb

@@ -0,0 +1,19 @@
+# Rush mixes in Rush::Commands in order to allow operations on groups of
+# Rush::Entry items.  For example, dir['**/*.rb'] returns an array of files, so
+# dir['**/*.rb'].destroy would destroy all the files specified.
+#
+# One cool tidbit: the array can contain entries anywhere, so you can create
+# collections of entries from different servers and then operate across them:
+#
+#   [ box1['/var/log/access.log'] + box2['/var/log/access.log'] ].search /#{url}/
+class Array
+	include Rush::Commands
+
+	def entries
+		self
+	end
+
+	include Rush::FindBy
+
+	include Rush::HeadTail
+end

data/lib/rush/box.rb

@@ -0,0 +1,115 @@
+# A rush box is a single unix machine - a server, workstation, or VPS instance.
+#
+# Specify a box by hostname (default = 'localhost').  If the box is remote, the
+# first action performed will attempt to open an ssh tunnel.  Use square
+# brackets to access the filesystem, or processes to access the process list.
+#
+# Example:
+#
+#   local = Rush::Box.new
+#   local['/etc/hosts'].contents
+#   local.processes
+#
+class Rush::Box
+	attr_reader :host
+
+	# Instantiate a box.  No action is taken to make a connection until you try
+	# to perform an action.  If the box is remote, an ssh tunnel will be opened.
+	# Specify a username with the host if the remote ssh user is different from
+	# the local one (e.g. Rush::Box.new('user@host')).
+	def initialize(host='localhost')
+		@host = host
+	end
+
+	def to_s        # :nodoc:
+		host
+	end
+
+	def inspect     # :nodoc:
+		host
+	end
+
+	# Access / on the box.
+	def filesystem
+		Rush::Entry.factory('/', self)
+	end
+
+	# Look up an entry on the filesystem, e.g. box['/path/to/some/file'].
+	# Returns a subclass of Rush::Entry - either Rush::Dir if you specifiy
+	# trailing slash, or Rush::File otherwise.
+	def [](key)
+		filesystem[key]
+	end
+
+	# Get the list of processes running on the box, not unlike "ps aux" in bash.
+	# Returns a Rush::ProcessSet.
+	def processes
+		Rush::ProcessSet.new(
+			connection.processes.map do |ps|
+				Rush::Process.new(ps, self)
+			end
+		)
+	end
+
+	# Execute a command in the standard unix shell.  Returns the contents of
+	# stdout if successful, or raises Rush::BashFailed with the output of stderr
+	# if the shell returned a non-zero value.  Options:
+	#
+	# :user => unix username to become via sudo
+	# :env => hash of environment variables
+	# :background => run in the background (returns Rush::Process instead of stdout)
+	#
+	# Examples:
+	#
+	#   box.bash '/etc/init.d/mysql restart', :user => 'root'
+	#   box.bash 'rake db:migrate', :user => 'www', :env => { :RAILS_ENV => 'production' }
+	#   box.bash 'mongrel_rails start', :background => true
+	#   box.bash 'rake db:migrate', :user => 'www', :env => { :RAILS_ENV => 'production' }, :reset_environment => true
+	#
+	def bash(command, options={})
+		cmd_with_env = command_with_environment(command, options[:env])
+		options[:reset_environment] ||= false
+
+		if options[:background]
+			pid = connection.bash(cmd_with_env, options[:user], true, options[:reset_environment])
+			processes.find_by_pid(pid)
+		else
+			connection.bash(cmd_with_env, options[:user], false, options[:reset_environment])
+		end
+	end
+
+	def command_with_environment(command, env)   # :nodoc:
+		return command unless env
+
+		vars = env.sort_by{ |key, value| key.to_s }.map do |key, value|
+			escaped = value.to_s.gsub('"', '\\"').gsub('`', '\\\`')
+			"export #{key}=\"#{escaped}\""
+		end
+		vars.push(command).join("\n")
+	end
+
+	# Returns true if the box is responding to commands.
+	def alive?
+		connection.alive?
+	end
+
+	# This is called automatically the first time an action is invoked, but you
+	# may wish to call it manually ahead of time in order to have the tunnel
+	# already set up and running.  You can also use this to pass a timeout option,
+	# either :timeout => (seconds) or :timeout => :infinite.
+	def establish_connection(options={})
+		connection.ensure_tunnel(options)
+	end
+
+	def connection         # :nodoc:
+		@connection ||= make_connection
+	end
+
+	def make_connection    # :nodoc:
+		host == 'localhost' ? Rush::Connection::Local.new : Rush::Connection::Remote.new(host)
+	end
+
+	def ==(other)          # :nodoc:
+		host == other.host
+	end
+end