rush 0.1

data/lib/rush/entry.rb

@@ -0,0 +1,141 @@
+# Rush::Entry is the base class for Rush::File and Rush::Dir.  One or more of
+# these is instantiated whenever you use square brackets to access the
+# filesystem on a box, as well as any other operation that returns an entry or
+# list of entries.
+class Rush::Entry
+	attr_reader :box, :name, :path
+
+	# Initialize with full path to the file or dir, and the box it resides on.
+	def initialize(full_path, box=nil)
+		full_path = ::File.expand_path(full_path, '/')
+		@path = ::File.dirname(full_path)
+		@name = ::File.basename(full_path)
+		@box = box || Rush::Box.new('localhost')
+	end
+
+	# The factory checks to see if the full path has a trailing slash for
+	# creating a Rush::Dir rather than the default Rush::File.
+	def self.factory(full_path, box=nil)
+		if full_path.tail(1) == '/'
+			Rush::Dir.new(full_path, box)
+		else
+			Rush::File.new(full_path, box)
+		end
+	end
+
+	def to_s      # :nodoc:
+		if box.host == 'localhost'
+			"#{full_path}"
+		else
+			inspect
+		end
+	end
+
+	def inspect   # :nodoc:
+		"#{box}:#{full_path}"
+	end
+
+	def connection
+		box ? box.connection : Rush::Connection::Local.new
+	end
+
+	# The parent dir.  For example, box['/etc/hosts'].parent == box['etc/']
+	def parent
+		@parent ||= Rush::Dir.new(@path)
+	end
+
+	def full_path
+		"#{@path}/#{@name}"
+	end
+
+	# Timestamp of entry creation.
+	def created_at
+		stat[:ctime]
+	end
+
+	# Timestamp that entry was last modified on.
+	def last_modified
+		stat[:mtime]
+	end
+
+	# Timestamp that entry was last accessed on.
+	def last_accessed
+		stat[:atime]
+	end
+
+	# Attempts to rename, copy, or otherwise place an entry into a dir that already contains an entry by that name will fail with this exception.
+	class NameAlreadyExists < Exception; end
+
+	# Do not use rename or duplicate with a slash; use copy_to or move_to instead.
+	class NameCannotContainSlash < Exception; end
+
+	# You cannot move or copy entries to a path that is not a dir.
+	class NotADir < Exception; end
+
+	# Rename an entry to another name within the same dir.  The object's name
+	# will be updated to match the change on the filesystem.
+	def rename(new_name)
+		connection.rename(@path, @name, new_name)
+		@name = new_name
+	end
+
+	# Rename an entry to another name within the same dir.  The existing object
+	# will not be affected, but a new object representing the newly-created
+	# entry will be returned.
+	def duplicate(new_name)
+		raise NameCannotContainSlash if new_name.match(/\//)
+		new_full_path = "#{@path}/#{new_name}"
+		connection.copy(full_path, new_full_path)
+		self.class.new(new_full_path, box)
+	end
+
+	# Copy the entry to another dir.  Returns an object representing the new
+	# copy.
+	def copy_to(dir)
+		raise NotADir unless dir.class == Rush::Dir
+
+		if box == dir.box
+			connection.copy(full_path, dir.full_path)
+		else
+			archive = connection.read_archive(full_path)
+			dir.box.connection.write_archive(archive, dir.full_path)
+		end
+
+		new_full_path = "#{dir.full_path}#{name}"
+		self.class.new(new_full_path, dir.box)
+	end
+
+	# Move the entry to another dir.  The object will be updated to show its new
+	# location.
+	def move_to(dir)
+		moved = copy_to(dir)
+		destroy
+		mimic(moved)
+	end
+
+	def mimic(from)      # :nodoc:
+		@box = from.box
+		@path = from.path
+		@name = from.name
+	end
+
+	# Unix convention considers entries starting with a . to be hidden.
+	def hidden?
+		name.slice(0, 1) == '.'
+	end
+
+	# Destroy the entry.  If it is a dir, everything inside it will also be destroyed.
+	def destroy
+		connection.destroy(full_path)
+	end
+
+	def ==(other)       # :nodoc:
+		full_path == other.full_path and box == other.box
+	end
+
+private
+
+	def stat
+		connection.stat(full_path)
+	end
+end

data/lib/rush/file.rb

@@ -0,0 +1,73 @@
+# Files are a subclass of Rush::Entry.  Most of the file-specific operations
+# relate to manipulating the file's contents, like search and replace.
+class Rush::File < Rush::Entry
+	def dir?
+		false
+	end
+
+	# Create a blank file.
+	def create
+		write('')
+		self
+	end
+
+	# Size in bytes on disk.
+	def size
+		stat[:size]
+	end
+
+	# Raw contents of the file.  For non-text files, you probably want to avoid
+	# printing this on the screen.
+	def contents
+		connection.file_contents(full_path)
+	end
+
+	# Write to the file, overwriting whatever was already in it.
+	#
+	# Example: file.write "hello, world\n"
+	def write(new_contents)
+		connection.write_file(full_path, new_contents)
+	end
+
+	# Return an array of lines from the file, similar to stdlib's File#readlines.
+	def lines
+		contents.split("\n")
+	end
+
+	# Search the file's for a regular expression.  Returns nil if no match, or
+	# each of the matching lines in its entirety.
+	#
+	# Example: box['/etc/hosts'].search(/localhost/) # -> [ "127.0.0.1 localhost\n", "::1 localhost\n" ]
+	def search(pattern)
+		matching_lines = lines.select { |line| line.match(pattern) }
+		matching_lines.size == 0 ? nil : matching_lines
+	end
+
+	# Search-and-replace file contents.
+	#
+	# Example: box['/etc/hosts'].replace_contents!(/localhost/, 'local.host')
+	def replace_contents!(pattern, replace_with)
+		write contents.gsub(pattern, replace_with)
+	end
+
+	# Return the file's contents, or if it doesn't exist, a blank string.
+	def contents_or_blank
+		contents rescue ""
+	end
+
+	# Count the number of lines in the file.
+	def line_count
+		lines.size
+	end
+
+	# Return an array of lines, or an empty array if the file does not exist.
+	def lines_or_empty
+		lines rescue []
+	end
+
+	include Rush::Commands
+
+	def entries
+		[ self ]
+	end
+end

data/lib/rush/fixnum_ext.rb

@@ -0,0 +1,18 @@
+# Integer extensions for file and dir sizes (returned in bytes).
+#
+# Example:
+#
+# box['/assets/'].files_flattened.select { |f| f.size > 10.mb }
+class Fixnum
+	def kb
+		self * 1024
+	end
+
+	def mb
+		kb * 1024
+	end
+
+	def gb
+		mb * 1024
+	end
+end

data/lib/rush/head_tail.rb

@@ -0,0 +1,11 @@
+# Mixin for array and string for methods I wish they had.
+module Rush::HeadTail
+	def head(n)
+		slice(0, n)
+	end
+
+	def tail(n)
+		n = [ n, length ].min
+		slice(-n, n)
+	end
+end

data/lib/rush/local.rb

@@ -0,0 +1,224 @@
+require 'fileutils'
+require 'yaml'
+
+# Rush::Box uses a connection object to execute all rush commands.  If the box
+# is local, Rush::Connection::Local is created.  The local connection is the
+# heart of rush's internals.  (Users of the rush shell or library need never
+# access the connection object directly, so the docs herein are intended for
+# developers wishing to modify rush.)
+#
+# The local connection has a series of methods which do the actual work of
+# modifying files, getting process lists, and so on.  RushServer creates a
+# local connection to handle incoming requests; the translation from a raw hash
+# of parameters to an executed method is handled by
+# Rush::Connection::Local#receive.
+class Rush::Connection::Local
+	# Write raw bytes to a file.
+	def write_file(full_path, contents)
+		::File.open(full_path, 'w') do |f|
+			f.write contents
+		end
+		true
+	end
+
+	# Read raw bytes from a file.
+	def file_contents(full_path)
+		::File.read(full_path)
+	end
+
+	# Destroy a file or dir.
+	def destroy(full_path)
+		raise "No." if full_path == '/'
+		FileUtils.rm_rf(full_path)
+		true
+	end
+
+	# Create a dir.
+	def create_dir(full_path)
+		FileUtils.mkdir_p(full_path)
+		true
+	end
+
+	class NameAlreadyExists < Exception; end
+	class NameCannotContainSlash < Exception; end
+	class NotADir < Exception; end
+
+	# Rename an entry within a dir.
+	def rename(path, name, new_name)
+		raise NameCannotContainSlash if new_name.match(/\//)
+		old_full_path = "#{path}/#{name}"
+		new_full_path = "#{path}/#{new_name}"
+		raise NameAlreadyExists if ::File.exists?(new_full_path)
+		FileUtils.mv(old_full_path, new_full_path)
+		true
+	end
+
+	# Copy ane entry from one path to another.
+	def copy(src, dst)
+		FileUtils.cp_r(src, dst)
+		true
+	end
+
+	# Create an in-memory archive (tgz) of a file or dir, which can be
+	# transmitted to another server for a copy or move.  Note that archive
+	# operations have the dir name implicit in the archive.
+	def read_archive(full_path)
+		`cd #{::File.dirname(full_path)}; tar c #{::File.basename(full_path)}`
+	end
+
+	# Extract an in-memory archive to a dir.
+	def write_archive(archive, dir)
+		IO.popen("cd #{dir}; tar x", "w") do |p|
+			p.write archive
+		end
+	end
+
+	# Get an index of files from the given path with the glob.  Could return
+	# nested values if the glob contains a doubleglob.  The return value is an
+	# array of full paths, with directories listed first.
+	def index(base_path, glob)
+		glob = '*' if glob == '' or glob.nil?
+		dirs = []
+		files = []
+		::Dir.chdir(base_path) do
+			::Dir.glob(glob).each do |fname|
+				if ::File.directory?(fname)
+					dirs << fname + '/'
+				else
+					files << fname
+				end
+			end
+		end
+		dirs + files
+	end
+
+	# Fetch stats (size, ctime, etc) on an entry.  Size will not be accurate for dirs.
+	def stat(full_path)
+		s = ::File.stat(full_path)
+		{
+			:size => s.size,
+			:ctime => s.ctime,
+			:atime => s.atime,
+			:mtime => s.mtime,
+		}
+	end
+
+	# Fetch the size of a dir, since a standard file stat does not include the
+	# size of the contents.
+	def size(full_path)
+		`du -sb #{full_path}`.match(/(\d+)/)[1].to_i
+	end
+
+	# Get the list of processes as an array of hashes.
+	def processes
+		if ::File.directory? "/proc"
+			linux_processes
+		else
+			os_x_processes
+		end
+	end
+
+	# Process list on Linux using /proc.
+	def linux_processes
+		list = []
+		::Dir["/proc/*/stat"].select { |file| file =~ /\/proc\/\d+\// }.each do |file|
+			begin
+				list << read_proc_file(file)
+			rescue
+				# process died between the dir listing and accessing the file
+			end
+		end
+		list
+	end
+
+	# Read a single file in /proc and store the parsed values in a hash suitable
+	# for use in the Rush::Process#new.
+	def read_proc_file(file)
+		data = ::File.read(file).split(" ")
+		uid = ::File.stat(file).uid
+		pid = data[0]
+		command = data[1].match(/^\((.*)\)$/)[1]
+		cmdline = ::File.read("/proc/#{pid}/cmdline").gsub(/\0/, ' ')
+		utime = data[13].to_i
+		ktime = data[14].to_i
+		vss = data[22].to_i / 1024
+		rss = data[23].to_i * 4
+		time = utime + ktime
+
+		{
+			:pid => pid,
+			:uid => uid,
+			:command => command,
+			:cmdline => cmdline,
+			:mem => rss,
+			:cpu => time,
+		}
+	end
+
+	# Process list on OS X or other unixes without a /proc.
+	def os_x_processes
+		raw = os_x_raw_ps.split("\n").slice(1, 99999)
+		raw.map do |line|
+			parse_ps(line)
+		end
+	end
+
+	# ps command used to generate list of processes on non-/proc unixes.
+	def os_x_raw_ps
+		`COLUMNS=9999 ps ax -o "pid uid rss cpu command"`
+	end
+
+	# Parse a single line of the ps command and return the values in a hash
+	# suitable for use in the Rush::Process#new.
+	def parse_ps(line)
+		m = line.split(" ", 5)
+		params = {}
+		params[:pid] = m[0]
+		params[:uid] = m[1]
+		params[:rss] = m[2]
+		params[:cpu] = m[3]
+		params[:cmdline] = m[4]
+		params[:command] = params[:cmdline].split(" ").first
+		params
+	end
+
+	# Returns true if the specified pid is running.
+	def process_alive(pid)
+		`ps -p #{pid} | wc -l`.to_i >= 2
+	end
+
+	# Terminate a process, by pid.
+	def kill_process(pid)
+		::Process.kill('TERM', pid.to_i)
+	end
+
+	####################################
+
+	# Raised when the action passed in by RushServer is not known.
+	class UnknownAction < Exception; end
+
+	# RushServer uses this method to transform a hash (:action plus parameters
+	# specific to that action type) into a method call on the connection.  The
+	# returned value must be text so that it can be transmitted across the wire
+	# as an HTTP response.
+	def receive(params)
+		case params[:action]
+			when 'write_file'     then write_file(params[:full_path], params[:payload])
+			when 'file_contents'  then file_contents(params[:full_path])
+			when 'destroy'        then destroy(params[:full_path])
+			when 'create_dir'     then create_dir(params[:full_path])
+			when 'rename'         then rename(params[:path], params[:name], params[:new_name])
+			when 'copy'           then copy(params[:src], params[:dst])
+			when 'read_archive'   then read_archive(params[:full_path])
+			when 'write_archive'  then write_archive(params[:payload], params[:dir])
+			when 'index'          then index(params[:base_path], params[:glob]).join("\n") + "\n"
+			when 'stat'           then YAML.dump(stat(params[:full_path]))
+			when 'size'           then size(params[:full_path])
+			when 'processes'      then YAML.dump(processes)
+			when 'process_alive'  then process_alive(params[:pid]) ? '1' : '0'
+			when 'kill_process'   then kill_process(params[:pid])
+		else
+			raise UnknownAction
+		end
+	end
+end