rush2 0.7.0

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,124 @@
+# 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, :local_path
+
+  # 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', local_path = nil)
+    @host = host
+    @local_path = local_path
+  end
+
+  def to_s        # :nodoc:
+    host
+  end
+
+  def inspect     # :nodoc:
+    host
+  end
+
+  # Access / on the box.
+  def filesystem
+    if host == 'localhost'
+      Rush::Entry.factory('/', self)
+    else
+      connection.local_path
+    end
+  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 { |ps| Rush::Process.new(ps, self) }
+    )
+  end
+
+  # Guess if method missing then it's command for folder binded to that box.
+  #
+  def method_missing(meth, *args, &block)
+    filesystem.send(meth, *args, &block)
+  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
+    env.map do |key, value|
+      escaped = value.to_s.gsub('"', '\\"').gsub('`', '\\\`')
+      "export #{key}=\"#{escaped}\""
+    end.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, local_path)
+  end
+
+  def ==(other)          # :nodoc:
+    host == other.host
+  end
+end

data/lib/rush/commands.rb

@@ -0,0 +1,76 @@
+# 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)
+    entries.inject(Rush::SearchResults.new(pattern)) do |results, entry|
+      if !entry.dir? and matches = entry.search(pattern)
+        results.add(entry, matches)
+      end
+      results
+    end
+  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.dir? ? 0 : entry.lines.size)
+    end
+  end
+
+  # Invoke vi on one or more files - only works locally.
+  def vi(*args)
+    if self.class == Rush::Dir
+      system "cd #{full_path}; vim"
+    else
+      open_with('vim', *args)
+    end
+  end
+  alias_method :vim, :vi
+
+  # Invoke TextMate on one or more files - only works locally.
+  def mate(*args)
+    open_with('mate', *args)
+  end
+
+  # Open file with xdg-open.
+  # Usage:
+  #   home.locate('mai_failz').open
+  def open(*args)
+    open_with('xdg-open', *args)
+  end
+
+  # Open file with any application you like.
+  # Usage:
+  #   home.locate('timetable').open_with :vim
+  def open_with(app, *args)
+    names = dir? ? '' : entries.map(&:to_s).join(' ')
+    system "cd #{dirname}; #{app.to_s} #{names} #{args.join(' ')}"
+  end
+
+  def output_of(app, *args)
+    names = entries.map(&:to_s).join(' ')
+    `cd #{dirname}; #{app.to_s} #{names} #{args.join(' ')}`
+  end
+end

data/lib/rush/config.rb

@@ -0,0 +1,147 @@
+# 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
+    passwords_file.lines_or_empty.inject({}) do |result, line|
+      user, password = line.split(":", 2)
+      result.merge user => password
+    end
+  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
+    len.times.inject('') { |r| r += chars[rand(chars.length)] }
+  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.merge host => port.to_i
+    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,166 @@
+# 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
+  alias_method :dirname, :full_path
+
+	# Entries contained within this dir - not recursive.
+	def contents
+		find_by_glob('*')
+	end
+
+	# Files contained in this dir only.
+	def files
+		contents.reject(&:dir?)
+	end
+
+	# Other dirs contained in this dir only.
+	def dirs
+		contents.select(&:dir?)
+	end
+
+	# Access subentries with square brackets, e.g. dir['subdir/file']
+	def [](key)
+		key = key.to_s
+    case
+    when key == '**'     then files_flattened
+    when key.match(/\*/) then find_by_glob(key)
+		else find_by_name(key)
+		end
+	end
+	# Slashes work as well, e.g. dir/'subdir/file'
+	alias_method :/, :[]
+
+  def locate(path)
+    located = bash("locate #{path}").split("\n").
+      map { |x| x.dir? ? Rush::Dir.new(x) : Rush::File.new(x) }
+    located.size == 1 ? located.first : located
+  end
+
+  def locate_dir(path)
+    located = bash("locate -r #{path}$").split("\n").
+      map { |x| Dir.new x }
+    located.size == 1 ? located.first : located
+  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.reject(&:dir?)
+	end
+
+	# Recursively contained dirs.
+	def dirs_flattened
+		entries_tree.select(&:dir?)
+	end
+
+	# Given a list of flat filenames, product a list of entries under this dir.
+	# Mostly for internal use.
+	def make_entries(filenames)
+		Array(filenames).
+      map { |fname| Rush::Entry.factory("#{full_path}/#{fname}") }
+	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[-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.reject(&:hidden?)
+	end
+
+	# Contained files that are not hidden.
+	def nonhidden_files
+		files.reject(&:hidden?)
+	end
+
+	# Run a bash command starting in this directory.  Options are the same as Rush::Box#bash.
+	def bash(command, options={})
+		box.bash "cd #{quoted_path} && #{command}", options
+	end
+
+	# Destroy all of the contents of the directory, leaving it fresh and clean.
+	def purge
+		connection.purge full_path
+	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)
+		bash "rake #{args.join(' ')}"
+	end
+
+	# Run git within this dir.
+	def git(*args)
+		bash "git #{args.join(' ')}"
+	end
+
+	include Rush::Commands
+
+	def entries
+		contents
+	end
+end