tbm 0.2.0 → 0.3.0

data/README.md

@@ -1,11 +1,12 @@
 # Tunnel Boring Machine
+[![Build Status](https://travis-ci.org/geoffreywiseman/tunnel-boring-machine.png?branch=master)](https://travis-ci.org/geoffreywiseman/tunnel-boring-machine) [![Dependency Status](https://gemnasium.com/geoffreywiseman/tunnel-boring-machine.png)](https://gemnasium.com/geoffreywiseman/tunnel-boring-machine) [![Code Climate](https://codeclimate.com/github/geoffreywiseman/tunnel-boring-machine.png)](https://codeclimate.com/github/geoffreywiseman/tunnel-boring-machine)
 
 Tunnel Boring Machine is a ruby application to manage SSH tunnels, which you can use to achieve something a little like a VPN, wherein SSH access to a server can give you access to the network beyond that server.
 
 I use SSH tunnels on a regular basis to access resources at client sites that are not exposed directly to the internet as a whole. Managing those tunnels as a series of bash scripts or aliases became cumbersome. I wanted / needed something better, and the tunnel boring machine has evolved from that need.
 
 ## Current Status ##
-It's pretty early days. I'm using this myself, but I haven't gone out of my way to share it with anyone because so much is still in flux. I imagine it will be starting to stabilize soon into something I might call a 'beta' product. At the moment, it's probably more of an 'alpha'.
+It's pretty early days. I'm using this myself, and I've shared it so other people can use it, but its advantages over a shell script are still fairly thin. There are some enhancements that I have planned that might make the case much stronger, but we'll see.
 
 ## Installing ##
 It is bundled as a ruby gem, so if you have Ruby and RubyGems installed, simply run:
@@ -17,12 +18,12 @@ If you prefer, you can certainly download it and build it yourself, or simply in
 ## Invocation ##
 For the time being, TBM is a simple command you invoke to open the tunnels you need, then you cancel with `^C` to close the tunnels that you had opened. Something like this:
 
-    $ tbm dev-ngnix
+    $ tbm dev-nginx
 
 Eventually, I expect that TBM will become a little more interactive, allowing you to open additional tunnels without closing the ones you already opened, close a tunnel without closing all of them, and so forth. Whether it does this as an interactive program, a shell command that interacts with a running process is all TBD.
 
 ## Configuration ##
-You configure the tunnel boring machine by creating a configuration file in YAML form at `~/.tunnels`. At the moment, you can't have multiple configuration files, change the location of the configuration file or anything of that nature.
+You configure the tunnel boring machine by creating a configuration file in YAML form at `~/.tbm`. At the moment, you can't have multiple configuration files, change the location of the configuration file or anything of that nature.
 
 An example configuration file follows:
 
@@ -35,14 +36,12 @@ An example configuration file follows:
         as400: [ 449, 8470, 8471, 8476 ]
         alias: [ ju, ussi ]
       qa:
-        forward: 8080
-      staging:
-        alias: [ stage, st ]
-        tunnel: 8080:80
+        tunnel: 8080
+      staging (stage, st): 8080:80
       5250: 8023:as400:23
       webfacing: as400:10905
 
-Although the above configuration format is still subject to flux, I feel like it's starting to stabilize, so I'm going to need to document it more thoroughly. For the time being, you might want to look at the [closed issue](https://github.com/geoffreywiseman/tunnel-boring-machine/issues/38) regarding the format change.
+I have [documented the configuration file format](http://geoffreywiseman.github.com/tunnel-boring-machine/config.html) on the website.
 
 ## License ##
 I've put it under the UNLICENSE. Basically, I don't care if you use it, bundle it inside commercial software, or otherwise make use of it, and I don't offer any kind of warranty or support guarantees, nor do I guarantee that any of the projects dependencies are suited for whatever purpose you have in mind. That's all up to you. That said, if you want to talk about it, see the next section.

data/Rakefile

@@ -21,19 +21,26 @@ RSpec::Core::RakeTask.new(:coverage) do |t|
 end
 
 spec = Gem::Specification.new do |spec|
+  # Basics
   spec.name = 'tbm'
   spec.version = TBM::VERSION
   spec.date = TBM::RELEASE_DATE
   spec.summary = 'Manages SSH Tunnels by creating an SSH connection and forwarding ports based on named targets defined in configuration.'
   spec.description = 'The "Tunnel Boring Machine" is meant to bore ssh tunnels through the internet to your desired destination simply and repeatedly, as often as you need them. This is a tool for someone who needs SSH tunnels frequently.'
-  spec.author = 'Geoffrey Wiseman'
-  spec.email = 'geoffrey.wiseman@codiform.com'
-  spec.homepage = 'http://github.com/geoffreywiseman/tunnel-boring-machine'
-  spec.executables << 'tbm'
+  spec.add_dependency( 'net-ssh', '>= 2.6.2' )
 
+  # Files
+  spec.executables << 'tbm'
   spec.files = Dir['{lib,spec}/**/*.rb', 'bin/*', 'Rakefile', 'README.md', 'UNLICENSE']
 
-  spec.add_dependency( 'net-ssh', '>= 2.6.2' )
+  # Documentation
+  spec.has_rdoc = true
+
+  # About
+  spec.author = 'Geoffrey Wiseman'
+  spec.email = 'geoffrey.wiseman@codiform.com'
+  spec.homepage = 'http://github.com/geoffreywiseman/tunnel-boring-machine'
+  spec.license = 'UNLICENSE'
 end
 
 Gem::PackageTask.new( spec ) do |pkg|

data/lib/TBM/cli.rb

@@ -41,7 +41,8 @@ module TBM
 					machine.bore
 				end
 			else
-				puts "Cannot parse configuration:\n\t#{config.errors.join('\n\t')}"
+				formatted_errors = config.errors.join( "\n\t" )
+				puts "Cannot parse configuration. Errors:\n\t#{formatted_errors}\n"
 			end
 		end
 

data/lib/TBM/config_parser.rb

@@ -7,8 +7,31 @@ module TBM
 
 		# The configuration file used for parsing config.
 		CONFIG_FILE = File.expand_path( '~/.tbm' )
+
+		# Pattern for Gateway Server with Optional Username
 		GATEWAY_PATTERN = /^([^@]+)(@([^@]+))?$/
 
+		# Pattern for a tunnel with a remote host followed by a port (example.com:3333)
+		HOSTPORT_PATTERN = /^([a-zA-Z0-9\.\-]+):(\d{1,5})$/
+
+		# Pattern for a tunnel with a remote host and local and remote ports (1234:example.com:4321)
+		PORTHOSTPORT_PATTERN = /^(\d{1,5}):([a-zA-Z0-9\.\-]+):(\d{1,5})$/
+
+		# Pattern for a tunnel with a local port and a gateway port (1234:4321)
+		PORTPORT_PATTERN = /^(\d{1,5}):(\d{1,5})$/
+
+		# Pattern for a tunnel with a single port to be used client/server to forward to the gateway (1234)
+		PORT_PATTERN = /^\d{1,5}$/
+
+		# Pattern for a target with aliases defined in the target name
+		TARGET_NAME_PATTERN = /^
+			([A-Za-z0-9\.\-\[\]\#]+)									# name
+			(\s*\(\s* 																# optional parenthesized aliases
+			([A-Za-z0-9\.\-\[\]\#]+\s*								# first alias
+			(,\s*[A-Za-z0-9\.\-\[\]\#]+\s*)*)						# repeating alias pattern with commas
+		\))?\s*$/x 																	# end of parenthesized aliases
+
+
 		# Parses the tunnel boring machine configuration to get a list of targets which can 
 		# be invoked to bore tunnels.
 		#
@@ -69,16 +92,33 @@ module TBM
 
 		def self.parse_targets( gateway_host, gateway_username, targets, config )
 			if Hash === targets
-				targets.each_key do |target_name|
-					target = Target.new( target_name.to_s, gateway_host, gateway_username )
-					config.targets << target
-					configure_target( target, targets[target_name], config )
+				targets.each_key do |target_name_string|
+					names = parse_target_names( target_name_string.to_s )
+					if names.empty?
+						config.errors << "Cannot parse target name: #{target_name_string}"
+					else
+						target = Target.new( names.shift, gateway_host, gateway_username )
+						config.targets << target
+						names.each { |aka| target.add_alias aka }
+						configure_target( target, targets[target_name_string], config )
+					end
 				end
 			else
 				config.errors << "Cannot parse targets, expected Hash, received: #{targets.class}"
 			end
 		end
 
+		def self.parse_target_names( target_name_string )
+			names = []
+			if TARGET_NAME_PATTERN =~ target_name_string
+				names << $1
+				unless $3.nil?
+					names.concat $3.split(',').map { |x| x.strip }
+				end
+			end
+			return names
+		end
+
 		def self.configure_target( target, target_config, config )
 			case target_config
 			when Fixnum, String
@@ -99,54 +139,45 @@ module TBM
 		def self.tunnel( target, tunnel_config, config )
 			case tunnel_config
 			when Fixnum
-				if valid_port?( tunnel_config )
-					target.add_tunnel( Tunnel.new( tunnel_config ) )
-				else
-					config.errors << "Invalid port number: #{tunnel_config}"
-				end
+					config.errors.concat validate_and_add( tunnel_config, tunnel_config, target )
 			when String
 				case tunnel_config 
-				when /^\d{1,5}$/
-					port = tunnel_config.to_i
-					if valid_port?( port )
-						target.add_tunnel( Tunnel.new( port ) )
-					else
-						config.errors << "Invalid port number: #{tunnel_config}"
-					end
-				when /^(\d{1,5}):(\d{1,5})$/
-					port = $1.to_i
-					remote_port = $2.to_i
-					if !valid_port?( port )
-						config.errors << "Invalid local port number #{port} from #{tunnel_config}"
-					elsif !valid_port?( remote_port )
-						config.errors << "Invalid remote port number #{remote_port} from #{tunnel_config}"
-					else
-						target.add_tunnel( Tunnel.new( port, :remote_port => remote_port ) )
-					end
-				when /^(\d{1,5}):([a-zA-Z0-9\.\-]+):(\d{1,5})$/
-					port = $1.to_i
-					remote_host = $2
-					remote_port = $3.to_i
-					if !valid_port?( port )
-						config.errors << "Invalid local port number #{port} from #{tunnel_config}"
-					elsif !valid_port?( remote_port )
-						config.errors << "Invalid remote port number #{remote_port} from #{tunnel_config}"
-					else
-						target.add_tunnel( Tunnel.new( port, :remote_host => remote_host, :remote_port => remote_port ) )
-					end
-				when /^([a-zA-Z0-9\.\-]+):(\d{1,5})$/
-					port = $2.to_i
-					remote_host = $1
-					if !valid_port?( port )
-						config.errors << "Invalid port number #{port} from #{tunnel_config}"
-					else
-						target.add_tunnel( Tunnel.new( port, :remote_host => remote_host ) )
-					end
+				when PORT_PATTERN
+					config.errors.concat validate_and_add( tunnel_config.to_i, tunnel_config, target )
+				when PORTPORT_PATTERN
+					config.errors.concat validate_and_add( $1.to_i, tunnel_config, target, :remote_port => $2.to_i )
+				when PORTHOSTPORT_PATTERN
+					config.errors.concat validate_and_add( $1.to_i, tunnel_config, target, :remote_host => $2, :remote_port => $3.to_i )
+				when HOSTPORT_PATTERN
+					config.errors.concat validate_and_add( $2.to_i, tunnel_config, target, :remote_host => $1 )
 				else
-					config.errors << "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
+					config.errors.concat "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
 				end
 			else
-				config.errors << "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
+				config.errors.concat "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
+			end
+		end
+
+		def self.validate_and_add( port, tunnel_config, target, options={} )
+			errors = []
+			if options.has_key?( :remote_port ) then
+				validate_port( port, 'local', tunnel_config, errors )
+				validate_port( options[:remote_port], 'remote', tunnel_config, errors )
+			else
+				validate_port( port, nil, tunnel_config, errors )
+			end
+			target.add_tunnel( Tunnel.new( port, options ) ) if errors.empty?
+			return errors
+		end
+
+		def self.validate_port( port, port_qualifier, tunnel_config, errors )
+			if valid_port?( port )
+				return true
+			else
+				qualified_port = ( port_qualifier.nil? ? "port" : "#{port_qualifier} port" )
+				port_source = tunnel_config.to_s.match PORT_PATTERN ? '' : " from ${tunnel_config}"
+				errors << "Invalid #{qualified_port} number #{port}#{port_source}"
+				return false
 			end
 		end
 
@@ -184,35 +215,18 @@ module TBM
 		def self.remote_tunnel( target, remote_host, tunnel_config, config )
 			case tunnel_config
 			when Fixnum
-				if valid_port?( tunnel_config )
-					target.add_tunnel( Tunnel.new( tunnel_config, :remote_host => remote_host ) )
-				else
-					config.errors << "Invalid port number: #{tunnel_config}"
-				end
+				config.errors.concat validate_and_add( tunnel_config, tunnel_config, target, :remote_host => remote_host )
 			when String
 				case tunnel_config 
-				when /^\d{1,5}$/
-					port = tunnel_config.to_i
-					if valid_port?( port )
-						target.add_tunnel( Tunnel.new( port, :remote_host => remote_host ) )
-					else
-						config.errors << "Invalid port number: #{tunnel_config}"
-					end
-				when /^(\d{1,5}):(\d{1,5})$/
-					port = $1.to_i
-					remote_port = $2.to_i
-					if !valid_port?( port )
-						config.errors << "Invalid local port number #{port} from #{tunnel_config}"
-					elsif !valid_port?( remote_port )
-						config.errors << "Invalid remote port number #{remote_port} from #{tunnel_config}"
-					else
-						target.add_tunnel( Tunnel.new( port, :remote_port => remote_port, :remote_host => remote_host ) )
-					end
+				when PORT_PATTERN
+					config.errors.concat validate_and_add( tunnel_config.to_i, tunnel_config, target, :remote_host => remote_host )
+				when PORTPORT_PATTERN
+					config.errors.concat validate_and_add( $1.to_i, tunnel_config, target, :remote_host => remote_host, :remote_port => $2.to_i )
 				else
-					config.errors << "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
+					config.errors.concat "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
 				end
 			else
-				config.errors << "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
+				config.errors.concat "Cannot parse tunnel: #{tunnel_config} (#{tunnel_config.class})"
 			end
 		end
 

data/lib/TBM/meta.rb

@@ -1,6 +1,6 @@
 # The namespace for this application/gem.
 module TBM
   APP_NAME = "Tunnel Boring Machine"
-  VERSION = "0.2.0"
-  RELEASE_DATE = '2013-01-22'
+  VERSION = "0.3.0"
+  RELEASE_DATE = '2013-03-07'
 end

data/spec/config_spec.rb

@@ -85,6 +85,23 @@ describe ConfigParser do
 					specify { subject.errors.should include_match(/No target config/) }
 				end
 
+				context "with parenthesized alias" do
+					let(:targets) { { 'target-name (aka)' => 8080 } }
+					it "should accept alias as name" do
+						subject.should be_valid
+						subject.get_target( 'aka' ).should_not be_nil
+					end
+				end
+
+				context "with parenthesized aliases" do
+					let(:targets) { { 'target-name (pseudo,nym)' => 8080 } }
+					it "should accept alias as name" do
+						subject.should be_valid
+						subject.get_target( 'pseudo' ).should_not be_nil
+						subject.get_target( 'nym' ).should_not be_nil
+					end
+				end
+
 				context "with target config of 8080" do
 					let(:target) { 8080 }
 					it "should forward port 8080" do
@@ -95,7 +112,7 @@ describe ConfigParser do
 
 				context "with target config of 0" do
 					let(:target) { 0 }
-					specify { subject.errors.should include( "Invalid port number: 0" ) }
+					specify { subject.errors.should include( "Invalid port number 0" ) }
 				end
 
 				context "with target config of '8443'" do
@@ -108,7 +125,7 @@ describe ConfigParser do
 
 				context "with target config of '77777'" do
 					let(:target) { "77777" }
-					specify { subject.errors.should include( "Invalid port number: 77777" ) }
+					specify { subject.errors.should include( "Invalid port number 77777" ) }
 				end
 
 				context "with target config of '8080:80'" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tbm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-22 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -53,7 +53,8 @@ files:
 - README.md
 - UNLICENSE
 homepage: http://github.com/geoffreywiseman/tunnel-boring-machine
-licenses: []
+licenses:
+- UNLICENSE
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -66,7 +67,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1799474746480285819
+      hash: 450154189210157473
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: