necktie 0.1.1 → 0.2.0

data/bin/necktie

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
-$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__)), File.expand_path("../rush/lib", File.dirname(__FILE__))
 require "necktie"
 necktie ARGV

data/lib/necktie/rush.rb

@@ -0,0 +1,11 @@
+require "rush"
+include Rush
+
+class Object
+  include Rush
+  Rush.methods(false).each do |method|
+    define_method method do |*args|
+      Rush.__send__ method, *args
+    end
+  end
+end

data/lib/necktie/services.rb

@@ -1,13 +1,33 @@
-def start_service(name)
-  puts " ** Starting service #{name}"
-  system "update-rc.d #{name} defaults" and
-    system "service #{name} start" or
-    fail "failed to start #{name}"
-end
+module Services
+  def self.start(name)
+    puts " ** Starting service #{name}"
+    system "update-rc.d #{name} defaults" and
+      system "service #{name} start" or
+      fail "failed to start #{name}"
+  end
+
+  def self.enable(name)
+    system "update-rc.d #{name} defaults" or "cannot enable #{name}"
+  end
+
+  def self.stop(name)
+    puts " ** Stopping service #{name}"
+    system "service #{name} stop" and
+    system "update-rc.d -f #{name} remove" or
+      fail "failed to stop #{name}"
+  end
+
+  def self.disable(name)
+    system "update-rc.d -f #{name} remove" or fail "cannot disable #{name}"
+  end
+
+  def self.restart(name)
+    puts " ** Stopping service #{name}"
+    system "service #{name} restart" or fail "failed to restart #{name}"
+  end
 
-def stop_service(name)
-  puts " ** Stopping service #{name}"
-  system "service #{name} stop" and
-  system "update-rc.d -f #{name} remove" or
-    fail "failed to shutdown #{name}"
+  def self.status(name)
+    status = File.read("|sudo service --status-all 2>&1")[/^ \[ (.) \]  #{Regexp.escape name}$/,1]
+    stauts == "+" ? true : status == "-" ? false : nil
+  end
 end

data/lib/necktie.rb

@@ -2,7 +2,10 @@ require "fileutils"
 extend FileUtils
 require "necktie/gems"
 require "necktie/services"
-require "necktie/files"
+require "necktie/rush"
+
+puts launch_dir
+exit!
 
 def necktie(args)
   etc = "/etc/necktie"
@@ -35,8 +38,9 @@ def necktie(args)
   Dir.chdir repo do
     executed = File.exist?(etc) ? File.read(etc).split("\n") : []
     roles.each do |role|
-      tasks = Dir["tasks/#{role}/*.rb"].sort.map { |name| File.basename(name).gsub(/(.*)\.rb$/, "#{role}/\\1") }
-      todo = tasks - executed
+      skip = executed.map { |t| t[/^#{Regexp.escape role}\/(.*)$/, 1] }.reject(&:nil?)
+      tasks = Dir["tasks/#{role}/*.rb"].sort.map { |name| File.basename(name).gsub(/\.rb$/, "") }
+      todo = tasks - skip
       if tasks.empty?
         puts "  * No tasks for role #{role}"
       elsif todo.empty?
@@ -45,9 +49,9 @@ def necktie(args)
         puts "  * Now in role: #{role}"
         File.open etc, "a" do |f|
           todo.each do |task|
-            puts " ** Executing #{task.split("/").last}"
-            load "tasks/#{task}.rb"
-            f.puts task
+            puts " ** Executing #{task}"
+            load "tasks/#{role}/#{task}.rb"
+            f.puts task if task[/^\d+_/]
           end
         end
       end

data/necktie.gemspec

@@ -1,12 +1,12 @@
 Gem::Specification.new do |spec|
   spec.name           = "necktie"
-  spec.version        = "0.1.1"
+  spec.version        = "0.2.0"
   spec.author         = "Assaf Arkin"
   spec.email          = "assaf@labnotes.org"
   spec.homepage       = ""
   spec.summary        = "Dress to impress"
   spec.description    = ""
 
-  spec.files          = Dir["{bin,lib}/**/*", "*.{gemspec,rdoc}"]
+  spec.files          = Dir["{bin,lib,rush}/**/*", "*.{gemspec,rdoc}"]
   spec.executable     = "necktie"
 end

data/rush/README.rdoc

@@ -0,0 +1,87 @@
+= 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
+
+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/rush/Rakefile

@@ -0,0 +1,60 @@
+require 'rake'
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "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"
+	s.email = "adam@heroku.com"
+	s.homepage = "http://rush.heroku.com/"
+	s.executables = [ "rush", "rushd" ]
+	s.rubyforge_project = "ruby-shell"
+	s.has_rdoc = true
+
+	s.add_dependency 'session'
+	
+	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
+end
+
+Jeweler::RubyforgeTasks.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/rush/VERSION

@@ -0,0 +1 @@
+0.6.2

data/rush/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/rush/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/rush/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/rush/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/rush/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
+#   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/rush/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.quoted_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.quoted_path }.join(' ')
+		system "mate #{names} #{args.join(' ')}"
+	end
+end