rush 0.1

data/Rakefile

@@ -0,0 +1,86 @@
+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
+
+version = "0.1"
+name = "rush"
+
+spec = Gem::Specification.new do |s|
+	s.name = name
+	s.version = version
+	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"
+	s.email = "adam@heroku.com"
+	s.homepage = "http://rush.heroku.com/"
+	s.executables = [ "rush", "rushd" ]
+	s.rubyforge_project = "ruby-shell"
+
+	s.platform = Gem::Platform::RUBY
+	s.has_rdoc = true
+	
+	s.files = %w(Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+	
+	s.require_path = "lib"
+	s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :install => [ :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{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,6 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/rush'
+require 'shell'
+Rush::Shell.new.run
+

data/bin/rushd

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

data/lib/rush.rb

@@ -0,0 +1,20 @@
+module Rush; end
+module Rush::Connection; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/rush')
+
+require 'config'
+require 'commands'
+require 'entry'
+require 'file'
+require 'dir'
+require 'search_results'
+require 'head_tail'
+require 'string_ext'
+require 'fixnum_ext'
+require 'array_ext'
+require 'process'
+require 'local'
+require 'remote'
+require 'ssh_tunnel'
+require 'box'

data/lib/rush/array_ext.rb

@@ -0,0 +1,17 @@
+# 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::HeadTail
+end

data/lib/rush/box.rb

@@ -0,0 +1,63 @@
+# 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 currently running on the box.  Returns an array
+	# of Rush::Process.
+	def processes
+		connection.processes.map do |ps|
+			Rush::Process.new(ps, self)
+		end
+	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

data/lib/rush/dir.rb

@@ -0,0 +1,148 @@
+# A dir is a subclass of Rush::Entry that contains other entries.  Also known
+# as a directory or a folder.
+#
+# Dirs can be operated on with Rush::Commands the same as an array of files.
+# They also offer a square bracket accessor which can use globbing to get a
+# list of files.
+#
+# Example:
+#
+#   dir = box['/home/adam/']
+#   dir['**/*.rb'].line_count
+#
+# In the interactive shell, dir.ls is a useful command.
+class Rush::Dir < Rush::Entry
+	def dir?
+		true
+	end
+
+	def full_path
+		"#{super}/"
+	end
+
+	# Entries contained within this dir - not recursive.
+	def contents
+		find_by_glob('*')
+	end
+
+	# Files contained in this dir only.
+	def files
+		contents.select { |entry| !entry.dir? }
+	end
+
+	# Other dirs contained in this dir only.
+	def dirs
+		contents.select { |entry| entry.dir? }
+	end
+
+	# Access subentries with square brackets, e.g. dir['subdir/file'] 
+	def [](key)
+		key = key.to_s
+		if key == '**'
+			files_flattened
+		elsif key.match(/\*/)
+			find_by_glob(key)
+		else
+			find_by_name(key)
+		end
+	end
+
+	def find_by_name(name)    # :nodoc:
+		Rush::Entry.factory("#{full_path}/#{name}", box)
+	end
+
+	def find_by_glob(glob)    # :nodoc:
+		connection.index(full_path, glob).map do |fname|
+			Rush::Entry.factory("#{full_path}/#{fname}", box)
+		end
+	end
+
+	# A list of all the recursively contained entries in flat form.
+	def entries_tree
+		find_by_glob('**/*')
+	end
+
+	# Recursively contained files.
+	def files_flattened
+		entries_tree.select { |e| !e.dir? }
+	end
+
+	# Recursively contained dirs.
+	def dirs_flattened
+		entries_tree.select { |e| e.dir? }
+	end
+
+	# Given a list of flat filenames, product a list of entries under this dir.
+	# Mostly for internal use.
+	def make_entries(filenames)
+		filenames.map do |fname|
+			Rush::Entry.factory("#{full_path}/#{fname}")
+		end
+	end
+
+	# Create a blank file within this dir.
+	def create_file(name)
+		file = self[name].create
+		file.write('')
+		file
+	end
+
+	# Create an empty subdir within this dir.
+	def create_dir(name)
+		name += '/' unless name.tail(1) == '/'
+		self[name].create
+	end
+
+	# Create an instantiated but not yet filesystem-created dir.
+	def create
+		connection.create_dir(full_path)
+		self
+	end
+
+	# Get the total disk usage of the dir and all its contents.
+	def size
+		connection.size(full_path)
+	end
+
+	# Contained dirs that are not hidden.
+	def nonhidden_dirs
+		dirs.select do |dir|
+			!dir.hidden?
+		end
+	end
+
+	# Contained files that are not hidden.
+	def nonhidden_files
+		files.select do |file|
+			!file.hidden?
+		end
+	end
+
+	# Text output of dir listing, equivalent to the regular unix shell's ls command.
+	def ls
+		out = [ "#{self}" ]
+		nonhidden_dirs.each do |dir|
+			out << "  #{dir.name}+"
+		end
+		nonhidden_files.each do |file|
+			out << "  #{file.name}"
+		end
+		out.join("\n")
+	end
+
+	# Run rake within this dir.
+	def rake(*args)
+		system "cd #{full_path}; rake #{args.join(' ')}"
+	end
+
+	# Run git within this dir.
+	def git(*args)
+		system "cd #{full_path}; git #{args.join(' ')}"
+	end
+
+	include Rush::Commands
+
+	def entries
+		contents
+	end
+end