spider-gazelle 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3081d50c47f8dd30b20deca6f8ff4ab4f6b96b04
+  data.tar.gz: 6d33aab9f1fe72354d919b59d6232918cd452c2b
+SHA512:
+  metadata.gz: fe5cc932cb5a8616da336f5806ff8c46ae7fba0743f42e688d9e9c6a3e9371c05cf1a01081e3f077283a9b8c35b4c93263e75fb6875a7039ef030aaf4314704e
+  data.tar.gz: 1a1ef9210f7edd32884f5e7dba6f7257ff8c4c33b2ee18ab83a2f209e48aa5bc13cf0a455b61316cd7d78702cf0f9b2d89cb41f57f5d9247711b390cdc662f79

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 CoTag Media
+
+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,9 @@
+spider-gazelle
+==============
+
+A fast, parallel and concurrent web server for ruby
+
+Spidergazelle, spidergazelle amazingly agile, she leaps through the veldt, 
+Spidergazelle, spidergazelle! She don’t care what you think, she says what the hell!
+Look out! Here comes the Spidergazelle!
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+task :default => [:test]
+
+RSpec::Core::RakeTask.new(:test)

data/bin/sg

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+
+require 'spider-gazelle'
+require 'optparse'
+
+
+options = {
+    Host: "0.0.0.0",
+    Port: 3000,
+    environment: ENV['RACK_ENV'] || 'development',
+    rackup: "#{Dir.pwd}/config.ru"
+}
+
+parser = OptionParser.new do |opts|
+    opts.on "-p", "--port PORT", Integer, "Define what port TCP port to bind to (default: 3000)" do |arg|
+        options[:Port] = arg
+    end
+
+    opts.on "-a", "--address HOST", "bind to HOST address (default: 0.0.0.0)" do |arg|
+        options[:Host] = arg
+    end
+
+    opts.on "-q", "--quiet", "Quiet down the output" do
+        options[:Quiet] = true
+    end
+
+    opts.on "-e", "--environment ENVIRONMENT", "The environment to run the Rack app on (default: development)" do |arg|
+        options[:environment] = arg
+    end
+
+    opts.on "-r", "--rackup FILE", "Load Rack config from this file (default: config.ru)" do |arg|
+        options[:rackup] = arg
+    end
+end
+
+parser.banner = "sg <options> <rackup file>"
+parser.on_tail "-h", "--help", "Show help" do
+    puts parser
+    exit 1
+end
+
+parser.parse!(ARGV)
+
+if ARGV.last =~ /\.ru$/
+    options[:rackup] = ARGV.shift
+end
+
+unless File.exists?(options[:rackup])
+    abort "No rackup found at #{options[:rackup]}"
+end
+
+app, rack_options = Rack::Builder.parse_file options[:rackup]
+server = ::SpiderGazelle::Spider.new(app, options)
+
+puts "Look out! Here comes Spider-Gazelle #{::SpiderGazelle::VERSION}!"
+puts "* Environment: #{ENV['RACK_ENV']}"
+puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+
+begin
+    server.run
+ensure
+    puts "\nSpider-Gazelle leaps through the veldt"
+end

data/lib/rack/handler/spider-gazelle.rb

@@ -0,0 +1,47 @@
+require 'rack/handler'
+require 'spider-gazelle'
+
+
+module Rack
+	module Handler
+	    module SpiderGazelle
+			DEFAULT_OPTIONS = {
+				:Host => '0.0.0.0',
+				:Port => 8080,
+				:Verbose => false
+			}
+
+	    	def self.run(app, options = {})
+	    		options = DEFAULT_OPTIONS.merge(options)
+
+	    		if options[:Verbose]
+	    			app = Rack::CommonLogger.new(app, STDOUT)
+	    		end
+
+	    		if options[:environment]
+	    			ENV['RACK_ENV'] = options[:environment].to_s
+	    		end
+
+	    		server = ::SpiderGazelle::Spider.new(app, options)
+
+	    		puts "Spider-Gazelle #{::SpiderGazelle::VERSION} starting..."
+	    		puts "* Environment: #{ENV['RACK_ENV']}"
+	    		puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+
+	    		yield server if block_given?
+
+	    		server.run
+	    	end
+
+			def self.valid_options
+				{
+					"Host=HOST"       => "Hostname to listen on (default: 0.0.0.0)",
+					"Port=PORT"       => "Port to listen on (default: 8080)",
+					"Quiet"           => "Don't report each request"
+				}
+			end
+	    end
+
+	    register :sg, SpiderGazelle
+	end
+end

data/lib/spider-gazelle/connection.rb

@@ -0,0 +1,104 @@
+require 'stringio'
+
+
+module SpiderGazelle
+    class Connection
+
+
+        SET_INSTANCE_TYPE = proc {|inst| inst.type = :request}
+
+
+        attr_reader :state, :parsing
+        attr_accessor :queue_worker
+
+
+        def initialize(loop, socket, queue) # TODO:: port information
+            # A single parser instance per-connection (supports pipelining)
+            @state = ::HttpParser::Parser.new_instance &SET_INSTANCE_TYPE
+            @pending = []
+
+            # Work callback for thread pool processing
+            @request = nil
+            @work = method(:work)
+
+            # Called after the work on the thread pool is complete
+            @send_response = method(:send_response)
+            @send_error = method(:send_error)
+
+            # Used to chain promises (ensures requests are processed in order)
+            @process_next = method(:process_next)
+            @current_worker = queue # keep track of work queue head to prevent unintentional GC
+            @queue_worker = queue   # start queue with an existing resolved promise (::Libuv::Q::ResolvedPromise.new(@loop, true))
+            
+            # Socket for writing the response
+            @socket = socket
+            @loop = loop
+        end
+
+        # Creates a new request state object
+        def start_parsing(request)
+            @parsing = request
+        end
+
+        # Chains the work in a promise queue
+        def finished_parsing
+            if !@state.keep_alive?
+                @parsing.keep_alive = false
+                @socket.stop_read   # we don't want to do any more work then we need to
+            end
+            @parsing.upgrade = @state.upgrade?
+            @pending.push @parsing
+            @queue_worker = @queue_worker.then @process_next
+        end
+
+        # The parser encountered an error
+        def parsing_error
+            # TODO::log error (available in the @request object)
+            p "parsing error #{@state.error}"
+
+            # We no longer care for any further requests from this client
+            # however we will finish processing any valid pipelined requests before shutting down
+            @socket.stop_read
+            @queue_worker = @queue_worker.then do
+                # TODO:: send response (400 bad request)
+                @socket.shutdown
+            end
+        end
+
+
+        protected
+
+
+        def send_response(result)
+            # As we have come back from another thread the socket may have closed
+            # This check is an optimisation, the call to write and shutdown would fail safely
+            if !@socket.closed
+                @socket.write @request.response
+                if @request.keep_alive == false
+                    @socket.shutdown
+                end
+            end
+            # continue processing (don't wait for write to complete)
+            # if the write fails it will close the socket
+            nil
+        end
+
+        def send_error(reason)
+            p "send error: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+            # log error reason
+            # TODO:: send response (500 internal error)
+            # no need to close the socket as this isn't fatal
+            nil
+        end
+
+        def process_next(result)
+            @request = @pending.shift
+            @current_worker = @loop.work @work
+            @current_worker.then @send_response, @send_error   # resolves the promise with a promise
+        end
+
+        def work
+            @request.execute!
+        end
+    end
+end

data/lib/spider-gazelle/error.rb

@@ -0,0 +1,16 @@
+
+module SpiderGazelle
+    module Error
+
+        # Indicate that we couldn't parse the request
+        ERROR_400_RESPONSE = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n".freeze
+
+        # The standard empty 404 response for bad requests.
+        ERROR_404_RESPONSE = "HTTP/1.1 404 Not Found\r\n\r\nNOT FOUND".freeze
+
+        # Indicate that there was an internal error, obviously.
+        ERROR_500_RESPONSE = "HTTP/1.1 500 Internal Server Error\r\n\r\n".freeze
+
+
+    end
+end

data/lib/spider-gazelle/gazelle.rb

@@ -0,0 +1,144 @@
+require 'set'
+
+
+module SpiderGazelle
+    class Gazelle
+
+
+        HTTP_META = 'HTTP_'.freeze
+        REQUEST_METHOD = 'REQUEST_METHOD'.freeze    # GET, POST, etc
+
+
+        def initialize(app, options)
+            @gazelle = Libuv::Loop.new
+            @connections = Set.new      # Set of active connections on this thread
+            @parser_cache = []      	# Stale parser objects cached for reuse
+            @connection_queue = ::Libuv::Q::ResolvedPromise.new(@gazelle, true)
+
+            @app = app
+            @options = options
+
+            # A single parser instance for processing requests for each gazelle
+            @parser = ::HttpParser::Parser.new(self)
+
+            # Single progress callback for each gazelle
+            @on_progress = method(:on_progress)
+        end
+
+        def run
+            @gazelle.run do |logger|
+                logger.progress do |level, errorid, error|
+                    begin
+                        p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+                    rescue Exception
+                        p 'error in gazelle logger'
+                    end
+                end
+
+                # A pipe used to forward connections to different threads
+                @socket_server = @gazelle.pipe(true)
+                @socket_server.connect(DELEGATE_PIPE) do
+                    @socket_server.progress do |data, socket|
+                        new_connection(socket)
+                    end
+                    @socket_server.start_read2
+                end
+
+                # A pipe used to signal various control commands (shutdown, etc)
+                @signal_server = @gazelle.pipe
+                @signal_server.connect(SIGNAL_PIPE) do
+                    @signal_server.progress do |data|
+                        process_signal(data)
+                    end
+                    @signal_server.start_read
+                end
+            end
+        end
+
+
+        # HTTP Parser callbacks:
+        def on_message_begin(parser)
+            @connection.start_parsing(Request.new(@app, @options))
+        end
+
+        def on_url(parser, url)
+            @connection.parsing.url << url
+        end
+
+        def on_header_field(parser, header)
+            req = @connection.parsing
+            if req.header.frozen?
+                req.header = header
+            else
+                req.header << header
+            end
+        end
+
+        def on_header_value(parser, value)
+            req = @connection.parsing
+            if req.header.frozen?
+                req.env[req.header] << value
+            else
+                header = req.header
+                header.upcase!
+                header.gsub!('-', '_')
+                header.prepend(HTTP_META)
+                header.freeze
+                req.env[header] = value
+            end
+        end
+
+        def on_headers_complete(parser)
+            @connection.parsing.env[REQUEST_METHOD] = @connection.state.http_method.to_s
+        end
+
+        def on_body(parser, data)
+            @connection.parsing.body << data
+        end
+
+        def on_message_complete(parser)
+            @connection.finished_parsing
+        end
+
+
+        protected
+
+
+        def on_progress(data, socket)
+            # Keep track of which connection we are processing for the callbacks
+            @connection = socket.storage
+
+            # Check for errors during the parsing of the request
+            if @parser.parse(@connection.state, data)
+                @connection.parsing_error
+            end
+        end
+
+        def new_connection(socket)
+            # Keep track of the connection
+            connection = Connection.new @gazelle, socket, @connection_queue
+            @connections.add connection
+            socket.storage = connection     # This allows us to re-use the one proc for parsing
+
+            # process any data coming from the socket
+            socket.progress @on_progress
+            socket.start_read
+
+            # Remove connection if the socket closes
+            socket.finally do
+                @connections.delete(connection)
+            end
+        end
+
+        def process_signal(data)
+            if data == Spider::KILL_GAZELLE
+                shutdown
+            end
+        end
+
+        def shutdown
+            # TODO:: do this nicely
+            @gazelle.stop
+        end
+    end
+end

data/lib/spider-gazelle/request.rb

@@ -0,0 +1,150 @@
+require 'stringio'
+require 'benchmark'
+
+
+module SpiderGazelle
+    class Request
+
+        SERVER = 'SG'.freeze    # The server name
+
+        # Based on http://rack.rubyforge.org/doc/SPEC.html
+        PATH_INFO = 'PATH_INFO'.freeze              # Request path from the script name up
+        QUERY_STRING = 'QUERY_STRING'.freeze        # portion of the request following a '?' (empty if none)
+        SERVER_NAME = 'SERVER_NAME'.freeze          # required although HTTP_HOST takes priority if set
+        SERVER_PORT = 'SERVER_PORT'.freeze          # required (set in spider.rb init)
+        REQUEST_URI = 'REQUEST_URI'.freeze
+        REQUEST_PATH = 'REQUEST_PATH'.freeze
+        RACK_URLSCHEME = 'rack.url_scheme'.freeze   # http or https
+        RACK_INPUT = 'rack.input'.freeze            # an IO like object containing all the request body
+
+        GATEWAY_INTERFACE = "GATEWAY_INTERFACE".freeze
+        CGI_VER = "CGI/1.2".freeze
+
+        RACK = 'rack'.freeze            # used for filtering headers
+        EMPTY = ''.freeze
+
+        HTTP_11 = 'HTTP/1.1'.freeze     # used in PROTO_ENV
+        HTTP_URL_SCHEME = 'http'.freeze
+        HTTPS_URL_SCHEME = 'https'.freeze
+        HTTP_HOST = 'HTTP_HOST'.freeze
+        COLON_SPACE = ': '.freeze
+        CRLF = "\r\n".freeze
+        LOCALHOST = 'localhost'.freeze
+        
+        CONTENT_LENGTH = "Content-Length".freeze
+        CONNECTION = "Connection".freeze
+        KEEP_ALIVE = "Keep-Alive".freeze
+        CLOSE = "close".freeze
+
+        HTTP_CONTENT_LENGTH = 'HTTP_CONTENT_LENGTH'.freeze
+        HTTP_CONTENT_TYPE = 'HTTP_CONTENT_TYPE'.freeze
+        HTTP_AUTHORIZATION = 'AUTHORIZATION'.freeze
+        HTTP_CONNECTION = 'HTTP_CONNECTION'.freeze
+
+        SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+        SERVER   = 'SpiderGazelle'.freeze
+
+
+        #
+        # TODO:: Add HTTP headers to the env and capitalise them and prefix them with HTTP_
+        #   convert - signs to underscores
+        # => copy puma with a const file
+        # 
+        PROTO_ENV = {
+            'rack.version'.freeze => ::Rack::VERSION,   # Should be an array of integers
+            'rack.errors'.freeze => $stderr,            # An error stream that supports: puts, write and flush
+            'rack.multithread'.freeze => true,          # can the app be simultaneously invoked by another thread?
+            'rack.multiprocess'.freeze => false,        # will the app be simultaneously be invoked in a separate process?
+            'rack.run_once'.freeze => false,            # this isn't CGI so will always be false
+
+            'SCRIPT_NAME'.freeze => ENV['SCRIPT_NAME'] || EMPTY,   #  The virtual path of the app base (empty if root)
+            'CONTENT_TYPE'.freeze => 'text/plain',      # works with Rack and Rack::Lint (source puma)
+            'SERVER_PROTOCOL'.freeze => HTTP_11,
+            RACK_URLSCHEME => HTTP_URL_SCHEME,          # TODO:: check for / support ssl
+
+            GATEWAY_INTERFACE => CGI_VER,
+            SERVER_SOFTWARE   => SERVER
+        }
+
+
+        attr_accessor :env, :url, :header, :body, :keep_alive, :upgrade, :response
+
+
+        def initialize(app, options)
+            @app, @options = app, options
+            @body = ''
+            @header = ''
+            @url = ''
+            @env = PROTO_ENV.dup
+        end
+
+        def execute!
+            @env.delete(HTTP_CONTENT_LENGTH)
+            @env.delete(HTTP_CONTENT_TYPE)
+            @env.delete(HTTP_AUTHORIZATION)
+            @env.delete(HTTP_CONNECTION)
+
+            @env[REQUEST_URI] = @url.freeze
+            @env[RACK_INPUT] = StringIO.new(@body)
+
+            # Break the request into its components
+            query_start  = @url.index('?')
+            if query_start
+                path = @url[0...query_start].freeze
+                @env[PATH_INFO] = path
+                @env[REQUEST_PATH] = path
+                @env[QUERY_STRING] = @url[query_start + 1..-1].freeze
+            else
+                @env[PATH_INFO] = @url
+                @env[REQUEST_PATH] = @url
+            end
+
+            # Grab the host name from the request
+            if host = @env[HTTP_HOST]
+                if colon = host.index(':')
+                    @env[SERVER_NAME] = host[0, colon]
+                    @env[SERVER_PORT] = host[colon+1, host.bytesize]
+                else
+                    @env[SERVER_NAME] = host
+                    @env[SERVER_PORT] = PROTO_ENV[SERVER_PORT]
+                end
+            else
+                @env[SERVER_NAME] = LOCALHOST
+                @env[SERVER_PORT] = PROTO_ENV[SERVER_PORT]
+            end
+
+            # Process the request
+            #p @env
+            status, headers, body = nil, nil, nil
+            puts Benchmark.measure {
+                status, headers, body = @app.call(@env)
+            }
+            # TODO:: check if upgrades were handled here (hijack_io)
+            
+            # Collect the body
+            resp_body = ''
+            body.each do |val|
+                resp_body << val
+            end
+
+            # Build the response
+            resp = "HTTP/1.1 #{status}\r\n"
+            headers[CONTENT_LENGTH] = resp_body.size.to_s           # ensure correct size
+            headers[CONNECTION] = CLOSE if @keep_alive == false     # ensure appropriate keep alive is set (http 1.1 way)
+
+            headers.each do |key, value|
+                next if key.start_with? RACK
+
+                resp << key
+                resp << COLON_SPACE
+                resp << value
+                resp << CRLF
+            end
+            resp << CRLF
+            resp << resp_body
+
+            # TODO:: streaming responses (using async and a queue object?)
+            @response = resp
+        end
+    end
+end

data/lib/spider-gazelle/spider.rb

@@ -0,0 +1,210 @@
+require 'set'
+
+
+module SpiderGazelle
+    class Spider
+
+
+        DEFAULT_OPTIONS = {
+            :gazelle_count => ::Libuv.cpu_count || 1,
+            :Host => '127.0.0.1',
+            :Port => 8081
+        }
+
+        NEW_SOCKET = 's'.freeze
+        KILL_GAZELLE = 'k'.freeze
+
+        STATES = [:dead, :reanimating, :running, :squashing]
+        MODES = [:thread, :process]    # TODO:: implement process
+
+
+        def initialize(app, options = {})
+            @spider = Libuv::Loop.new
+
+            logger = options[:logger] || STDOUT
+            @app = Rack::CommonLogger.new(app, logger)
+            @options = DEFAULT_OPTIONS.merge(options)
+
+            # Manage the set of Gazelle socket listeners
+            @loops = Set.new
+            @select_loop = @loops.cycle     # provides a looping enumerator for our round robin
+            @accept_loop = method(:accept_loop)
+
+            # Manage the set of Gazelle signal pipes
+            @gazella = Set.new
+            @accept_gazella = method(:accept_gazella)
+
+            # Connection management
+            @accept_connection = method(:accept_connection)
+            @new_connection = method(:new_connection)
+
+            @status = :dead
+            @mode = :thread
+
+            # Update the base request environment
+            Request::PROTO_ENV[Request::SERVER_PORT] = @options[:port]
+        end
+
+        # Start the server (this method blocks until completion)
+        def run
+            return unless @status == :dead
+            @status = :reanimating
+            @spider.run &method(:reanimate)
+        end
+
+        # If the spider is running we will request to squash it (thread safe)
+        def stop
+            @squash.call
+        end
+
+
+        protected
+
+
+        # There is a new connection pending
+        # We accept it
+        def new_connection(server)
+            server.accept @accept_connection
+        end
+
+        # Once the connection is accepted we disable Nagles Algorithm
+        # This improves performance as we are using vectored or scatter/gather IO
+        # Then we send the socket, round robin, to the gazelle loops
+        def accept_connection(client)
+            client.enable_nodelay
+            loop = @select_loop.next
+            loop.write2(client, NEW_SOCKET)
+        end
+
+
+        # A new gazelle is ready to accept commands
+        def accept_gazella(gazelle)
+            p "gazelle #{@gazella.size} signal port ready"
+            # add the signal port to the set
+            @gazella.add gazelle
+            gazelle.finally do
+                @gazella.delete gazelle
+            end
+        end
+
+        # A new gazelle loop is ready to accept sockets
+        # We start the server as soon as the first gazelle is ready
+        def accept_loop(loop)
+            p "gazelle #{@loops.size} loop running"
+
+            # start accepting connections
+            if @loops.size == 0
+                # Bind the socket
+                @tcp = @spider.tcp
+                @tcp.bind(@options[:Host], @options[:Port], @new_connection)
+                @tcp.listen(1024)
+                @tcp.catch do |e|
+                    p "tcp bind error: #{e}"
+                end
+            end
+
+            @loops.add loop      	# add the new gazelle to the set
+            @select_loop.rewind     # update the enumerator with the new gazelle
+
+            # If a gazelle dies or shuts down we update the set
+            loop.finally do
+                @loops.delete loop
+                @select_loop.rewind
+
+                if @loops.size == 0
+                    @tcp.close
+                end
+            end
+        end
+
+        # Triggers the creation of gazelles
+        def reanimate(logger)
+            logger.progress do |level, errorid, error|
+                begin
+                    p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+                rescue Exception
+                    p 'error in gazelle logger'
+                end
+            end
+
+            # Create a function for stopping the spider from another thread
+            @squash = @spider.async do
+                squash
+            end
+
+            # Bind the pipe for sending sockets to gazelle
+            begin
+                File.unlink(DELEGATE_PIPE)
+            rescue
+            end
+            @delegator = @spider.pipe(true)
+            @delegator.bind(DELEGATE_PIPE) do 
+                @delegator.accept @accept_loop
+            end
+            @delegator.listen(128)
+
+            # Bind the pipe for communicating with gazelle
+            begin
+                File.unlink(SIGNAL_PIPE)
+            rescue
+            end
+            @signaller = @spider.pipe(true)
+            @signaller.bind(SIGNAL_PIPE) do
+                @signaller.accept @accept_gazella
+            end
+            @signaller.listen(128)
+
+
+            # Launch the gazelle here
+            @options[:gazelle_count].times do
+                Thread.new do
+                    gazelle = Gazelle.new(@app, @options)
+                    gazelle.run
+                end
+            end
+
+            # Signal gazelle death here
+            @spider.signal(:INT) do
+                squash
+            end
+
+            # Update state only once the event loop is ready
+            @status = :running
+        end
+
+
+        # Triggers a shutdown of the gazelles.
+        # We ensure the process is running here as signals can be called multiple times
+        def squash
+            if @status == :running
+
+                # Update the state and close the socket
+                @status = :squashing
+                @tcp.close
+
+                # Signal all the gazelle to shutdown
+                promises = []
+                @gazella.each do |gazelle|
+                    promises << gazelle.write(KILL_GAZELLE)
+                end
+
+                # Once the signal has been sent we can stop the spider loop
+                @spider.finally(*promises).finally do
+                    # TODO:: need a better system for ensuring these are cleaned up
+                    begin
+                        @delegator.close
+                        File.unlink(DELEGATE_PIPE)
+                    rescue
+                    end
+                    begin
+                        @signaller.close
+                        File.unlink(SIGNAL_PIPE)
+                    rescue
+                    end
+                    @spider.stop
+                    @status = :dead
+                end
+            end
+        end
+    end
+end

data/lib/spider-gazelle/upgrades/websocket.rb

@@ -0,0 +1,37 @@
+require 'websocket/driver'
+
+
+module SpiderGazelle
+	class Websocket
+		attr_reader :env, :url, :driver, :socket
+
+
+		def initialize(tcp, env)
+			@socket, @env = tcp, env
+
+			scheme = Rack::Request.new(env).ssl? ? 'wss://' : 'ws://'
+			@url = scheme + env['HTTP_HOST'] + env['REQUEST_URI']
+			@driver = ::WebSocket::Driver.rack(self)
+
+			# Pass data from the socket to the driver
+			@socket.progress do |data|
+				@driver.parse(data)
+			end
+
+			# Driver has indicated that it is closing
+			# We'll close the socket after writing any remaining data
+			@driver.on(:close) {
+				@socket.shutdown
+			}
+		end
+
+		def start
+			@driver.start
+			@socket.start_read
+		end
+
+		def write(string)
+			@socket.write(string)
+		end
+	end
+end

data/lib/spider-gazelle/version.rb

@@ -0,0 +1,3 @@
+module SpiderGazelle
+    VERSION = "0.1.0"
+end

data/lib/spider-gazelle.rb

@@ -0,0 +1,17 @@
+require "http-parser"   # C based, fast, http parser
+require "libuv"         # Ruby Libuv FFI wrapper
+require "rack"          # Ruby webserver abstraction
+
+require "spider-gazelle/version"
+require "spider-gazelle/request"        # Holds request information and handles request processing
+require "spider-gazelle/connection"     # Holds connection information and handles request pipelining
+require "spider-gazelle/gazelle"        # Processes data received from connections
+require "spider-gazelle/spider"         # Accepts connections and offloads them to gazelles
+
+
+module SpiderGazelle
+    # Delegate pipe used for passing sockets to the gazelles
+    # Signal pipe used to pass control signals
+    DELEGATE_PIPE = "/tmp/spider-gazelle.delegate"
+    SIGNAL_PIPE = "/tmp/spider-gazelle.signal"
+end

data/spider-gazelle.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "spider-gazelle/version"
+
+Gem::Specification.new do |s|
+    s.name        = "spider-gazelle"
+    s.version     = SpiderGazelle::VERSION
+    s.authors     = ["Stephen von Takach"]
+    s.email       = ["steve@cotag.me"]
+    s.license     = 'MIT'
+    s.homepage    = "https://github.com/cotag/spider-gazelle"
+    s.summary     = "A fast, parallel and concurrent web server for ruby"
+    s.description = <<-EOF
+      Spidergazelle, spidergazelle, amazingly agile, she leaps through the veldt,
+      Spidergazelle, spidergazelle! She don’t care what you think, she says what the hell!
+      Look out! Here comes the Spidergazelle!
+    EOF
+
+    s.add_dependency 'rake'
+    s.add_dependency 'http-parser'          # Ruby FFI bindings for https://github.com/joyent/http-parser
+    s.add_dependency 'libuv'                # Ruby FFI bindings for https://github.com/joyent/libuv
+    s.add_dependency 'rack', '>= 1.0.0'     # Ruby web server interface
+    s.add_dependency 'websocket-driver'     # Websocket parser
+
+    s.add_development_dependency 'rspec'    # Testing framework
+    s.add_development_dependency 'yard'     # Comment based documentation generation
+    
+
+    s.files = Dir["{lib,bin}/**/*"] + %w(Rakefile spider-gazelle.gemspec README.md LICENSE)
+    s.test_files = Dir["spec/**/*"]
+    s.extra_rdoc_files = ["README.md"]
+
+    s.bindir = 'bin'
+    s.executables = ['sg']
+
+    s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: spider-gazelle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: http-parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: libuv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+        Spidergazelle, spidergazelle, amazingly agile, she leaps through the veldt,
+        Spidergazelle, spidergazelle! She don’t care what you think, she says what the hell!
+        Look out! Here comes the Spidergazelle!
+email:
+- steve@cotag.me
+executables:
+- sg
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/rack/handler/spider-gazelle.rb
+- lib/spider-gazelle/connection.rb
+- lib/spider-gazelle/error.rb
+- lib/spider-gazelle/gazelle.rb
+- lib/spider-gazelle/request.rb
+- lib/spider-gazelle/spider.rb
+- lib/spider-gazelle/upgrades/websocket.rb
+- lib/spider-gazelle/version.rb
+- lib/spider-gazelle.rb
+- bin/sg
+- Rakefile
+- spider-gazelle.gemspec
+- README.md
+- LICENSE
+homepage: https://github.com/cotag/spider-gazelle
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A fast, parallel and concurrent web server for ruby
+test_files: []
+has_rdoc: