dysinger-rush 0.4

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rake'
+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'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+
+spec = eval(IO.read('rush.gemspec'))
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :install => [ :package ] do
+	sh %{sudo gem install pkg/#{spec.name}-#{spec.version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{spec.name}}
+end
+
+Rake::TestTask.new do |t|
+	t.libs << "spec"
+	t.test_files = FileList['spec/*_spec.rb']
+	t.verbose = true
+end
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	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')
+	t.rdoc_files.include('lib/rush.rb')
+	t.rdoc_files.include('lib/rush/*.rb')
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config' ]
+

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,27 @@
+require 'rubygems'
+
+module Rush; 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,112 @@
+# 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('localhost')
+#   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
+	#
+	def bash(command, options={})
+		cmd_with_env = command_with_environment(command, options[:env])
+
+		if options[:background]
+			pid = connection.bash(cmd_with_env, options[:user], true)
+			processes.find_by_pid(pid)
+		else
+			connection.bash(cmd_with_env, options[:user], false)
+		end
+	end
+
+	def command_with_environment(command, env)   # :nodoc:
+		return command unless env
+
+		vars = env.map do |key, value|
+			"export #{key}='#{value}'"
+		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

data/lib/rush/commands.rb

@@ -0,0 +1,55 @@
+# The commands module contains operations against Rush::File entries, and is
+# mixed in to Rush::Entry and Array.  This means you can run these commands against a single
+# file, a dir full of files, or an arbitrary list of files.
+#
+# Examples:
+#
+#   box['/etc/hosts'].search /localhost/       # single file
+#   box['/etc/'].search /localhost/            # entire directory
+#   box['/etc/**/*.conf'].search /localhost/   # arbitrary list
+module Rush::Commands
+	# The entries command must return an array of Rush::Entry items.  This
+	# varies by class that it is mixed in to.
+	def entries
+		raise "must define me in class mixed in to for command use"
+	end
+
+	# Search file contents for a regular expression.  A Rush::SearchResults
+	# object is returned.
+	def search(pattern)
+		results = Rush::SearchResults.new(pattern)
+		entries.each do |entry|
+			if !entry.dir? and matches = entry.search(pattern)
+				results.add(entry, matches)
+			end
+		end
+		results
+	end
+
+	# Search and replace file contents.
+	def replace_contents!(pattern, with_text)
+		entries.each do |entry|
+			entry.replace_contents!(pattern, with_text) unless entry.dir?
+		end
+	end
+
+	# Count the number of lines in the contained files.
+	def line_count
+		entries.inject(0) do |count, entry|
+			count += entry.lines.size if !entry.dir?
+			count
+		end
+	end
+
+	# Invoke vi on one or more files - only works locally.
+	def vi(*args)
+		names = entries.map { |f| f.full_path }.join(' ')
+		system "vim #{names} #{args.join(' ')}"
+	end
+
+	# Invoke TextMate on one or more files - only works locally.
+	def mate(*args)
+		names = entries.map { |f| f.full_path }.join(' ')
+		system "mate #{names} #{args.join(' ')}"
+	end
+end

data/lib/rush/config.rb

@@ -0,0 +1,154 @@
+# The config class accesses files in ~/.rush to load and save user preferences.
+class Rush::Config
+	DefaultPort = 7770
+
+	attr_reader :dir
+
+	# By default, reads from the dir ~/.rush, but an optional parameter allows
+	# using another location.
+	def initialize(location=nil)
+		@dir = Rush::Dir.new(location || "#{ENV['HOME']}/.rush")
+		@dir.create
+	end
+
+	# History is a flat file of past commands in the interactive shell,
+	# equivalent to .bash_history.
+	def history_file
+		dir['history']
+	end
+
+	def save_history(array)
+		history_file.write(array.join("\n") + "\n")
+	end
+
+	def load_history
+		history_file.contents_or_blank.split("\n")
+	end
+
+	# The environment file is executed when the interactive shell starts up.
+	# Put aliases and your own functions here; it is the equivalent of .bashrc
+	# or .profile.
+	#
+	# Example ~/.rush/env.rb:
+	#
+	#   server = Rush::Box.new('www@my.server')
+	#   myproj = home['projects/myproj/']
+	def env_file
+		dir['env.rb']
+	end
+
+	def load_env
+		env_file.contents_or_blank
+	end
+
+	# Commands are mixed in to Array and Rush::Entry, alongside the default
+	# commands from Rush::Commands.  Any methods here should reference "entries"
+	# to get the list of entries to operate on.
+	#
+	# Example ~/.rush/commands.rb:
+	#
+	#   def destroy_svn(*args)
+	#     entries.select { |e| e.name == '.svn' }.destroy
+	#   end
+	def commands_file
+		dir['commands.rb']
+	end
+
+	def load_commands
+		commands_file.contents_or_blank
+	end
+
+	# Passwords contains a list of username:password combinations used for
+	# remote access via rushd.  You can fill this in manually, or let the remote
+	# connection publish it automatically.
+	def passwords_file
+		dir['passwords']
+	end
+
+	def passwords
+		hash = {}
+		passwords_file.lines_or_empty.each do |line|
+			user, password = line.split(":", 2)
+			hash[user] = password
+		end
+		hash
+	end
+
+	# Credentials is the client-side equivalent of passwords.  It contains only
+	# one username:password combination that is transmitted to the server when
+	# connecting.  This is also autogenerated if it does not exist.
+	def credentials_file
+		dir['credentials']
+	end
+
+	def credentials
+		credentials_file.lines.first.split(":", 2)
+	end
+
+	def save_credentials(user, password)
+		credentials_file.write("#{user}:#{password}\n")
+	end
+
+	def credentials_user
+		credentials[0]
+	end
+
+	def credentials_password
+		credentials[1]
+	end
+
+	def ensure_credentials_exist
+		generate_credentials if credentials_file.contents_or_blank == ""
+	end
+
+	def generate_credentials
+		save_credentials(generate_user, generate_password)
+	end
+
+	def generate_user
+		generate_secret(4, 8)
+	end
+
+	def generate_password
+		generate_secret(8, 15)
+	end
+
+	def generate_secret(min, max)
+		chars = self.secret_characters
+		len = rand(max - min + 1) + min
+		password = ""
+		len.times do |index|
+			password += chars[rand(chars.length)]
+		end
+		password
+	end
+
+	def secret_characters
+		[ ('a'..'z'), ('1'..'9') ].inject([]) do |chars, range|
+			chars += range.to_a
+		end
+	end
+
+	# ~/.rush/tunnels contains a list of previously created ssh tunnels.  The
+	# format is host:port, where port is the local port that the tunnel is
+	# listening on.
+	def tunnels_file
+		dir['tunnels']
+	end
+
+	def tunnels
+		tunnels_file.lines_or_empty.inject({}) do |hash, line|
+			host, port = line.split(':', 2)
+			hash[host] = port.to_i
+			hash
+		end
+	end
+
+	def save_tunnels(hash)
+		string = ""
+		hash.each do |host, port|
+			string += "#{host}:#{port}\n"
+		end
+		tunnels_file.write string
+	end
+end