spider-gazelle 0.1.6 → 0.1.7

data/lib/spider-gazelle/request.rb

@@ -1,151 +1,105 @@
+require 'spider-gazelle/const'
 require 'stringio'
 
-
 module SpiderGazelle
-    class Request
-
-        # 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
-        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
-
-        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
-        LOCALHOST = 'localhost'.freeze
-        
-        KEEP_ALIVE = "Keep-Alive".freeze
-
-        CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze
-        CONTENT_TYPE = 'CONTENT_TYPE'.freeze
-        DEFAULT_TYPE = 'text/plain'.freeze
-        HTTP_CONTENT_LENGTH = 'HTTP_CONTENT_LENGTH'.freeze
-        HTTP_CONTENT_TYPE = 'HTTP_CONTENT_TYPE'.freeze
-
-        SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
-        SERVER   = 'SpiderGazelle'.freeze
-        REMOTE_ADDR = 'REMOTE_ADDR'.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)
-            'SERVER_PROTOCOL'.freeze => HTTP_11,
-
-            GATEWAY_INTERFACE => CGI_VER,
-            SERVER_SOFTWARE   => SERVER
-        }
-
-
-        attr_accessor :env, :url, :header, :body, :keep_alive, :upgrade, :deferred 
-        attr_reader :hijacked, :response
-
-
-        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!
-            @env[CONTENT_LENGTH] = @env.delete(HTTP_CONTENT_LENGTH) || @body.length
-            @env[CONTENT_TYPE] = @env.delete(HTTP_CONTENT_TYPE) || DEFAULT_TYPE
-            @env[REQUEST_URI] = @url.freeze
-            
-            # For Rack::Lint on 1.9, ensure that the encoding is always for spec
-            @body.force_encoding('ASCII-8BIT') if @body.respond_to?(:force_encoding)
-            @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
-                @env[QUERY_STRING] = ''
-            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
-
-            # Provide hijack options if this is an upgrade request
-            if @upgrade == true
-                @env[RACK_HIJACKABLE] = true
-                @env[RACK_HIJACK] = method(:hijack)
-            end
+  class Request
+    include Const
+
+    # TODO:: Add HTTP headers to the env and capitalise them and prefix them with HTTP_
+    #   convert - signs to underscores
+    PROTO_ENV = {
+      RACK_VERSION => ::Rack::VERSION,   # Should be an array of integers
+      RACK_ERRORS => $stderr,            # An error stream that supports: puts, write and flush
+      RACK_MULTITHREAD => true,          # can the app be simultaneously invoked by another thread?
+      RACK_MULTIPROCESS => false,        # will the app be simultaneously be invoked in a separate process?
+      RACK_RUN_ONCE => false,            # this isn't CGI so will always be false
+
+      SCRIPT_NAME => ENV['SCRIPT_NAME'] || EMPTY,   #  The virtual path of the app base (empty if root)
+      SERVER_PROTOCOL => HTTP_11,
+
+      GATEWAY_INTERFACE => CGI_VER,
+      SERVER_SOFTWARE   => SERVER
+    }
+
+    attr_accessor :env, :url, :header, :body, :keep_alive, :upgrade, :deferred 
+    attr_reader :hijacked, :response
+
+    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_URL_SCHEME] = connection.tls ? HTTPS : HTTP
+      @env[ASYNC] = connection.async_callback
+    end
 
-            # Execute the request
-            @response = catch(:async, &@execute)
-            if @response.nil? || @response[0] == -1
-                @deferred = @loop.defer
-            end
-            @response
+    def execute!
+      @env[CONTENT_LENGTH] = @env.delete(HTTP_CONTENT_LENGTH) || @body.length
+      @env[CONTENT_TYPE] = @env.delete(HTTP_CONTENT_TYPE) || DEFAULT_TYPE
+      @env[REQUEST_URI] = @url.freeze
+
+      # For Rack::Lint on 1.9, ensure that the encoding is always for spec
+      @body.force_encoding('ASCII-8BIT') if @body.respond_to?(:force_encoding)
+      @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
+        @env[QUERY_STRING] = ''
+      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
+
+      # Provide hijack options if this is an upgrade request
+      if @upgrade == true
+        @env[HIJACK_P] = true
+        @env[HIJACK] = method :hijack
+      end
+
+      # Execute the request
+      @response = catch :async, &@execute
+      @deferred = @loop.defer if (@response.nil? || @response[0] == -1)
+      @response
+    end
 
+    protected
 
-        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
+    # 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
 
-        def hijack
-            @hijacked = @loop.defer
-            @env[RACK_HIJACK_IO] = @hijacked.promise
-        end
+    def hijack
+      @hijacked = @loop.defer
+      @env[HIJACK_IO] = @hijacked.promise
     end
+  end
 end

data/lib/spider-gazelle/spider.rb

@@ -1,408 +1,392 @@
+require 'spider-gazelle/const'
 require 'set'
 require 'thread'
 require 'logger'
 require 'singleton'
-require 'fileutils'   # mkdir_p
+require 'fileutils' # mkdir_p
 require 'forwardable' # run method
 
-
 module SpiderGazelle
-    class Spider
-        include Singleton
-
+  class Spider
+    include Const
+    include Singleton
 
-        USE_TLS = 'T'.freeze
-        NO_TLS = 'F'.freeze
-        KILL_GAZELLE = 'k'.freeze
+    STATES = [:reanimating, :running, :squashing, :dead]
+    # TODO:: implement clustering using processes
+    MODES = [:thread, :process, :no_ipc]
+    DEFAULT_OPTIONS = {
+      Host: "0.0.0.0",
+      Port: 8080,
+      Verbose: false,
+      tls: false,
+      optimize_for_latency: true,
+      backlog: 1024
+    }
 
-        STATES = [:reanimating, :running, :squashing, :dead]
-        MODES = [:thread, :process, :no_ipc]    # TODO:: implement clustering using processes
+    attr_reader :state, :mode, :threads, :logger
 
-        DEFAULT_OPTIONS = {
-            :Host => '0.0.0.0',
-            :Port => 8080,
-            :Verbose => false,
-            :tls => false,
-            :optimize_for_latency => true,
-            :backlog => 1024
-        }
+    extend Forwardable
+    def_delegators :@web, :run
 
-        def self.run(app, options = {})
-            options = DEFAULT_OPTIONS.merge(options)
+    def self.run(app, options = {})
+      options = DEFAULT_OPTIONS.merge options
 
-            ENV['RACK_ENV'] = options[:environment].to_s if options[:environment]
+      ENV['RACK_ENV'] = options[:environment].to_s if options[:environment]
 
-            puts "Look out! Here comes Spider-Gazelle #{::SpiderGazelle::VERSION}!"
-            puts "* Environment: #{ENV['RACK_ENV']} on #{RUBY_ENGINE || 'ruby'} #{RUBY_VERSION}"
+      puts "Look out! Here comes Spider-Gazelle #{SPIDER_GAZELLE_VERSION}!"
+      puts "* Environment: #{ENV['RACK_ENV']} on #{RUBY_ENGINE || 'ruby'} #{RUBY_VERSION}"
 
-            server = instance
-            server.run do |logger|
-                logger.progress server.method(:log)
-                server.loaded.then do
-                    puts "* Loading: #{app}"
+      server = instance
+      server.run do |logger|
+        logger.progress server.method(:log)
+        server.loaded.then do
+          puts "* Loading: #{app}"
 
-                    # yield server if block_given?
+          # yield server if block_given?
 
-                    server.load(app, options).catch(proc {|e|
-                        puts "#{e.message}\n#{e.backtrace.join("\n") unless e.backtrace.nil?}\n"
-                    }).finally do
-                        # This will execute if the TCP binding is lost
-                        # Terminating the application
-                        Process.kill 'INT', 0
-                    end
+          caught = proc { |e| puts("#{e.message}\n#{e.backtrace.join("\n")}") unless e.backtrace.nil? }
+          server.load(app, options).catch(caught)
+            .finally { Process.kill('INT', 0) } # Terminate the application if the TCP binding is lost
 
-                    puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
-                end
-            end
+          puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
         end
+      end
+    end
 
+    def initialize
+      # Threaded mode by default
+      reanimating!
+      @bindings = {}
+      # @bindings = {
+      #   id => [bind1, bind2]
+      # }
+
+      mode = ENV['SG_MODE'] || :thread
+      @mode = mode.to_sym
+
+      @delegate = method(no_ipc? ? :direct_delegate : :delegate)
+      @squash = method(:squash)
+
+      # FIXME The expanded path path seems a bit risky
+      log_path = ENV['SG_LOG'] || File.expand_path('../../../logs/server.log', __FILE__)
+      dirname = File.dirname(log_path)
+      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      @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 { @web.run(&method(:reanimate)) }
+      end
+    end
 
-        attr_reader :state, :mode, :threads, :logger
-
-        extend Forwardable
-        def_delegators :@web, :run
-
-
-        def initialize
-            # Threaded mode by default
-            @status = :reanimating
-            @bindings = {
-                # id => [bind1, bind2]
-            }
+    # Modes
+    def thread?
+      @mode == :thread
+    end
+    def process?
+      @mode == :process
+    end
+    def no_ipc?
+      @mode == :no_ipc
+    end
 
-            mode = ENV['SG_MODE'] || :thread
-            @mode = mode.to_sym
+    # Statuses
+    def reanimating?
+      @status == :reanimating
+    end
+    def reanimating!
+      @status = :reanimating
+    end
+    def running?
+      @status == :running
+    end
+    def running!
+      @status = :running
+    end
+    def squashing?
+      @status == :squashing
+    end
+    def squashing!
+      @status = :squashing
+    end
+    def dead?
+      @status == :dead
+    end
+    def dead!
+      @status = :dead
+    end
 
-            if @mode == :no_ipc
-                @delegate = method(:direct_delegate)
-            else
-                @delegate = method(:delegate)
-            end
-            @squash = method(:squash)
+    # 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
 
+    # 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
 
-            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
+      ports = [ports] if ports.is_a?(Hash)
+      ports << {} if ports.empty?
 
-        # 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
+      @web.schedule do
+        begin
+          app_id = AppStore.load app
+          bindings = @bindings[app_id] ||= []
 
-        # 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?
-
-            @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
-
-                    if @status == :running
-                        defer.resolve(start(app, app_id))
-                    else
-                        defer.resolve(true)
-                    end
-                rescue Exception => e
-                    defer.reject(e)
-                end
-            end
+          ports.each { |options| bindings << Binding.new(@web, @delegate, app_id, options) }
 
-            defer.promise
+          defer.resolve(running? ? start(app, app_id) : true)
+        rescue Exception => e
+          defer.reject e
         end
+      end
 
-        # 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
 
-            defer.promise
+    # 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 ||= AppStore.lookup app
+
+      if !app_id.nil? && running?
+        @web.schedule do
+          bindings = @bindings[app_id] ||= []
+          starting = []
+
+          bindings.each { |binding| starting << binding.bind }
+          defer.resolve ::Libuv::Q.all(@web, *starting)
         end
+      elsif app_id.nil?
+        defer.reject 'application not loaded'
+      else
+        defer.reject 'server not running'
+      end
 
-        # 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
+      defer.promise
+    end
 
-            defer.promise
+    # 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 ||= AppStore.lookup app
+
+      if !app_id.nil?
+        @web.schedule do
+          bindings = @bindings[app_id]
+          closing = []
+
+          bindings.each do |binding|
+            result = binding.unbind
+            closing << result unless result.nil?
+          end unless bindings.nil?
+
+          defer.resolve ::Libuv::Q.all(@web, *closing)
         end
+      else
+        defer.reject 'application not loaded'
+      end
 
-        # Signals spider gazelle to shutdown gracefully
-        def shutdown
-            @signal_squash.call
-        end
+      defer.promise
+    end
 
+    # Signals spider gazelle to shutdown gracefully
+    def shutdown
+      @signal_squash.call
+    end
 
-        protected
+    protected
 
+    # Called from the binding for sending to gazelles
+    def delegate(client, tls, port, app_id)
+      indicator = tls ? USE_TLS : NO_TLS
+      @select_handler.next.write2(client, "#{indicator} #{port} #{app_id}")
+    end
 
-        # 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
 
-        def direct_delegate(client, tls, port, app_id)
-            indicator = tls ? USE_TLS : NO_TLS
-            @gazelle.__send__(:new_connection, "#{indicator} #{port} #{app_id}", client)
+    # Triggers the creation of gazelles
+    def reanimate(logger)
+      # Manage the set of Gazelle socket listeners
+      @threads = Set.new
+
+      if thread?
+        cpus = ::Libuv.cpu_count || 1
+        cpus.times { @threads << Libuv::Loop.new }
+      elsif 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
+      @signal_squash = @web.async @squash
+
+      # Link up the loops logger
+      logger.progress method(:log)
+
+      if 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
-
-        # Triggers the creation of gazelles
-        def reanimate(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
-            @signal_squash = @web.async @squash
-
-            # Link up the loops logger
-            logger.progress method(:log)
-
-            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
-                @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
-            @web.signal :INT, @squash
-
-            # Update state only once the event loop is ready
-            @gazelles_loaded.promise
+        @delegator = @web.pipe true
+        @delegator.bind(DELEGATE_PIPE) { @delegator.accept @accept_handler }
+        @delegator.listen INTERNAL_PIPE_BACKLOG
+
+        # Bind the pipe for communicating with gazelle
+        begin
+          File.unlink SIGNAL_PIPE
+        rescue
         end
-
-        # Triggers a shutdown of the gazelles.
-        # We ensure the process is running here as signals can be called multiple times
-        def squash(*args)
-            if @status == :running
-
-                # Update the state and close the socket
-                @status = :squashing
-                @bindings.each_key do |key|
-                    stop(key)
-                end
-
-                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
-
-                    # 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
-                end
-            end
+        @signaller = @web.pipe true
+        @signaller.bind(SIGNAL_PIPE) { @signaller.accept @accept_gazella }
+        @signaller.listen INTERNAL_PIPE_BACKLOG
+
+        # Launch the gazelle here
+        @threads.each do |thread|
+          Thread.new { Gazelle.new(thread, @logger, @mode).run }
+          @waiting_gazelle += 1
         end
+      end
 
-        # A new gazelle is ready to accept commands
-        def accept_gazella(gazelle)
-            #puts "gazelle #{@gazella.size} signal port ready"
+      # Signal gazelle death here
+      @web.signal :INT, @squash
 
-            # add the signal port to the set
-            @gazella.add gazelle
-            gazelle.finally do
-                @gazella.delete gazelle
-                @waiting_gazelle -= 1
-                @gazelle_count -= 1
-            end
+      # Update state only once the event loop is ready
+      @gazelles_loaded.promise
+    end
 
-            @gazelle_count += 1
-            if @waiting_gazelle == @gazelle_count
-                start_bindings
+    # Triggers a shutdown of the gazelles.
+    # We ensure the process is running here as signals can be called multiple times
+    def squash(*args)
+      if running?
+        # Update the state and close the socket
+        squashing!
+        @bindings.each { |key, val| stop(key) }
+
+        if no_ipc?
+          @web.stop
+          dead!
+        else
+          # Signal all the gazelle to shutdown
+          promises = @gazella.map { |gazelle| gazelle.write(KILL_GAZELLE) }
+
+          # 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
-        end
-
-        def start_bindings
-            @status = :running
-
-            # Start any bindings that are already present
-            @bindings.each_key do |key|
-                start(key)
+            begin
+              @signaller.close
+              File.unlink SIGNAL_PIPE
+            rescue
             end
 
-            # Inform any listeners that we have completed loading
-            @gazelles_loaded.resolve(@gazelle_count)
+            @web.stop
+            dead!
+          end
         end
+      end
+    end
+
+    # A new gazelle is ready to accept commands
+    def accept_gazella(gazelle)
+      # 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
+      start_bindings if @waiting_gazelle == @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"
+    def start_bindings
+      running!
 
-            @handlers.add handler       # add the new gazelle to the set
-            @select_handler.rewind     # update the enumerator with the new gazelle
+      # Start any bindings that are already present
+      @bindings.each { |key, val| start(key) }
 
-            # If a gazelle dies or shuts down we update the set
-            handler.finally do
-                @handlers.delete handler
-                @select_handler.rewind
+      # Inform any listeners that we have completed loading
+      @gazelles_loaded.resolve @gazelle_count
+    end
 
-                if @status == :running && @handlers.size == 0
-                    # I assume if we made it here something went quite wrong
-                    squash
-                end
-            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_handler(handler)
+      # Add the new gazelle to the set
+      @handlers.add handler
+      # Update the enumerator with the new gazelle
+      @select_handler.rewind
+
+      # If a gazelle dies or shuts down we update the set
+      handler.finally do
+        @handlers.delete handler
+        @select_handler.rewind
+
+        # I assume if we made it here something went quite wrong
+        squash if running? && @handlers.empty?
+      end
+    end
 
-        def log(*args)
-            msg = ''
-            err = args[-1]
-            if err && err.respond_to?(:backtrace)
-                msg << "unhandled exception: #{err.message} (#{args[0..-2]})"
-                msg << "\n#{err.backtrace.join("\n")}" if err.respond_to?(:backtrace) && err.backtrace
-            else
-                msg << "unhandled exception: #{args}"
-            end
-            @logger.error msg
-            ::Libuv::Q.reject(@web, msg)
-        end
+    # TODO FIXME Review this method.
+    def log(*args)
+      msg = ''
+      err = args[-1]
+      if err && err.respond_to?(:backtrace)
+        msg << "unhandled exception: #{err.message} (#{args[0..-2]})"
+        msg << "\n#{err.backtrace.join("\n")}" if err.respond_to?(:backtrace) && err.backtrace
+      else
+        msg << "unhandled exception: #{args}"
+      end
+      @logger.error msg
+      ::Libuv::Q.reject @web, msg
     end
+  end
 end