spider-gazelle 0.1.0 → 0.1.1

data/lib/spider-gazelle/gazelle.rb

@@ -9,17 +9,28 @@ module SpiderGazelle
         REQUEST_METHOD = 'REQUEST_METHOD'.freeze    # GET, POST, etc
 
 
-        def initialize(app, options)
-            @gazelle = Libuv::Loop.new
+        attr_reader :parser_cache, :connections, :logger
+
+
+        def set_instance_type(inst)
+            inst.type = :request
+        end
+        
+
+
+        def initialize(loop, logger, mode)
+            @gazelle = loop
             @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
+            @mode = mode
+            @logger = logger
+            @app_cache = {}
+            @connection_queue = ::Libuv::Q::ResolvedPromise.new(@gazelle, true)
 
             # A single parser instance for processing requests for each gazelle
             @parser = ::HttpParser::Parser.new(self)
+            @set_instance_type = method(:set_instance_type)
 
             # Single progress callback for each gazelle
             @on_progress = method(:on_progress)
@@ -29,28 +40,28 @@ module SpiderGazelle
             @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"
+                        msg = "Gazelle log: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n") if error.backtrace}\n"
+                        @logger.error msg
+                        puts msg
                     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)
+                unless @mode == :no_ipc
+                    # A pipe used to forward connections to different threads
+                    @socket_server = @gazelle.pipe(true)
+                    @socket_server.connect(DELEGATE_PIPE) do
+                        @socket_server.progress &method(:new_connection)
+                        @socket_server.start_read2
                     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)
+                    # A pipe used to signal various control commands (shutdown, etc)
+                    @signal_server = @gazelle.pipe
+                    @signal_server.connect(SIGNAL_PIPE) do
+                        @signal_server.progress &method(:process_signal)
+                        @signal_server.start_read
                     end
-                    @signal_server.start_read
                 end
             end
         end
@@ -58,7 +69,7 @@ module SpiderGazelle
 
         # HTTP Parser callbacks:
         def on_message_begin(parser)
-            @connection.start_parsing(Request.new(@app, @options))
+            @connection.start_parsing
         end
 
         def on_url(parser, url)
@@ -100,6 +111,11 @@ module SpiderGazelle
             @connection.finished_parsing
         end
 
+        def discard(connection)
+            @connections.delete(connection)
+            @parser_cache << connection.state
+        end
+
 
         protected
 
@@ -114,23 +130,28 @@ module SpiderGazelle
             end
         end
 
-        def new_connection(socket)
+        def new_connection(data, socket)
+            # Data == "TLS_indicator Port APP_ID"
+            tls, port, app_id = data.split(' ', 3)
+            app = @app_cache[app_id.to_sym] ||= AppStore.get(app_id)
+            inst = @parser_cache.pop || ::HttpParser::Parser.new_instance(&@set_instance_type)
+
+            # process any data coming from the socket
+            socket.progress @on_progress
+            if tls == 'T'
+                # TODO:: Allow some globals for supplying the certs
+                socket.start_tls(:server => true)
+            end
+
             # Keep track of the connection
-            connection = Connection.new @gazelle, socket, @connection_queue
+            connection = Connection.new self, @gazelle, socket, port, inst, app, @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)
+        def process_signal(data, pipe)
             if data == Spider::KILL_GAZELLE
                 shutdown
             end
@@ -138,6 +159,7 @@ module SpiderGazelle
 
         def shutdown
             # TODO:: do this nicely
+            # Need to signal the connections to close
             @gazelle.stop
         end
     end

data/lib/spider-gazelle/request.rb

@@ -1,12 +1,9 @@
 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)
@@ -16,25 +13,23 @@ module SpiderGazelle
         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
+        RACK_HIJACKABLE = 'rack.hijack?'.freeze     # hijacking IO is supported
+        RACK_HIJACK = 'rack.hijack'.freeze          # callback for indicating that this socket will be hijacked
+        RACK_HIJACK_IO = 'rack.hijack_io'.freeze    # the object for performing IO on after hijack is called
+        RACK_ASYNC = 'async.callback'.freeze
 
         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
@@ -43,6 +38,7 @@ module SpiderGazelle
 
         SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
         SERVER   = 'SpiderGazelle'.freeze
+        REMOTE_ADDR = 'REMOTE_ADDR'.freeze
 
 
         #
@@ -60,22 +56,28 @@ module SpiderGazelle
             '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
+        attr_accessor :env, :url, :header, :body, :keep_alive, :upgrade, :deferred 
+        attr_reader :hijacked, :response
 
 
-        def initialize(app, options)
-            @app, @options = app, options
+        def initialize(connection, app)
+            @app = app
             @body = ''
             @header = ''
             @url = ''
+            @execute = method(:execute)
             @env = PROTO_ENV.dup
+            @loop = connection.loop
+            @env[SERVER_PORT] = connection.port
+            @env[REMOTE_ADDR] = connection.remote_ip
+            @env[RACK_URLSCHEME] = connection.tls ? HTTPS_URL_SCHEME : HTTP_URL_SCHEME
+            @env[RACK_ASYNC] = connection.async_callback
         end
 
         def execute!
@@ -113,38 +115,36 @@ module SpiderGazelle
                 @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
+            # Provide hijack options if this is an upgrade request
+            if @upgrade == true
+                @env[RACK_HIJACKABLE] = true
+                @env[RACK_HIJACK] = method(:hijack)
             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)
+            # Execute the request
+            @response = catch(:async, &@execute)
+            if @response.nil? || @response[0] == -1
+                @deferred = @loop.defer
+            end
+            @response
+        end
 
-            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
+        protected
+
+
+        # Execute the request then close the body
+        # NOTE:: closing the body here might cause issues (see connection.rb)
+        def execute(*args)
+            result = @app.call(@env)
+            body = result[2]
+            body.close if body.respond_to?(:close)
+            result
+        end
 
-            # TODO:: streaming responses (using async and a queue object?)
-            @response = resp
+        def hijack
+            @hijacked = @loop.defer
+            @env[RACK_HIJACK_IO] = @hijacked.promise
         end
     end
 end

data/lib/spider-gazelle/spider.rb

@@ -1,210 +1,363 @@
 require 'set'
+require 'thread'
+require 'logger'
+require 'singleton'
+require 'fileutils'
 
 
 module SpiderGazelle
     class Spider
+        include Singleton
 
 
-        DEFAULT_OPTIONS = {
-            :gazelle_count => ::Libuv.cpu_count || 1,
-            :Host => '127.0.0.1',
-            :Port => 8081
-        }
-
-        NEW_SOCKET = 's'.freeze
+        USE_TLS = 'T'.freeze
+        NO_TLS = 'F'.freeze
         KILL_GAZELLE = 'k'.freeze
 
-        STATES = [:dead, :reanimating, :running, :squashing]
-        MODES = [:thread, :process]    # TODO:: implement process
+        STATES = [:reanimating, :running, :squashing, :dead]
+        MODES = [:thread, :process, :no_ipc]    # TODO:: implement clustering using processes
 
 
-        def initialize(app, options = {})
-            @spider = Libuv::Loop.new
+        attr_reader :state, :mode, :threads, :logger
 
-            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)
+        def initialize
+            # Threaded mode by default
+            @status = :reanimating
+            @bindings = {
+                # id => [bind1, bind2]
+            }
 
-            # Manage the set of Gazelle signal pipes
-            @gazella = Set.new
-            @accept_gazella = method(:accept_gazella)
+            mode = ENV['SG_MODE'] || :thread
+            @mode = mode.to_sym
 
-            # Connection management
-            @accept_connection = method(:accept_connection)
-            @new_connection = method(:new_connection)
+            if @mode == :no_ipc
+                @delegate = method(:direct_delegate)
+            else
+                @delegate = method(:delegate)
+            end
+            @squash = method(:squash)
 
-            @status = :dead
-            @mode = :thread
 
-            # Update the base request environment
-            Request::PROTO_ENV[Request::SERVER_PORT] = @options[:port]
+            log_path = ENV['SG_LOG'] || File.expand_path('../../../logs/server.log', __FILE__)
+            dirname = File.dirname(log_path)
+            unless File.directory?(dirname)
+                FileUtils.mkdir_p(dirname)
+            end
+            @logger = ::Logger.new(log_path.to_s, 10, 4194304)
+
+            # Keep track of the loading process
+            @waiting_gazelle = 0
+            @gazelle_count = 0
+
+            # Spider always runs on the default loop
+            @web = ::Libuv::Loop.default
+            @gazelles_loaded = @web.defer
+
+            # Start the server
+            if @web.reactor_running?
+                # Call run so we can be notified of errors
+                @web.run &method(:reanimate)
+            else
+                # Don't block on this thread if default reactor not running
+                Thread.new do
+                    @web.run &method(:reanimate)
+                end
+            end
         end
 
-        # Start the server (this method blocks until completion)
-        def run
-            return unless @status == :dead
-            @status = :reanimating
-            @spider.run &method(:reanimate)
+        # Provides a promise that resolves when we are read to start binding applications
+        #
+        # @return [::Libuv::Q::Promise] that indicates when the gazelles are loaded
+        def loaded
+            @gazelles_loaded.promise unless @gazelles_loaded.nil?
         end
 
-        # If the spider is running we will request to squash it (thread safe)
-        def stop
-            @squash.call
-        end
+        # A thread safe method for loading and binding rack apps. The app can be pre-loaded or a rackup file
+        #
+        # @param app [String, Object] rackup filename or rack app
+        # @param ports [Hash, Array] binding config or array of binding config
+        # @return [::Libuv::Q::Promise] resolves once the app is loaded (and bound if SG is running)
+        def load(app, ports = [])
+            defer = @web.defer
 
+            ports = [ports] if ports.is_a? Hash
+            ports << {} if ports.empty?
 
-        protected
+            @web.schedule do
+                begin
+                    app_id = AppStore.load(app)
+                    bindings = @bindings[app_id] ||= []
 
+                    ports.each do |options|
+                        binding = Binding.new(@web, @delegate, app_id, options)
+                        bindings << binding
+                    end
 
-        # There is a new connection pending
-        # We accept it
-        def new_connection(server)
-            server.accept @accept_connection
-        end
+                    if @status == :running
+                        defer.resolve(start(app, app_id))
+                    else
+                        defer.resolve(true)
+                    end
+                rescue Exception => e
+                    defer.reject(e)
+                end
+            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)
+            defer.promise
         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
+        # Starts the app specified. It must already be loaded
+        #
+        # @param app [String, Object] rackup filename or the rack app instance
+        # @return [::Libuv::Q::Promise] resolves once the app is bound to the port
+        def start(app, app_id = nil)
+            defer = @web.defer
+            app_id = app_id || AppStore.lookup(app)
+
+            if app_id != nil && @status == :running
+                @web.schedule do
+                    bindings = @bindings[app_id] ||= []
+                    starting = []
+
+                    bindings.each do |binding|
+                        starting << binding.bind
+                    end
+                    defer.resolve(::Libuv::Q.all(@web, *starting))
+                end
+            elsif app_id.nil?
+                defer.reject('application not loaded')
+            else
+                defer.reject('server not running')
             end
+
+            defer.promise
         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}"
+        # Stops the app specified. If loaded
+        #
+        # @param app [String, Object] rackup filename or the rack app instance
+        # @return [::Libuv::Q::Promise] resolves once the app is no longer bound to the port
+        def stop(app, app_id = nil)
+            defer = @web.defer
+            app_id = app_id || AppStore.lookup(app)
+
+            if !app_id.nil?
+                @web.schedule do
+                    bindings = @bindings[app_id]
+                    closing = []
+
+                    if bindings != nil
+                        bindings.each do |binding|
+                            result = binding.unbind
+                            closing << result unless result.nil?
+                        end
+                    end
+                    defer.resolve(::Libuv::Q.all(@web, *closing))
                 end
+            else
+                defer.reject('application not loaded')
             end
 
-            @loops.add loop      	# add the new gazelle to the set
-            @select_loop.rewind     # update the enumerator with the new gazelle
+            defer.promise
+        end
 
-            # If a gazelle dies or shuts down we update the set
-            loop.finally do
-                @loops.delete loop
-                @select_loop.rewind
+        # Signals spider gazelle to shutdown gracefully
+        def shutdown
+            @signal_squash.call
+        end
 
-                if @loops.size == 0
-                    @tcp.close
-                end
-            end
+
+        protected
+
+
+        # Called from the binding for sending to gazelles
+        def delegate(client, tls, port, app_id)
+            indicator = tls ? USE_TLS : NO_TLS
+            loop = @select_handler.next
+            loop.write2(client, "#{indicator} #{port} #{app_id}")
+        end
+
+        def direct_delegate(client, tls, port, app_id)
+            indicator = tls ? USE_TLS : NO_TLS
+            @gazelle.__send__(:new_connection, "#{indicator} #{port} #{app_id}", client)
         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'
+            # Manage the set of Gazelle socket listeners
+            @threads = Set.new
+
+            if @mode == :thread
+                cpus = ::Libuv.cpu_count || 1
+                cpus.times do
+                    @threads << Libuv::Loop.new
                 end
+            elsif @mode == :no_ipc
+                # TODO:: need to perform process mode as well
+                @threads << @web
             end
 
+            @handlers = Set.new
+            @select_handler = @handlers.cycle     # provides a looping enumerator for our round robin
+            @accept_handler = method(:accept_handler)
+
+            # Manage the set of Gazelle signal pipes
+            @gazella = Set.new
+            @accept_gazella = method(:accept_gazella)
+
             # Create a function for stopping the spider from another thread
-            @squash = @spider.async do
-                squash
-            end
+            @signal_squash = @web.async @squash
 
-            # 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)
+            # Link up the loops logger
+            logger.progress method(:log)
 
-            # 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)
+            if @mode == :no_ipc
+                @gazelle = Gazelle.new(@web, @logger, @mode)
+                @gazelle_count = 1
+                start_bindings
+            else
+                # Bind the pipe for sending sockets to gazelle
+                begin
+                    File.unlink(DELEGATE_PIPE)
+                rescue
+                end
+                @delegator = @web.pipe(true)
+                @delegator.bind(DELEGATE_PIPE) do 
+                    @delegator.accept @accept_handler
+                end
+                @delegator.listen(16)
 
+                # Bind the pipe for communicating with gazelle
+                begin
+                    File.unlink(SIGNAL_PIPE)
+                rescue
+                end
+                @signaller = @web.pipe(true)
+                @signaller.bind(SIGNAL_PIPE) do
+                    @signaller.accept @accept_gazella
+                end
+                @signaller.listen(16)
 
-            # Launch the gazelle here
-            @options[:gazelle_count].times do
-                Thread.new do
-                    gazelle = Gazelle.new(@app, @options)
-                    gazelle.run
+                # Launch the gazelle here
+                @threads.each do |thread|
+                    Thread.new do
+                        gazelle = Gazelle.new(thread, @logger, @mode)
+                        gazelle.run
+                    end
+                    @waiting_gazelle += 1
                 end
             end
 
             # Signal gazelle death here
-            @spider.signal(:INT) do
-                squash
-            end
+            @web.signal :INT, @squash
 
             # Update state only once the event loop is ready
-            @status = :running
+            @gazelles_loaded.promise
         end
 
-
         # Triggers a shutdown of the gazelles.
         # We ensure the process is running here as signals can be called multiple times
-        def squash
+        def squash(*args)
             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)
+                @bindings.each_key do |key|
+                    stop(key)
                 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
+                if @mode == :no_ipc
+                    @web.stop
+                    @status = :dead
+                else
+                    # Signal all the gazelle to shutdown
+                    promises = []
+                    @gazella.each do |gazelle|
+                        promises << gazelle.write(KILL_GAZELLE)
                     end
-                    begin
-                        @signaller.close
-                        File.unlink(SIGNAL_PIPE)
-                    rescue
+
+                    # Once the signal has been sent we can stop the spider loop
+                    @web.finally(*promises).finally do
+
+                        # TODO:: need a better system for ensuring these are cleaned up
+                        #  Especially when we implement live migrations and process clusters
+                        begin
+                            @delegator.close
+                            File.unlink(DELEGATE_PIPE)
+                        rescue
+                        end
+                        begin
+                            @signaller.close
+                            File.unlink(SIGNAL_PIPE)
+                        rescue
+                        end
+
+                        @web.stop
+                        @status = :dead
                     end
-                    @spider.stop
-                    @status = :dead
                 end
             end
         end
+
+        # A new gazelle is ready to accept commands
+        def accept_gazella(gazelle)
+            #puts "gazelle #{@gazella.size} signal port ready"
+
+            # add the signal port to the set
+            @gazella.add gazelle
+            gazelle.finally do
+                @gazella.delete gazelle
+                @waiting_gazelle -= 1
+                @gazelle_count -= 1
+            end
+
+            @gazelle_count += 1
+            if @waiting_gazelle == @gazelle_count
+                start_bindings
+            end
+        end
+
+        def start_bindings
+            @status = :running
+
+            # Start any bindings that are already present
+            @bindings.each_key do |key|
+                start(key)
+            end
+
+            # Inform any listeners that we have completed loading
+            @gazelles_loaded.resolve(@gazelle_count)
+        end
+
+        # A new gazelle loop is ready to accept sockets
+        # We start the server as soon as the first gazelle is ready
+        def accept_handler(handler)
+            #puts "gazelle #{@handlers.size} loop running"
+
+            @handlers.add handler       # add the new gazelle to the set
+            @select_handler.rewind     # update the enumerator with the new gazelle
+
+            # If a gazelle dies or shuts down we update the set
+            handler.finally do
+                @handlers.delete handler
+                @select_handler.rewind
+
+                if @status == :running && @handlers.size == 0
+                    # I assume if we made it here something went quite wrong
+                    squash
+                end
+            end
+        end
+
+        def log(*args)
+            msg = ''
+            if args[0].respond_to? :backtrace
+                msg << "unhandled exception: #{args[0]}\n #{args[0].backtrace}"
+            else
+                msg << "unhandled exception: #{args}"
+            end
+            @logger.error msg
+        end
     end
 end