dysinger-rush 0.4

data/lib/rush/ssh_tunnel.rb

@@ -0,0 +1,122 @@
+# Internal class for managing an ssh tunnel, across which relatively insecure
+# HTTP commands can be sent by Rush::Connection::Remote.
+class Rush::SshTunnel
+	def initialize(real_host)
+		@real_host = real_host
+	end
+
+	def host
+		'localhost'
+	end
+
+	def port
+		@port
+	end
+
+	def ensure_tunnel(options={})
+		return if @port and tunnel_alive?
+
+		@port = config.tunnels[@real_host]
+
+		if !@port or !tunnel_alive?
+			setup_everything(options)
+		end
+	end
+
+	def setup_everything(options={})
+		display "Connecting to #{@real_host}..."
+		push_credentials
+		launch_rushd
+		establish_tunnel(options)
+	end
+
+	def push_credentials
+		display "Pushing credentials"
+		config.ensure_credentials_exist
+		ssh_append_to_credentials(config.credentials_file.contents.strip)
+	end
+
+	def ssh_append_to_credentials(string)
+		# the following horror is exactly why rush is needed
+		passwords_file = "~/.rush/passwords"
+		string = "'#{string}'"
+		ssh "M=`grep #{string} #{passwords_file} 2>/dev/null | wc -l`; if [ $M = 0 ]; then mkdir -p .rush; chmod 700 .rush; echo #{string} >> #{passwords_file}; chmod 600 #{passwords_file}; fi"
+	end
+
+	def launch_rushd
+		display "Launching rushd"
+		ssh("if [ `ps aux | grep rushd | grep -v grep | wc -l` -ge 1 ]; then exit; fi; rushd > /dev/null 2>&1 &")
+	end
+
+	def establish_tunnel(options={})
+		display "Establishing ssh tunnel"
+		@port = next_available_port
+
+		make_ssh_tunnel(options)
+
+		tunnels = config.tunnels
+		tunnels[@real_host] = @port
+		config.save_tunnels tunnels
+
+		sleep 0.5
+	end
+
+	def tunnel_options
+		{
+			:local_port => @port,
+			:remote_port => Rush::Config::DefaultPort,
+			:ssh_host => @real_host,
+		}
+	end
+
+	def tunnel_alive?
+		`#{tunnel_count_command}`.to_i > 0
+	end
+
+	def tunnel_count_command
+		"ps x | grep '#{ssh_tunnel_command_without_stall}' | grep -v grep | wc -l"
+	end
+
+	class SshFailed < Exception; end
+	class NoPortSelectedYet < Exception; end
+
+	def ssh(command)
+		raise SshFailed unless system("ssh #{@real_host} '#{command}'")
+	end
+
+	def make_ssh_tunnel(options={})
+		raise SshFailed unless system(ssh_tunnel_command(options))
+	end
+
+	def ssh_tunnel_command_without_stall
+		options = tunnel_options
+		raise NoPortSelectedYet unless options[:local_port]
+		"ssh -f -L #{options[:local_port]}:127.0.0.1:#{options[:remote_port]} #{options[:ssh_host]}"
+	end
+
+	def ssh_stall_command(options={})
+		if options[:timeout] == :infinite
+			"while [ 1 ]; do sleep 1000; done"
+		elsif options[:timeout].to_i > 10
+			"sleep #{options[:timeout].to_i}"
+		else
+			"sleep 9000"
+		end
+	end
+
+	def ssh_tunnel_command(options={})
+		ssh_tunnel_command_without_stall + ' "' + ssh_stall_command(options) + '"'
+	end
+
+	def next_available_port
+		(config.tunnels.values.max || Rush::Config::DefaultPort) + 1
+	end
+
+	def config
+		@config ||= Rush::Config.new
+	end
+
+	def display(msg)
+		puts msg
+	end
+end

data/lib/rush/string_ext.rb

@@ -0,0 +1,3 @@
+class String
+	include Rush::HeadTail
+end

data/spec/access_spec.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Access do
+	before do
+		@access = Rush::Access.new
+	end
+
+	it "has roles: user, group, other" do
+		@access.class.roles == %w(user group other)
+	end
+
+	it "has permissions: read, write, execute" do
+		@access.class.permissions == %w(read write execute)
+	end
+
+	it "gets parts from a one-part symbol like :user" do
+		@access.parts_from(:user).should == %w(user)
+	end
+
+	it "gets parts from a two-part symbol like :read_write" do
+		@access.parts_from(:read_write).should == %w(read write)
+	end
+
+	it "allows use of 'and' in multipart symbols, like :user_and_group" do
+		@access.parts_from(:user_and_group).should == %w(user group)
+	end
+
+	it "extract_list verifies that all the parts among the valid choices" do
+		@access.should_receive(:parts_from).with(:red_green).and_return(%w(red green))
+		@access.extract_list('type', :red_green, %w(red blue green)).should == %w(red green)
+	end
+
+	it "extract_list raises a BadAccessSpecifier when there is part not in the list of choices" do
+		lambda do
+			@access.extract_list('role', :user_bork, %w(user group))
+		end.should raise_error(Rush::BadAccessSpecifier, "Unrecognized role: bork")
+	end
+
+	it "sets one value in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user))
+		@access.user_can_read.should == true
+	end
+
+	it "sets two values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+	end
+
+	it "sets four values in the matrix of permissions and roles" do
+		@access.set_matrix(%w(read write), %w(user group))
+		@access.user_can_read.should == true
+		@access.group_can_read.should == true
+		@access.user_can_write.should == true
+		@access.group_can_write.should == true
+	end
+
+	it "parse options hash" do
+		@access.parse(:user_can => :read)
+		@access.user_can_read.should == true
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.octal_permissions.should == 0400
+	end
+
+	it "generates octal permissions from its member vars" do
+		@access.user_can_read = true
+		@access.user_can_write = true
+		@access.user_can_execute = true
+		@access.group_can_read = true
+		@access.group_can_execute = true
+		@access.octal_permissions.should == 0750
+	end
+
+	it "applies its settings to a file" do
+		file = "/tmp/rush_spec_#{Process.pid}"
+		begin
+			system "rm -rf #{file}; touch #{file}; chmod 770 #{file}"
+			@access.user_can_read = true
+			@access.apply(file)
+			`ls -l #{file}`.should match(/^-r--------/)
+		ensure
+			system "rm -rf #{file}; touch #{file}"
+		end
+	end
+
+	it "serializes itself to a hash" do
+		@access.user_can_read = true
+		@access.to_hash.should == {
+			:user_can_read => 1, :user_can_write => 0, :user_can_execute => 0,
+			:group_can_read => 0, :group_can_write => 0, :group_can_execute => 0,
+			:other_can_read => 0, :other_can_write => 0, :other_can_execute => 0,
+		}
+	end
+
+	it "unserializes from a hash" do
+		@access.from_hash(:user_can_read => '1')
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a serialized hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.from_hash(:user_can_read => '1').should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "initializes from a parsed options hash" do
+		@access.class.should_receive(:new).and_return(@access)
+		@access.class.parse(:user_and_group_can => :read).should == @access
+		@access.user_can_read.should == true
+	end
+
+	it "converts and octal integer into an array of integers" do
+		@access.octal_integer_array(0740).should == [ 7, 4, 0 ]
+	end
+
+	it "filters out anything above the top three digits (File.stat returns some extra data there)" do
+		@access.octal_integer_array(0100644).should == [ 6, 4, 4 ]
+	end
+
+	it "taskes permissions from an octal representation" do
+		@access.from_octal(0644)
+		@access.user_can_read.should == true
+		@access.user_can_write.should == true
+		@access.user_can_execute.should == false
+	end
+
+	it "computes a display hash by dropping false keys and converting the 1s to trues" do
+		@access.should_receive(:to_hash).and_return(:red => 1, :green => 0, :blue => 1)
+		@access.display_hash.should == { :red => true, :blue => true }
+	end
+end

data/spec/array_ext_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Array do
+	it "mixes commands into array" do
+		[ 1,2,3 ].entries.should == [ 1, 2, 3 ]
+	end
+
+	it "can call head" do
+		[ 1,2,3 ].head(1).should == [ 1 ]
+	end
+
+	it "can call tail" do
+		[ 1,2,3 ].tail(1).should == [ 3 ]
+	end
+end

data/spec/base.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rush'
+
+def mock_config(&block)
+	mock_config_start
+	block.call(config)
+	mock_config_end
+end
+
+def mock_config_sandbox_dir
+	"/tmp/fake_config.#{Process.pid}"
+end
+
+def mock_config_start
+	mock_config_cleanup
+	Rush::Config.new(mock_config_sandbox_dir)
+end
+
+def mock_config_cleanup
+	FileUtils.rm_rf(mock_config_sandbox_dir)
+end

data/spec/box_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Box do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@box = Rush::Box.new('localhost')
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "looks up entries with [] syntax" do
+		@box['/'].should == Rush::Dir.new('/', @box)
+	end
+
+	it "looks up processes" do
+		@box.connection.should_receive(:processes).and_return([ { :pid => 123 } ])
+		@box.processes.should == [ Rush::Process.new({ :pid => 123 }, @box) ]
+	end
+
+	it "executes bash commands" do
+		@box.connection.should_receive(:bash).with('cmd', nil, false).and_return('output')
+		@box.bash('cmd').should == 'output'
+	end
+
+	it "executes bash commands with an optional user" do
+		@box.connection.should_receive(:bash).with('cmd', 'user', false)
+		@box.bash('cmd', :user => 'user')
+	end
+
+	it "executes bash commands in the background, returning a Rush::Process" do
+		@box.connection.should_receive(:bash).with('cmd', nil, true).and_return(123)
+		@box.stub!(:processes).and_return([ mock('ps', :pid => 123) ])
+		@box.bash('cmd', :background => true).pid.should == 123
+	end
+
+	it "builds a script of environment variables to prefix the bash command" do
+		@box.command_with_environment('cmd', { :a => 'b' }).should == "export a='b'\ncmd"
+	end
+
+	it "sets the environment variables from the provided hash" do
+		@box.connection.stub!(:bash)
+		@box.should_receive(:command_with_environment).with('cmd', { 1 => 2 })
+		@box.bash('cmd', :env => { 1 => 2 })
+	end
+
+	it "checks the connection to determine if it is alive" do
+		@box.connection.should_receive(:alive?).and_return(true)
+		@box.should be_alive
+	end
+
+	it "establish_connection to set up the connection manually" do
+		@box.connection.should_receive(:ensure_tunnel)
+		@box.establish_connection
+	end
+
+	it "establish_connection can take a hash of options" do
+		@box.connection.should_receive(:ensure_tunnel).with(:timeout => :infinite)
+		@box.establish_connection(:timeout => :infinite)
+	end
+end

data/spec/commands_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Commands do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@filename = "test_file"
+		system "echo thing_to_find > #{@sandbox_dir}/#{@filename}"
+		system "echo dont_find_me > #{@sandbox_dir}/some_other_file"
+
+		@dir = Rush::Dir.new(@sandbox_dir)
+		@array = @dir.files
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "searches a list of files" do
+		results = @dir.files.search(/thing_to_find/)
+		results.should be_kind_of(Rush::SearchResults)
+		results.entries.should == [ @dir[@filename] ]
+		results.lines.should == [ "thing_to_find" ]
+	end
+
+	it "searches a dir" do
+		@dir.search(/thing_to_find/).entries.should == [ @dir[@filename] ]
+	end
+
+	it "searchs a dir's nested files" do
+		@dir.create_dir('sub').create_file('file').write('nested')
+		@dir['**'].search(/nested/).entries.should == [ @dir['sub/file'] ]
+	end
+
+	it "search and replace contents on all files in the glob" do
+		@dir['1'].create.write('xax')
+		@dir['2'].create.write('-a-')
+		@dir.replace_contents!(/a/, 'b')
+		@dir['1'].contents.should == "xbx"
+		@dir['2'].contents.should == "-b-"
+	end
+
+	it "counts lines of the contained files" do
+		@dir.files.line_count.should == 2
+	end
+end

data/spec/config_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Rush::Config do
+	before do
+		@sandbox_dir = "/tmp/rush_config_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}"
+		@config = Rush::Config.new(@sandbox_dir)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "creates the dir" do
+		File.directory?(@sandbox_dir).should be_true
+	end
+
+	it "can access the history file" do
+		@config.history_file.class.should == Rush::File
+	end
+
+	it "saves the shell command history" do
+		@config.save_history(%w(1 2 3))
+		@config.history_file.contents.should == "1\n2\n3\n"
+	end
+
+	it "loads the shell command history" do
+		@config.save_history(%w(1 2 3))
+		@config.load_history.should == %w(1 2 3)
+	end
+
+	it "loads a blank history if no history file" do
+		@config.load_history.should == []
+	end
+
+	it "loads the env file" do
+		@config.env_file.write('abc')
+		@config.load_env.should == 'abc'
+	end
+
+	it "loads nothing if env file does not exist" do
+		@config.load_env.should == ""
+	end
+
+	it "loads the commands file" do
+		@config.commands_file.write('abc')
+		@config.load_commands.should == 'abc'
+	end
+
+	it "loads nothing if commands file does not exist" do
+		@config.load_commands.should == ""
+	end
+
+	it "loads usernames and password for rushd" do
+		system "echo 1:2 > #{@sandbox_dir}/passwords"
+		system "echo a:b >> #{@sandbox_dir}/passwords"
+		@config.passwords.should == { '1' => '2', 'a' => 'b' }
+	end
+
+	it "loads blank hash if no passwords file" do
+		@config.passwords.should == { }
+	end
+
+	it "loads credentials for client connecting to server" do
+		system "echo user:pass > #{@sandbox_dir}/credentials"
+		@config.credentials_user.should == 'user'
+		@config.credentials_password.should == 'pass'
+	end
+
+	it "loads list of ssh tunnels" do
+		system "echo host.example.com:123 > #{@sandbox_dir}/tunnels"
+		@config.tunnels.should == { 'host.example.com' => 123 }
+	end
+
+	it "returns an empty hash if tunnels file is blank" do
+		@config.tunnels.should == { }
+	end
+
+	it "saves a list of ssh tunnels" do
+		@config.save_tunnels({ 'my.example.com' => 4000 })
+		@config.tunnels_file.contents.should == "my.example.com:4000\n"
+	end
+
+	it "ensure_credentials_exist doesn't do anything if credentials already exist" do
+		@config.credentials_file.write "dummy"
+		@config.should_receive(:generate_credentials).exactly(0).times
+		@config.ensure_credentials_exist
+	end
+
+	it "ensure_credentials_exist generates credentials file if they don't exist" do
+		@config.should_receive(:generate_credentials)
+		@config.ensure_credentials_exist
+	end
+
+	it "secret_characters returns valid characters for username or password" do
+		@config.secret_characters.should be_kind_of(Array)
+	end
+
+	it "generate_secret products a random string for use in username and password" do
+		@config.should_receive(:secret_characters).and_return(%w(a))
+		@config.generate_secret(2, 2).should == "aa"
+	end
+
+	it "generate_credentials saves credentials" do
+		@config.generate_credentials
+		@config.credentials_file.contents.should match(/^.+:.+$/)
+	end
+end