fizx-proxymachine 1.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/History.txt

@@ -0,0 +1,22 @@
+= 1.1.0 / 2009-11-05
+  * New Features
+    * Add { :remote, :data, :reply } command [github.com/coderrr]
+  * Minor Changes
+    * Namespace connection classes under ProxyMachine instead of EM [github.com/cmelbye]
+    * Require socket [github.com/cmelbye]
+    * Up EM dep to 0.12.10
+    * Add SOCKS4 Proxy example [github.com/coderrr]
+
+= 1.0.0 / 2009-10-19
+  * No changes. Production ready!
+
+= 0.2.8 / 2009-10-14
+  * Minor changes
+    * Always log proxy connection
+    * Add version and total connection count to procline
+    * Add max connection count to procline
+    * Use Logger for logging
+
+= 0.2.7 / 2009-10-12
+  * Minor changes
+    * Use a 10k buffer to prevent memory growth due to slow clients

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tom Preston-Werner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+ProxyMachine
+============
+
+By Tom Preston-Werner (tom@mojombo.com)
+
+
+Description
+-----------
+
+ProxyMachine is a simple content aware (layer 7) TCP routing proxy built on
+EventMachine that lets you configure the routing logic in Ruby.
+
+If you need to proxy connections to different backend servers depending on the
+contents of the transmission, then ProxyMachine will make your life easy!
+
+The idea here is simple. For each client connection, start receiving data
+chunks and placing them into a buffer. Each time a new chunk arrives, send the
+buffer to a user specified block. The block's job is to parse the buffer to
+determine where the connection should be proxied. If the buffer contains
+enough data to make a determination, the block returns the address and port of
+the correct backend server. If not, it can choose to do nothing and wait for
+more data to arrive, close the connection, or close the connection after
+sending custom data. Once the block returns an address, a connection to the
+backend is made, the buffer is replayed to the backend, and the client and
+backend connections are hooked up to form a transparent proxy. This
+bidirectional proxy continues to exist until either the client or backend
+close the connection.
+
+ProxyMachine was developed for GitHub's federated architecture and is
+successfully used in production to proxy millions of requests every day. The
+performance and memory profile have both proven to be excellent.
+
+
+Installation
+------------
+
+    $ gem install proxymachine -s http://gemcutter.org
+
+
+Running
+-------
+
+    Usage:
+      proxymachine -c <config file> [-h <host>] [-p <port>]
+
+    Options:
+      -c, --config CONFIG              Configuration file
+      -h, --host HOST                  Hostname to bind. Default 0.0.0.0
+      -p, --port PORT                  Port to listen on. Default 5432
+
+
+Signals
+-------
+
+    QUIT - Graceful shutdown. Stop accepting connections immediately and
+           wait as long as necessary for all connections to close.
+
+    TERM - Fast shutdown. Stop accepting connections immediately and wait
+           up to 10 seconds for connections to close before forcing
+           termination.
+
+    INT  - Same as TERM
+
+
+Example routing config file
+---------------------------
+
+    class GitRouter
+      # Look at the routing table and return the correct address for +name+
+      # Returns "<host>:<port>" e.g. "ae8f31c.example.com:9418"
+      def self.lookup(name)
+        ...
+      end
+    end
+
+    # Perform content-aware routing based on the stream data. Here, the
+    # header information from the Git protocol is parsed to find the 
+    # username and a lookup routine is run on the name to find the correct
+    # backend server. If no match can be made yet, do nothing with the
+    # connection.
+    proxy do |data|
+      if data =~ %r{^....git-upload-pack /([\w\.\-]+)/[\w\.\-]+\000host=\w+\000}
+        name = $1
+        { :remote => GitRouter.lookup(name) }
+      else
+        { :noop => true }
+      end
+    end
+
+
+Example SOCKS4 Proxy in 7 Lines
+-------------------------------
+
+    proxy do |data|
+      return  if data.size < 9
+      v, c, port, o1, o2, o3, o4, user = data.unpack("CCnC4a*")
+      return { :close => "\0\x5b\0\0\0\0\0\0" }  if v != 4 or c != 1
+      return  if ! idx = user.index("\0")
+      { :remote => "#{[o1,o2,o3,o4]*'.'}:#{port}",
+        :reply => "\0\x5a\0\0\0\0\0\0",
+        :data => data[idx+9..-1] }
+    end
+
+
+Valid return values
+-------------------
+
+`{ :remote => String }` - String is the host:port of the backend server that will be proxied.  
+`{ :remote => String, :data => String }` - Same as above, but send the given data instead.  
+`{ :remote => String, :data => String, :reply => String}` - Same as above, but reply with given data back to the client
+`{ :noop => true }` - Do nothing.  
+`{ :close => true }` - Close the connection.  
+`{ :close => String }` - Close the connection after sending the String.  
+
+
+Contribute
+----------
+
+If you'd like to hack on ProxyMachine, start by forking my repo on GitHub:
+
+http://github.com/mojombo/proxymachine
+
+To get all of the dependencies, install the gem first. The best way to get
+your changes merged back into core is as follows:
+
+1. Clone down your fork
+1. Create a topic branch to contain your change
+1. Hack away
+1. Add tests and make sure everything still passes by running `rake`
+1. If you are adding new functionality, document it in the README.md
+1. Do not change the version number, I will do that on my end
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send me (mojombo) a pull request for your branch
+
+
+Copyright
+---------
+
+Copyright (c) 2009 Tom Preston-Werner. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fizx-proxymachine"
+    gem.summary = %Q{ProxyMachine is a simple content aware (layer 7) TCP routing proxy.}
+    gem.email = "tom@mojombo.com"
+    gem.homepage = "http://github.com/fizx/proxymachine"
+    gem.authors = ["Tom Preston-Werner", "Kyle Maxwell"]
+    gem.add_dependency('eventmachine', '>= 0.12.10')
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "proxymachine #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:build: 
+:major: 1
+:minor: 2
+:patch: 0

data/bin/proxymachine

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'optparse'
+require 'proxymachine'
+
+begin
+  options = {:host => "0.0.0.0", :port => 5432}
+
+  opts = OptionParser.new do |opts|
+    opts.banner = <<-EOF
+  Usage:
+    proxymachine -c <config file> [-h <host>] [-p <port>]
+
+  Options:
+EOF
+
+    opts.on("-cCONFIG", "--config CONFIG", "Configuration file") do |x|
+      options[:config] = x
+    end
+
+    opts.on("-hHOST", "--host HOST", "Hostname to bind. Default 0.0.0.0") do |x|
+      options[:host] = x
+    end
+
+    opts.on("-pPORT", "--port PORT", "Port to listen on. Default 5432") do |x|
+      options[:port] = x
+    end
+  end
+
+  opts.parse!
+
+  load(options[:config])
+  name = options[:config].split('/').last.chomp('.rb')
+  ProxyMachine.run(name, options[:host], options[:port])
+rescue Exception => e
+  if e.instance_of?(SystemExit)
+    raise
+  else
+    LOGGER.info 'Uncaught exception'
+    LOGGER.info e.message
+    LOGGER.info e.backtrace.join("\n")
+  end
+end

data/examples/git.rb

@@ -0,0 +1,26 @@
+# This is a config file for ProxyMachine. It pulls the username out of
+# the Git stream and can proxy to different locations based on that value
+# Run with `proxymachine -c examples/git.rb`
+
+class GitRouter
+  # Look at the routing table and return the correct address for +name+
+  # Returns "<host>:<port>" e.g. "ae8f31c.example.com:9418"
+  def self.lookup(name)
+    LOGGER.info "Proxying for user #{name}"
+    "localhost:9418"
+  end
+end
+
+# Perform content-aware routing based on the stream data. Here, the
+# header information from the Git protocol is parsed to find the
+# username and a lookup routine is run on the name to find the correct
+# backend server. If no match can be made yet, do nothing with the
+# connection yet.
+proxy do |data|
+  if data =~ %r{^....git-upload-pack /([\w\.\-]+)/[\w\.\-]+\000host=(.+)\000}
+    name, host = $1, $2
+    { :remote => GitRouter.lookup(name) }
+  else
+    { :noop => true }
+  end
+end

data/examples/long.rb

@@ -0,0 +1,9 @@
+# To try out the graceful exit via SIGQUIT, start up a proxymachine with this
+# configuration, and run the following curl command a few times:
+#     curl http://localhost:5432/ubuntu-releases/9.10/ubuntu-9.10-beta-alternate-amd64.iso \
+#     -H "Host: mirrors.cat.pdx.edu" > /dev/null
+# Then send a SIGQUIT to the process and stop the long downloads one by one.
+
+proxy do |data|
+  { :remote => "mirrors.cat.pdx.edu:80" }
+end

data/examples/transparent.rb

@@ -0,0 +1,4 @@
+proxy do |data|
+  # p data
+  { :remote => "google.com:80" }
+end

data/fizx-proxymachine.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fizx-proxymachine}
+  s.version = "1.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Preston-Werner", "Kyle Maxwell"]
+  s.date = %q{2010-01-10}
+  s.default_executable = %q{proxymachine}
+  s.email = %q{tom@mojombo.com}
+  s.executables = ["proxymachine"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION.yml",
+     "bin/proxymachine",
+     "examples/git.rb",
+     "examples/long.rb",
+     "examples/transparent.rb",
+     "fizx-proxymachine.gemspec",
+     "lib/fizx_proxymachine.rb",
+     "lib/proxymachine.rb",
+     "lib/proxymachine/callback_server_connection.rb",
+     "lib/proxymachine/client_connection.rb",
+     "lib/proxymachine/server_connection.rb",
+     "test/configs/simple.rb",
+     "test/proxymachine_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/fizx/proxymachine}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ProxyMachine is a simple content aware (layer 7) TCP routing proxy.}
+  s.test_files = [
+    "test/configs/simple.rb",
+     "test/proxymachine_test.rb",
+     "test/test_helper.rb",
+     "examples/git.rb",
+     "examples/long.rb",
+     "examples/transparent.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.10"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+  end
+end
+

data/lib/fizx_proxymachine.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/proxymachine"

data/lib/proxymachine.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'eventmachine'
+require 'logger'
+require 'socket'
+
+require 'proxymachine/client_connection'
+require 'proxymachine/server_connection'
+require 'proxymachine/callback_server_connection'
+
+LOGGER = Logger.new(STDOUT)
+
+class ProxyMachine
+  MAX_FAST_SHUTDOWN_SECONDS = 10
+
+  def self.update_procline
+    $0 = "proxymachine #{VERSION} - #{@@name} #{@@listen} - #{self.stats} cur/max/tot conns"
+  end
+
+  def self.stats
+    "#{@@counter}/#{@@maxcounter}/#{@@totalcounter}"
+  end
+
+  def self.count
+    @@counter
+  end
+
+  def self.incr
+    @@totalcounter += 1
+    @@counter += 1
+    @@maxcounter = @@counter if @@counter > @@maxcounter
+    self.update_procline
+    @@counter
+  end
+
+  def self.decr
+    @@counter -= 1
+    if $server.nil?
+      LOGGER.info "Waiting for #{@@counter} connections to finish."
+    end
+    self.update_procline
+    EM.stop if $server.nil? and @@counter == 0
+    @@counter
+  end
+
+  def self.set_router(block)
+    @@router = block
+  end
+
+  def self.router
+    @@router
+  end
+
+  def self.graceful_shutdown(signal)
+    EM.stop_server($server) if $server
+    LOGGER.info "Received #{signal} signal. No longer accepting new connections."
+    LOGGER.info "Waiting for #{ProxyMachine.count} connections to finish."
+    $server = nil
+    EM.stop if ProxyMachine.count == 0
+  end
+
+  def self.fast_shutdown(signal)
+    EM.stop_server($server) if $server
+    LOGGER.info "Received #{signal} signal. No longer accepting new connections."
+    LOGGER.info "Maximum time to wait for connections is #{MAX_FAST_SHUTDOWN_SECONDS} seconds."
+    LOGGER.info "Waiting for #{ProxyMachine.count} connections to finish."
+    $server = nil
+    EM.stop if ProxyMachine.count == 0
+    Thread.new do
+      sleep MAX_FAST_SHUTDOWN_SECONDS
+      exit!
+    end
+  end
+
+  def self.run(name, host, port)
+    @@totalcounter = 0
+    @@maxcounter = 0
+    @@counter = 0
+    @@name = name
+    @@listen = "#{host}:#{port}"
+    self.update_procline
+    EM.epoll
+
+    EM.run do
+      ProxyMachine::ClientConnection.start(host, port)
+      trap('QUIT') do
+        self.graceful_shutdown('QUIT')
+      end
+      trap('TERM') do
+        self.fast_shutdown('TERM')
+      end
+      trap('INT') do
+        self.fast_shutdown('INT')
+      end
+    end
+  end
+
+  def self.version
+    yml = YAML.load(File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION.yml])))
+    "#{yml[:major]}.#{yml[:minor]}.#{yml[:patch]}"
+  rescue
+    'unknown'
+  end
+
+  VERSION = self.version
+end
+
+module Kernel
+  def proxy(&block)
+    ProxyMachine.set_router(block)
+  end
+end

data/lib/proxymachine/callback_server_connection.rb

@@ -0,0 +1,27 @@
+class ProxyMachine
+  class CallbackServerConnection < ServerConnection
+    
+    def post_init
+      # empty
+    end
+    
+    def callback=(c)
+      @callback = c
+    end
+    
+    def receive_data(data)
+      @buffer ||= []
+      @buffer << data
+      if returned = @callback.call(@buffer.join(''))
+        proxy_incoming_to(@client_side, 10240)
+        @client_side.send_data returned
+      end
+    rescue => e
+      LOGGER.info e.message + e.backtrace.join("\n")
+    end
+
+    def unbind
+      @client_side.close_connection_after_writing
+    end
+  end
+end

data/lib/proxymachine/client_connection.rb

@@ -0,0 +1,108 @@
+class ProxyMachine
+  class ClientConnection < EventMachine::Connection
+    def self.start(host, port)
+      $server = EM.start_server(host, port, self)
+      LOGGER.info "Listening on #{host}:#{port}"
+      LOGGER.info "Send QUIT to quit after waiting for all connections to finish."
+      LOGGER.info "Send TERM or INT to quit after waiting for up to 10 seconds for connections to finish."
+    end
+
+    def post_init
+      LOGGER.info "Accepted #{peer}"
+      @buffer = []
+      @tries = 0
+      ProxyMachine.incr
+    end
+
+    def peer
+      @peer ||=
+      begin
+        port, ip = Socket.unpack_sockaddr_in(get_peername)
+        "#{ip}:#{port}"
+      end
+    end
+
+    def receive_data(data)
+      if !@server_side
+        @buffer << data
+        ensure_server_side_connection
+      end
+    rescue => e
+      close_connection
+      LOGGER.info "#{e.class} - #{e.message}"
+    end
+
+    def ensure_server_side_connection
+      @timer.cancel if @timer
+      unless @server_side
+        commands = ProxyMachine.router.call(@buffer.join)
+        LOGGER.info "#{peer} #{commands.inspect}"
+        close_connection unless commands.instance_of?(Hash)
+        if remote = commands[:remote]
+          m, host, port = *remote.match(/^(.+):(.+)$/)
+          klass = commands[:callback] ? CallbackServerConnection : ServerConnection
+          if try_server_connect(host, port.to_i, klass)
+            @server_side.callback = commands[:callback] if commands[:callback]
+            
+            if data = commands[:data]
+              @buffer = [data]
+            end
+            if reply = commands[:reply]
+              send_data(reply)
+            end
+            send_and_clear_buffer
+          end
+        elsif close = commands[:close]
+          if close == true
+            close_connection
+          else
+            send_data(close)
+            close_connection_after_writing
+          end
+        elsif commands[:noop]
+          # do nothing
+        else
+          close_connection
+        end
+      end
+    end
+
+    def try_server_connect(host, port, klass)
+      @server_side = klass.request(host, port, self)
+      proxy_incoming_to(@server_side, 10240)
+      LOGGER.info "Successful connection to #{host}:#{port}."
+      true
+    rescue => e
+      if @tries < 10
+        @tries += 1
+        LOGGER.info "Failed on server connect attempt #{@tries}. Trying again..."
+        @timer.cancel if @timer
+        @timer = EventMachine::Timer.new(0.1) do
+          self.ensure_server_side_connection
+        end
+      else
+        LOGGER.info "Failed after ten connection attempts."
+      end
+      false
+    end
+
+    def send_and_clear_buffer
+      if !@buffer.empty?
+        @buffer.each do |x|
+          @server_side.send_data(x)
+        end
+        @buffer = []
+      end
+    end
+
+    def unbind
+      @server_side.close_connection_after_writing if @server_side
+      ProxyMachine.decr
+    end
+
+    # Proxy connection has been lost
+    def proxy_target_unbound
+      @server_side = nil
+    end
+  end
+end

data/lib/proxymachine/server_connection.rb

@@ -0,0 +1,19 @@
+class ProxyMachine
+  class ServerConnection < EventMachine::Connection
+    def self.request(host, port, client_side)
+      EventMachine.connect(host, port, self, client_side)
+    end
+
+    def initialize(conn)
+      @client_side = conn
+    end
+
+    def post_init
+      proxy_incoming_to(@client_side, 10240)
+    end
+
+    def unbind
+      @client_side.close_connection_after_writing
+    end
+  end
+end

data/test/configs/simple.rb

@@ -0,0 +1,27 @@
+LOGGER = Logger.new(File.new('/dev/null', 'w'))
+
+callback = proc do |data|
+  data + ":callback"
+end
+
+proxy do |data|
+  if data == 'a'
+    { :remote => "localhost:9980" }
+  elsif data == 'b'
+    { :remote => "localhost:9981" }
+  elsif data == 'c'
+    { :remote => "localhost:9980", :data => 'ccc' }
+  elsif data == 'd'
+    { :close => 'ddd' }
+  elsif data == 'e' * 2048
+    { :noop => true }
+  elsif data == 'e' * 2048 + 'f'
+    { :remote => "localhost:9980" }
+  elsif data == 'g'
+    { :remote => "localhost:9980", :data => 'g2', :reply => 'g3-' }
+  elsif data == 'h'
+    { :remote => "localhost:9980", :callback => callback }
+  else
+    { :close => true }
+  end
+end

data/test/proxymachine_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+def assert_proxy(host, port, send, recv)
+  sock = TCPSocket.new(host, port)
+  sock.write(send)
+  assert_equal recv, sock.read
+  sock.close
+end
+
+class ProxymachineTest < Test::Unit::TestCase
+  should "handle simple routing" do
+    assert_proxy('localhost', 9990, 'a', '9980:a')
+    assert_proxy('localhost', 9990, 'b', '9981:b')
+  end
+
+  should "handle connection closing" do
+    sock = TCPSocket.new('localhost', 9990)
+    sock.write('xxx')
+    assert_equal nil, sock.read(1)
+    sock.close
+  end
+
+  should "handle rewrite routing" do
+    assert_proxy('localhost', 9990, 'c', '9980:ccc')
+  end
+
+  should "handle rewrite closing" do
+    assert_proxy('localhost', 9990, 'd', 'ddd')
+  end
+
+  should "handle data plus reply" do
+    assert_proxy('localhost', 9990, 'g', 'g3-9980:g2')
+  end
+
+  should "handle noop" do
+    sock = TCPSocket.new('localhost', 9990)
+    sock.write('e' * 2048)
+    sock.flush
+    sock.write('f')
+    assert_equal '9980:' + 'e' * 2048 + 'f', sock.read
+    sock.close
+  end
+
+  should "execute a callback" do
+    assert_proxy('localhost', 9990, 'h', '9980:h:callback')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'socket'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'proxymachine'
+
+# A simple echo server to use in tests
+module EventMachine
+  module Protocols
+    class TestConnection < Connection
+      def self.start(host, port)
+        @@port = port
+        EM.start_server(host, port, self)
+      end
+
+      def receive_data(data)
+        send_data("#{@@port}:#{data}")
+        close_connection_after_writing
+      end
+    end
+  end
+end
+
+def harikari(ppid)
+  Thread.new do
+    loop do
+      begin
+        Process.kill(0, ppid)
+      rescue
+        exit
+      end
+      sleep 1
+    end
+  end
+end
+
+ppid = Process.pid
+
+# Start the simple proxymachine
+fork do
+  harikari(ppid)
+  load(File.join(File.dirname(__FILE__), *%w[configs simple.rb]))
+  ProxyMachine.run('simple', 'localhost', 9990)
+end
+
+# Start two test daemons
+[9980, 9981].each do |port|
+  fork do
+    harikari(ppid)
+    EM.run do
+      EventMachine::Protocols::TestConnection.start('localhost', port)
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: fizx-proxymachine
+version: !ruby/object:Gem::Version 
+  version: 1.2.0
+platform: ruby
+authors: 
+- Tom Preston-Werner
+- Kyle Maxwell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-10 00:00:00 -08:00
+default_executable: proxymachine
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.10
+    version: 
+description: 
+email: tom@mojombo.com
+executables: 
+- proxymachine
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- History.txt
+- LICENSE
+- README.md
+- Rakefile
+- VERSION.yml
+- bin/proxymachine
+- examples/git.rb
+- examples/long.rb
+- examples/transparent.rb
+- fizx-proxymachine.gemspec
+- lib/fizx_proxymachine.rb
+- lib/proxymachine.rb
+- lib/proxymachine/callback_server_connection.rb
+- lib/proxymachine/client_connection.rb
+- lib/proxymachine/server_connection.rb
+- test/configs/simple.rb
+- test/proxymachine_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/fizx/proxymachine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ProxyMachine is a simple content aware (layer 7) TCP routing proxy.
+test_files: 
+- test/configs/simple.rb
+- test/proxymachine_test.rb
+- test/test_helper.rb
+- examples/git.rb
+- examples/long.rb
+- examples/transparent.rb