tunl 0.0.1

data/bin/tunl

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/tunl'
+require 'thor'
+
+module Tunl
+	
+	class CLI < Thor
+		
+		desc "start <name>", "launch named tunnel"
+		method_options :check => :string, :port => :string, :verbose => :boolean
+		def start(name)                 
+			printf("\n%-3s %-8s %-20s\n\n", '~~>', "Start", "Tunnel: #{name}")
+			tunl = Tunl::Base.new
+			tunl.setup_security_group(name)
+			tunl.setup_key_pair(name)
+			tunl.setup_instance(name)    
+			
+			instance = tunl.find_instance(name)
+			port = options[:port] || 3000
+			if options[:verbose]
+				verbose = "-v"
+			else
+				verbose = ''
+			end
+			
+			if uri = options[:check]
+				tunl.log("check", "#{instance[:dns_name]}#{uri}")
+				t = Thread.new do
+					loop do
+						`curl http://#{instance[:dns_name]}#{uri} > /dev/null 2>&1`
+							puts "."
+							sleep 60
+					end
+				end
+			end
+			tunl.log("tunnel", "#{instance[:dns_name]}:80 -> localhost:#{port}")
+			puts "\n\n"
+			`ssh -i #{tunl.key_pair_filepath(name)} #{verbose} -N -p 22 root@#{instance[:dns_name]} -R *:80:localhost:#{port}`
+		end
+		
+		desc "ssh <name>", "ssh into the named instance"
+		def ssh(name)
+			tunl = Tunl::Base.new 
+			instance = tunl.find_instance(name)
+			if instance.nil?
+				puts "Tunl #{name} does not exist"
+				exit(0)
+			end
+			exec "ssh -i #{tunl.key_pair_filepath(name)} root@#{instance[:dns_name]}"
+		end
+		
+		desc "stop <name>", "terminate the named tunnel"
+		def stop(name)
+			tunl = Tunl::Base.new
+			if instance = tunl.find_instance(name)
+				printf("\n%-3s %-8s %-20s\n\n", '~~>', "Stop", "Tunnel: #{name}")
+				tunl.delete_instance(name)
+				tunl.delete_security_group(name)
+				tunl.delete_key_pair(name)
+				puts ""
+			else
+				puts "tunl #{name} not running"
+			end
+		end
+		
+		desc "list", "list all the tunnels"
+		def list
+			tunl = Tunl::Base.new
+			instances = tunl.find_all_instances
+			if instances.size==0
+				puts "no running tunnels"
+			else
+				$stdout.printf("\n%-3s %-12s\n\n", '', 'Tunnels')
+				$stdout.printf("%-3s %-12s %-12s %-12s\n\n", '', 'Name', 'Aws Id', 'Host')
+				instances.each do |item|
+					$stdout.printf("%-3s %-12s %-12s %-12s\n", '', item[:aws_groups].first.gsub('tunl_', ''), item[:aws_instance_id], item[:dns_name])
+				end
+				$stdout.puts("\n\n")
+			end
+		end
+		
+		no_tasks do
+
+		end
+		
+	end
+	
+end
+
+Tunl::CLI.start

data/lib/tunl.rb

@@ -0,0 +1,204 @@
+
+# ruby requirements
+require 'pathname'
+require 'fileutils'
+
+
+require 'net/http'
+# hack to disable SSL warnings issued by the right_http_connection gem
+class Net::HTTP
+  alias_method :old_initialize, :initialize
+  def initialize(*args)
+    old_initialize(*args)
+    @ssl_context = OpenSSL::SSL::SSLContext.new
+    @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+  end
+end
+
+
+# gem requirements
+require 'right_aws'
+
+# hack to supress annoying log messages from right_aws gem
+module Tunl
+	class SilentLogger
+		def self.info(msg)
+		end
+		def self.error(msg)
+			puts "RIGHT AWS ERROR : #{msg}"
+		end
+		def self.warn(msg)
+			puts "RIGHT AWS WARN: #{msg}"
+		end
+	end
+end
+
+module Tunl
+	class Base
+		
+		def root
+			@root ||= Pathname.new(File.expand_path("~/.tunl"))
+		end
+		
+		def config
+			@config ||= YAML.load(File.read(root.join('tunl.yml')))
+		end
+		
+		def ec2
+			@ec2 ||= RightAws::Ec2.new(config['aws_access_key'],config['aws_secret_key'], :logger => SilentLogger)
+		end
+		
+		def key_pair_filepath(name)
+			root.join("tunl_key_pair_#{name}")
+		end
+		
+		def create_key_pair(name)
+			log "create", "key pair tunl_#{name}"
+			filepath = key_pair_filepath(name)
+			key_pair = ec2.create_key_pair("tunl_#{name}")
+			File.open(filepath, 'w') { |f| f.write(key_pair[:aws_material]) }
+			FileUtils.chmod 0400, filepath
+		rescue RightAws::AwsError => e
+	    if e.message =~ /already exists/
+	      # WARNING : this could be dangerous.
+	      delete_key_pair(name)
+	      retry
+	    else
+	      raise e
+	    end
+		end
+		
+		def delete_key_pair(name)
+			log "delete", "key Pair tunl_#{name}"
+			# delete key pair from amazon
+			ec2.delete_key_pair("tunl_#{name}")
+			# delete local file
+			filepath = key_pair_filepath(name)
+			if File.exists?(filepath)
+				FileUtils.rm_f(filepath)
+			end
+		end
+		
+		def setup_key_pair(name)
+			if ! File.exists?(key_pair_filepath(name))
+				create_key_pair(name)
+			end
+		end
+		
+		def create_security_group(name)
+			log "create", "security group tunl_#{name}"
+			ec2.create_security_group("tunl_#{name}", 'created by tunl gem')
+		rescue RightAws::AwsError => e
+			if e.message =~ /already exists/
+				return true
+			else
+				raise e
+			end
+		end
+		
+		def authorize_security_group(name)
+			[ 22, 80 ].each do |port|
+				begin
+					ec2.authorize_security_group_IP_ingress("tunl_#{name}", port, port)
+				rescue RightAws::AwsError => e
+					if e.message =~ /already been authorized/
+						# do nothing
+					else
+						raise e
+					end
+				end
+			end
+		end
+		
+		def delete_security_group(name)
+			log "delete", "security group tunl_#{name}"
+			ec2.delete_security_group("tunl_#{name}")
+		end
+		
+		def find_security_group(name)
+			ec2.describe_security_groups.find { |item| item[:aws_group_name]=="tunl_#{name}" }
+		end
+		
+		def setup_security_group(name)
+			# returns the names of all existing security groups prefixed with tunl_
+			group = find_security_group(name)
+			if group.nil?
+				create_security_group(name)
+				authorize_security_group(name)
+			end
+		end
+		
+		def find_instance(name)
+			ec2.describe_instances.find { |item| item[:aws_groups].include?("tunl_#{name}") and (item[:aws_state].include?("pending") or item[:aws_state].include?("running")) }
+		end
+		
+		def create_instance(name)
+			# launch instance with:
+			#  os - ubuntu hardy 32 bit
+			#  security_group: tunl_name
+			#  key_pair: tunl_name
+			log "launch", "instance ..."
+			instances = ec2.launch_instances('ami-ed46a784',
+				:key_name => "tunl_#{name}",
+				:group_ids => "tunl_#{name}",
+				:instance_type => 'm1.small',
+				:availability_zone => 'us-east-1a',
+				:user_data => %Q{#!/bin/sh
+					echo "starting" > /tmp/user_data_status.txt
+					echo "GatewayPorts clientspecified" >> /etc/ssh/sshd_config
+					/etc/init.d/ssh restart
+					echo "finished" > /tmp/user_data_status.txt
+				})
+			log "", "#{instances.first[:aws_instance_id]}"	
+		end
+		
+		def wait_for_instance(name)
+			log "", "waiting for dns ..."
+			while true
+				break if ( find_instance(name) and find_instance(name)[:dns_name].size>0 )
+				sleep(2)
+			end
+			log "", "done: #{find_instance(name)[:dns_name]}"
+			require 'socket'     
+			dns_name = find_instance(name)[:dns_name]
+			log "", "waiting for ssh"
+			loop do
+				begin
+					Timeout::timeout(4) do
+						TCPSocket.new(dns_name, 22)
+						log "", "done!"
+						log ""
+						return
+					end
+				rescue SocketError, Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+					sleep(2)
+				end
+			end
+		end
+		
+		def delete_instance(name)
+			instance = find_instance(name)
+		 	log "delete", "instance tunl_#{name} with id #{instance[:aws_instance_id]}"
+			ec2.terminate_instances(instance[:aws_instance_id])
+		end
+		
+		def setup_instance(name)
+			instance = find_instance(name)
+			if instance.nil?
+				create_instance(name)
+			else
+				log "connect", "instance #{instance[:aws_instance_id]}"
+			end
+			wait_for_instance(name)
+		end
+		
+		def find_all_instances
+			ec2.describe_instances.find_all { |item| item[:aws_groups].first.include?('tunl_') and ['running', 'pending'].include?(item[:aws_state]) }
+		end
+		
+		def log(action,message='')
+			$stdout.printf("%-3s %-8s %-12s\n", '', action, message)
+		end
+		
+	end 
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: tunl
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Crockett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-30 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: EC2 Proxy Service
+email: davy@davcro.com
+executables: 
+- tunl
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/tunl.rb
+- bin/tunl
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: EC2 Proxy Service
+test_files: []
+