tbm 0.1.2 → 0.2.0.rc1

data/lib/TBM/meta.rb

@@ -0,0 +1,6 @@
+# The namespace for this application/gem.
+module TBM
+  APP_NAME = "Tunnel Boring Machine"
+  VERSION = "0.2.0.rc1"
+  RELEASE_DATE = '2012-12-30'
+end

data/lib/TBM/target.rb

@@ -0,0 +1,54 @@
+module TBM
+
+	# A target defines a tunnel or set of tunnels that can be created by invoking one or more names assigned to the target.
+	#
+	# It has a name, a host, a user, and one or more tunnels well as an optional list of aliases.
+	class Target
+
+		attr_reader :name, :host, :username, :tunnels
+
+		def initialize( name, host, username )
+			@name = name
+			@host = host
+			@username = username
+			@tunnels = []
+			@aliases = []
+		end
+
+		# Adds a tunnel to the target.
+		#
+		# @param [Tunnel] tunnel the tunnel to add
+		def add_tunnel( tunnel )
+			@tunnels << tunnel
+		end
+
+		# Adds an alias to the list of recognized aliases supported by the target.
+		#
+		# @param [String] name the alias to add
+		def add_alias( name )
+			@aliases << name
+		end
+
+		def has_name?( name )
+			( @name == name ) || ( @aliases.include? name )
+		end
+
+		def each_tunnel( &block )
+			@tunnels.each { |tunnel| yield tunnel }
+		end
+
+		def to_s
+			if @aliases.empty?
+				@name
+			else
+				"#{@name} (#{@aliases.join(', ')})"
+			end
+		end
+
+		def has_tunnels?
+			!@tunnels.empty?
+		end
+
+	end
+
+end

data/lib/TBM/tunnel.rb

@@ -0,0 +1,26 @@
+module TBM
+
+  # Represents a particular tunnel, possibly one of many for a given target.
+  class Tunnel
+    attr_reader :port
+
+    def initialize( port, options = {} )
+      @port = port
+      @options = options
+    end
+
+    def remote_port
+      @options[:remote_port] || port
+    end
+
+    def remote_host_addr
+      @options[:remote_host] || 'localhost'
+    end
+
+    def remote_host
+      @options[:remote_host]
+    end
+
+  end
+
+end

data/lib/tbm.rb

@@ -1,4 +1,7 @@
-require 'tunnel/meta'
-require 'tunnel/cli'
-require 'tunnel/config'
-require 'tunnel/target'
+require 'TBM/meta'
+require 'TBM/cli'
+require 'TBM/config'
+require 'TBM/config_parser'
+require 'TBM/machine'
+require 'TBM/target'
+require 'TBM/tunnel'

data/spec/cli_spec.rb

@@ -0,0 +1,165 @@
+require 'tbm'
+
+include TBM
+
+describe CommandLineInterface do
+
+	let( :config ) { double( TBM::Config ) }
+	subject { CommandLineInterface.new config }
+
+	before do
+		TBM::ConfigParser.stub( :parse ) { config }
+		config.stub( :valid? ) { config_valid }
+		config.stub( :errors ) { config_errors }
+		stub_messages
+	end
+
+	context "without valid config" do
+		let(:config_valid) { false }
+		let(:config_errors) { ["Invalid Config"] }
+		it "should print config errors" do
+			CommandLineInterface.parse_and_run
+			@messages.should include_match(/Cannot parse config/)
+			@messages.should include_match(/Invalid Config/)
+		end
+	end
+
+	context "with no parameters" do
+		let(:config_valid) { true }
+
+		before do
+			ARGV.clear
+			config.stub(:each_target).and_yield( 'alpha' ).and_yield( 'beta' )
+		end
+
+		it "should print syntax and targets" do
+			CommandLineInterface.parse_and_run
+			@messages.should include_match( /SYNTAX/ )
+			@messages.should include_match( /alpha/ )
+			@messages.should include_match( /beta/ )
+		end
+	end
+
+	context "with a single parameter" do
+		let(:config_valid) { true }
+
+		before do
+			ARGV.clear.push( 'target-name' )
+			config.stub(:get_target).with('target-name') { target }
+		end
+
+		context "matching a config target" do
+			let(:target) { double Target }
+			let(:thost) { 'target-host.example.com' }
+			let(:tuser) { 'username' }
+			let(:machine) { double( Machine ) }
+
+			before do
+				target.stub(:host) { thost }
+				target.stub(:username) { tuser }
+			end
+
+			it "should start Tunnel Boring Machine" do
+				Machine.stub(:new) { machine }
+				machine.should_receive(:bore)
+				CommandLineInterface.parse_and_run
+			end
+		end
+
+		context "not matching a config target" do
+			let(:target) { nil }
+
+			before do
+				config.stub(:each_target).and_yield( 'another-target' )
+			end
+
+			it "should say 'Cannot find target'" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match( /Cannot find target/ )
+			end
+
+			it "should print target list" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match( /another-target/ )
+			end
+		end
+	end
+
+	context "with multiple parameters" do
+		let(:config_valid) { true }
+
+		before do
+			ARGV.clear.push( 'alpha', 'beta' )
+			config.stub(:get_target).with('alpha') { alpha }
+			config.stub(:get_target).with('beta') { beta }
+		end
+
+		context "matching configured targets with same host and user" do
+			let(:alpha) { Target.new( 'alpha', 'host', 'username' ) }
+			let(:beta) { Target.new( 'beta', 'host', 'username' ) }
+			let(:machine) { double( Machine ) }
+
+			it "should start boring machine" do
+				Machine.stub(:new) { machine }
+				machine.should_receive(:bore)
+				CommandLineInterface.parse_and_run
+			end
+		end
+
+		context "matching configured targets with different hosts" do
+			let(:alpha) { double Target }
+			let(:beta) { double Target }
+
+			before do
+				alpha.stub(:host) { 'host1' }
+				alpha.stub(:username) { 'username' }
+				beta.stub(:host) { 'host2' }
+				beta.stub(:username) { 'username' }
+			end
+
+			it "should say 'Can't combine targets'" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match(/Can't combine targets/)
+			end
+		end
+
+		context "matching configured targets with different usernames" do
+			let(:alpha) { double Target }
+			let(:beta) { double Target }
+
+			before do
+				alpha.stub(:host) { 'host' }
+				alpha.stub(:username) { 'username1' }
+				beta.stub(:host) { 'host' }
+				beta.stub(:username) { 'username2' }
+			end
+
+			it "should say 'Can't combine targets'" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match(/Can't combine targets/)
+			end
+		end
+
+		context "not all matching configured targets" do
+			let(:alpha) { nil }
+			let(:beta) { nil }
+
+			before do
+				config.stub(:each_target).and_yield( 'gamma' ).and_yield( 'delta' )
+			end
+
+			it "should say 'Cannot find target'" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match(/Cannot find target/)
+			end
+
+			it "should print target list" do
+				CommandLineInterface.parse_and_run
+				@messages.should include_match( /gamma/ )
+				@messages.should include_match( /delta/ )
+			end
+		end
+	end
+
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,348 @@
+require 'TBM/config_parser'
+require 'TBM/config'
+require 'TBM/target'
+require 'rspec'
+
+include TBM
+
+describe ConfigParser do
+	let( :path ) { File.expand_path( "~/.tbm" ) }
+	subject { ConfigParser.parse }
+
+	context "w/o config file" do
+		before do
+			stub_messages
+			File.stub( :file? ).with( path ) { false }
+		end
+
+		it { should_not be_valid }
+		specify { subject.errors.should include_match /No configuration file found/ }
+	end
+
+	context "w/ config file" do
+		before do
+			File.stub( :file? ).with( path ) { true }
+			YAML.should_receive( :load_file ).with( path ) { config }
+		end
+
+		context "containing no config" do
+			let(:config) { Hash.new }
+			it { should_not be_valid }
+			specify { subject.errors.should include_match(/No gateways/) }
+		end
+
+		context "containing an array" do
+			let(:config) { Array.new }
+			it { should_not be_valid }
+			specify { subject.errors.should include("Cannot parse TBM configuration of type: Array") }
+		end
+
+		context "containing a Hash" do
+			let(:config) { { gateway => targets } }
+
+			context "keyed by a gateway string" do
+				let(:gateway) { "gateway" }
+				let(:targets) { { 'web' => 80 } }
+				it { should be_valid }
+
+				before do
+					Etc.stub(:getlogin) { 'local-username' }
+				end
+
+				it "should contain a host with the specified gateway name" do
+				  subject.get_target('web').host.should eql('gateway')
+				end
+
+				it "should contain a host with the local username" do
+				  subject.get_target('web').username.should eql('local-username')
+				end
+			end
+
+			context "keyed by a username@gateway string" do
+				let(:gateway) { "remote-username@gateway.example.com" }
+				let(:targets) { { 'web' => 80 } }
+				it { should be_valid }
+				it "should contain a host with the specified gateway name" do
+				  subject.get_target('web').host.should eql('gateway.example.com')
+				end
+				it "should contain a host with the specified username" do
+				  subject.get_target('web').username.should eql('remote-username')
+				end
+			end
+
+			context "keyed by a non-String" do
+				let(:gateway) { Array.new }
+				let(:targets) { Hash.new }
+				specify { subject.errors.should include( "Cannot parse gateway name: [] (Array)" ) }
+			end
+
+			context "with target hash of tunnels" do
+				let(:gateway) { 'user@host' }
+				let(:targets) { { 'target-name' => target } }
+
+				context "with nil tunnel" do
+					let(:target) { nil }
+					specify { subject.errors.should include_match(/No target config/) }
+				end
+
+				context "with target config of 8080" do
+					let(:target) { 8080 }
+					it "should forward port 8080" do
+						subject.should be_valid
+						subject.get_target('target-name').should have_tunnel( :port => 8080, :remote_port => 8080, :remote_host => nil )
+					end
+				end
+
+				context "with target config of 0" do
+					let(:target) { 0 }
+					specify { subject.errors.should include( "Invalid port number: 0" ) }
+				end
+
+				context "with target config of '8443'" do
+					let(:target) { "8443" }
+					it "should forward port 8443" do
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnel( :port => 8443, :remote_port => 8443, :remote_host => nil )
+					end
+				end
+
+				context "with target config of '77777'" do
+					let(:target) { "77777" }
+					specify { subject.errors.should include( "Invalid port number: 77777" ) }
+				end
+
+				context "with target config of '8080:80'" do
+					let(:target) { "8080:80" }
+					it "should map port 8080 to 80" do
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnel( :port => 8080, :remote_port => 80, :remote_host => nil )
+					end
+				end
+
+				context "with target config of '8080:prod:80'" do
+					let(:target) { "8080:prod:80" }
+					it "should map port 8080 to 80 on prod" do
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnel( :port => 8080, :remote_port => 80, :remote_host => 'prod' )
+					end
+				end
+
+				context "with target config of 'staging:8080'" do
+					let(:target) { "staging:8080" }
+					it "should forward port 8080 to staging" do
+						puts subject.errors
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnel( :port => 8080, :remote_port => 8080, :remote_host => 'staging' )
+					end
+				end
+
+				context "with target config of [8080,8443]" do
+					let(:target) { [8080,8443] }
+					it "should forward ports 8080 and 8443" do
+						puts subject.errors
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnels( [ { :port => 8080 }, { :port => 8443 } ] )
+					end
+				end
+
+				context "with target config of [3000,8080:80]" do
+					let(:target) { [3000,"8080:80"] }
+					it "should forward port 3000 and map 8080 to 80" do
+						puts subject.errors
+						subject.should be_valid
+						target = subject.get_target('target-name').should have_tunnels( [ { :port => 3000, :remote_port => 3000 }, { :port => 8080, :remote_port => 80 } ] )
+					end
+				end
+
+				context "with Hash target config" do
+					let(:target) { Hash.new }
+
+					context "containing nothing" do
+						specify { subject.errors.should include_match(/no tunnels/) }
+					end
+
+					it "should forward port from 'tunnel' key" do
+						target['tunnel'] = 3000
+						subject.get_target('target-name').should have_tunnel( :port => 3000 )
+					end
+
+					it "should add alias from 'alias' key" do
+						target['alias']='aka'
+						subject.get_target('target-name').should have_name('aka')
+					end
+
+					it "should treat any other key as a remote host" do
+						target['staging']=[1111,"2222:3333"]
+						target['prod']=3306
+						subject.get_target('target-name').should have_tunnels( [
+								{ :port => 1111, :remote_port => 1111, :remote_host => 'staging' },
+								{ :port => 2222, :remote_port => 3333, :remote_host => 'staging' },
+								{ :port => 3306, :remote_port => 3306, :remote_host => 'prod' },
+							])
+					end
+				end
+			end
+
+			context "with a non-Hash value" do
+				let(:gateway) { 'user@host' }
+				let(:targets) { "Targets" }
+				specify { subject.errors.should include( "Cannot parse targets, expected Hash, received: String" ) }
+			end
+
+		end
+
+# target-details is a string (connection), array (array of connection) or hash (target-hash)
+# connection is an integer or string, matching any of: <port> or <localport>:<remoteport> or <localport>:host:<remoteport>
+# target-hash contains: alias, forward, remote-host
+# alias is string or array of strings containing aliases for the tunnel name.
+# forward contains a connection or array of connections
+# remote-host maps to a remote connection or array of remote connections
+# remote connection is an integer or a string in the following formats: <port>, <local-port>:<remote-port>
+
+		# 			context "and no forward" do
+		# 				it { should_not be_valid }
+		# 				specify { subject.errors.should include_match(/no forward/) }
+		# 			end
+
+		# 			context "and a forward" do
+		# 				let(:target) { { 'host' => 'host', 'username' => 'username', 'forward' => forward } }
+		# 				let(:targetmock) { double(Tunnel::Target) }
+
+		# 				before do
+		# 					Tunnel::Target.stub(:new) { targetmock }
+		# 					targetmock.stub( :host ) { 'host' }
+		# 				end
+
+		# 				context "of 8080" do
+		# 					let(:forward) { 8080 }
+		# 					it "should forward port 8080 on localhost" do
+		# 						targetmock.should_receive( :forward_port ).with( 8080, nil )
+		# 						subject.should be_valid
+		# 					end
+		# 				end
+
+		# 				context "of [ 8000, 8443 ]" do
+		# 					let(:forward) { [8000,8443] }
+		# 					it "should forward ports 8080 and 8443" do
+		# 						targetmock.should_receive( :forward_port ).with( 8000, nil )
+		# 						targetmock.should_receive( :forward_port ).with( 8443, nil )
+		# 						subject.should be_valid
+		# 					end
+		# 				end
+
+		# 				context "of { alpha => 3000, beta => [ 8080, 8443 ] } ]" do
+		# 					let(:forward) { { 'alpha' => 3000, 'beta' => [ 8080, 8443 ] } }
+		# 					it "should forward port 3000 to alpha" do
+		# 						targetmock.should_receive( :forward_port ).with( 3000, 'alpha' )
+		# 						targetmock.stub( :forward_port ).with( anything(), 'beta' )
+		# 						subject.should be_valid
+		# 					end
+		# 					it "should forward ports 8080, 8443 to alpha" do
+		# 						targetmock.should_receive( :forward_port ).with( 8080, 'beta' )
+		# 						targetmock.should_receive( :forward_port ).with( 8443, 'beta' )
+		# 						targetmock.stub( :forward_port ).with( anything(), 'alpha' )
+		# 						subject.should be_valid
+		# 					end
+		# 				end
+
+		# 				context "of 8000.5" do
+		# 					let(:forward) { 8000.5 }
+		# 					it { should_not be_valid }
+		# 					specify { subject.errors.should include_match(/Not sure how to handle forward .*: Float/) }
+		# 				end
+
+		# 				context "of -8080" do
+		# 					let(:forward) { -8080 }
+		# 					it { should_not be_valid }
+		# 					specify { subject.errors.should include_match(/Invalid port/) }
+		# 				end
+
+		# 				context "of 'blueberry'" do
+		# 					let(:forward) { 'blueberry' }
+		# 					it { should_not be_valid }
+		# 					specify { subject.errors.should include_match(/Not sure how to handle forward .*: String/) }
+		# 				end
+
+		# 				context "of 'blueberry'" do
+		# 					let(:forward) { [ 80.80, -443, 'blueberry' ] }
+		# 					it { should_not be_valid }
+		# 					specify { subject.errors.should include_match(/Invalid port/) }
+		# 				end
+
+		# 			end
+
+		# 			context "and an alias" do
+		# 				let(:target) { { 'host' => 'host', 'username' => 'username', 'forward' => 8080 } }
+		# 				let(:targetmock) { double(Tunnel::Target) }
+
+		# 				before do
+		# 					Tunnel::Target.stub(:new) { targetmock }
+		# 					targetmock.stub(:forward_port)
+		# 				end
+
+		# 				it "should treat string as single alias" do
+		# 					target['alias']= 'mr-smith'
+		# 					targetmock.should_receive( :alias ).with( 'mr-smith' )
+		# 					subject.should be_valid
+		# 				end
+
+		# 				it "should treat an array as a series of aliases" do
+		# 					target['alias']= 'mr-smith'
+		# 					targetmock.should_receive( :alias ).with( 'mr-smith' )
+		# 					subject.should be_valid
+		# 				end
+
+		# 				it "should warn with any other content" do
+		# 					target['alias'] = Hash.new
+		# 					subject.should_not be_valid
+		# 					subject.errors.should include_match( /Cannot parse alias/ )
+		# 				end
+		# 			end
+		# 		end
+
+		# 	end
+
+		# 	context "containing a hash of five targets" do
+		# 		let(:config) { { 'alpha' => { 'host' => 'host', 'forward' => 3001 }, 'beta' => { 'host' => 'host', 'forward' => 3002 }, 'gamma' => { 'host' => 'host', 'forward' => 3003 }, 'delta' => { 'host' => 'host', 'forward' => 3004 },
+		# 			'omega' => { 'host' => 'host', 'forward' => 3005 } } }
+		# 		it "should return all five targets specified" do
+		# 			subject.should be_valid
+		# 			subject.get_target( 'alpha' ).should be_instance_of(Tunnel::Target)
+		# 			subject.get_target( 'beta' ).should be_instance_of(Tunnel::Target)
+		# 			subject.get_target( 'gamma' ).should be_instance_of(Tunnel::Target)
+		# 			subject.get_target( 'delta' ).should be_instance_of(Tunnel::Target)
+		# 			subject.get_target( 'omega' ).should be_instance_of(Tunnel::Target)
+		# 		end
+		# 	end
+
+	end
+end
+
+RSpec::Matchers.define :have_tunnel do |expected|
+	match do |actual|
+		actual.should_not be_nil
+		actual.tunnels.size.should eql(1) 
+		tunnel = actual.tunnels[0]
+		expected.each do |k,v|
+			tunnel.send(k).should eql(v)
+		end
+	end
+	description do
+		properties = expected.map{ |k,v| "#{k}=#{v}" }.join( ', ' )
+		"have a tunnel with #{properties}"
+	end
+end
+
+RSpec::Matchers.define :have_tunnels do |expected|
+	match do |actual|
+		actual.should_not be_nil
+		actual.tunnels.size.should eql(expected.size) 
+		(0...expected.size).each do |index|
+			tunnel = actual.tunnels[index]
+			properties = expected[index]
+			properties.each do |k,v|
+				tunnel.send(k).should eql(v)
+			end
+		end
+	end
+end