pagoda-tunnel 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in pagoda-tunnel.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--colour --format documentation']
+end
+
+desc "Create tag v#{Pagoda::Tunnel::VERSION}"
+task :tag do
+  
+  puts "tagging version v#{Pagoda::Tunnel::VERSION}"
+  `git tag -a v#{Pagoda::Tunnel::VERSION} -m "Version #{Pagoda::Tunnel::VERSION}"`
+  `git push origin --tags`
+  
+end

data/lib/pagoda-tunnel.rb

@@ -0,0 +1,157 @@
+require 'timeout'
+require 'socket'
+require 'openssl'  
+
+module Pagoda
+  class Tunnel
+    VERSION = "0.1.0"
+    # Your code goes here...
+
+    def initialize(type, user, pass, app, instance, port = 3306)
+      @type     = type
+      @user     = user
+      @pass     = pass
+      @app      = app
+      @instance = instance
+      @port     = port
+    end
+
+    def port_available?(ip, port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return false
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return true
+          end
+        end
+      rescue Timeout::Error
+      end
+      return true
+    end
+
+    def next_available_port(start_port)
+      until port_available?("0.0.0.0", start_port)
+        # puts "port #{start_port} was not available"
+        start_port += 1
+      end
+      start_port
+    end
+    
+    def start
+      
+      [:INT, :TERM].each do |sig|
+        Signal.trap(sig) do
+          puts "Tunnel Closed."
+          puts "-----------------------------------------------"
+          puts
+          exit
+        end
+      end
+      
+      remote_host = "tunnel.pagodabox.com" # switch to tunnel.pagodabox.com
+      remote_port = 443
+
+      max_threads     = 20
+      threads         = []
+
+      chunk           = 4096*4096
+
+      # puts "start TCP server"
+      # puts "+> Opening Tunnel"
+      @port = next_available_port(@port)
+      retrys = 0
+      begin
+        proxy_server = TCPServer.new('0.0.0.0', @port)
+      rescue Exception => e
+        @port += 1
+        retry if retrys < 4
+        # puts "unable to connect to #{@port}. The algorithm is broken"
+        exit
+      end
+      
+      puts
+      puts "Tunnel Established!  Accepting connections on :"
+      puts "-----------------------------------------------"
+      puts
+      puts "HOST : 127.0.0.1 (or localhost)"
+      puts "PORT : #{@port}"
+      puts "USER : (found in pagodabox dashboard)"
+      puts "PASS : (found in pagodabox dashboard)"
+      puts
+      puts "-----------------------------------------------"
+      puts "(note : ctrl-c To close this tunnel)"
+      
+      loop do
+
+        # puts "start a new thread for every client connection"
+        threads << Thread.new(proxy_server.accept) do |client_socket|
+          begin
+            # puts "client connection"
+            begin
+              server_socket         = TCPSocket.new(remote_host, remote_port)
+              ssl_context           = OpenSSL::SSL::SSLContext.new()  
+              ssl_socket            = OpenSSL::SSL::SSLSocket.new(server_socket, ssl_context)
+              ssl_socket.sync_close = true
+              ssl_socket.connect
+            rescue Errno::ECONNREFUSED
+              # puts "connection refused"
+              client_socket.close
+              raise
+            end
+
+            # puts "authenticate"
+            if ssl_socket.readpartial(chunk) == "auth"
+              # puts "authentication"
+              # puts "auth=#{@type}:#{@user}:#{@pass}:#{@app}:#{@instance}" 
+              ssl_socket.write "auth=#{@type}:#{@user}:#{@pass}:#{@app}:#{@instance}" 
+              if ssl_socket.readpartial(chunk) == "success"
+                # puts "successful connection"
+              else
+                # puts "failed connection"
+              end
+            else
+              # puts "danger will robbinson! abort!"
+            end
+
+            loop do
+              # puts "wait for data on either socket"
+              (ready_sockets, dummy, dummy) = IO.select([client_socket, ssl_socket])
+
+              # puts "full duplex connection until data stream ends"
+              begin
+                ready_sockets.each do |socket|
+                  data = socket.readpartial(chunk)
+                  if socket == client_socket
+                    # puts "SERVER <== CLIENT"
+                    ssl_socket.write data
+                    ssl_socket.flush
+                  else
+                    # puts "SERVER ==> CLIENT"
+                    client_socket.write data
+                    client_socket.flush
+                  end
+                end
+              rescue EOFError
+                break
+              end
+            end
+
+          rescue StandardError => error
+          end
+          client_socket.close rescue StandardError
+          ssl_socket.close rescue StandardError
+        end
+
+        # puts "clean up the dead threads, and wait until we have available threads"
+        threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
+        while threads.size >= max_threads
+          sleep 1
+          threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
+        end
+      end
+    end
+  end
+end

data/pagoda-tunnel.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pagoda-tunnel"
+
+Gem::Specification.new do |s|
+  s.name        = "pagoda-tunnel"
+  s.version     = Pagoda::Tunnel::VERSION
+  s.authors     = ["Lyon"]
+  s.email       = ["lyon@delorum.com"]
+  s.homepage    = "http://www.pagodabox.com"
+  s.summary     = %q{Pagodabox Tunnel gem}
+  s.description = %q{Pagodabox container tunnel. Allows users to tunnel into pagodabox db's.}
+
+  s.rubyforge_project = "pagoda-tunnel"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Development
+  s.add_development_dependency "rspec"
+  # s.add_development_dependency "simplecov"
+
+
+
+  # Production
+  s.add_dependency "rest-client"
+
+
+end

data/spec/tunnel_spec.rb

@@ -0,0 +1,34 @@
+
+require 'pagoda-tunnel'
+
+describe Pagoda::Tunnel do
+
+  it "can create a connection" do
+    tunnel = Pagoda::Tunnel.new(nil,nil,nil,nil,nil)
+  end
+
+  it "cannot find an open port" do
+    tunnel = Pagoda::Tunnel.new(nil,nil,nil,nil,nil)
+    tunnel.port_available?("0.0.0.0", 3309).should == true
+  end
+
+  it "finds an open port" do
+    sock = TCPServer.new("0.0.0.0", 40000)
+    tunnel = Pagoda::Tunnel.new(nil,nil,nil,nil,nil)
+    tunnel.port_available?("0.0.0.0", 40000).should == false
+    sock.close
+  end
+
+  it "searches until it finds an available port" do
+    tunnel = Pagoda::Tunnel.new(nil,nil,nil,nil,nil)
+    tunnel.should_receive(:port_available?).with("0.0.0.0", 40000).and_return false
+    tunnel.should_receive(:port_available?).with("0.0.0.0", 40001).and_return false
+    tunnel.should_receive(:port_available?).with("0.0.0.0", 40002).and_return false
+    tunnel.should_receive(:port_available?).with("0.0.0.0", 40003).and_return true
+    STDOUT.stub(:puts)
+    tunnel.next_available_port(40000).should == 40003
+  end
+
+  it "needs more testing"
+  
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: pagoda-tunnel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156757880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156757880
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &2156757260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156757260
+description: Pagodabox container tunnel. Allows users to tunnel into pagodabox db's.
+email:
+- lyon@delorum.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/pagoda-tunnel.rb
+- pagoda-tunnel.gemspec
+- spec/tunnel_spec.rb
+homepage: http://www.pagodabox.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: pagoda-tunnel
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Pagodabox Tunnel gem
+test_files:
+- spec/tunnel_spec.rb