spider-gazelle 1.2.0 → 2.0.0

data/lib/spider-gazelle/reactor.rb

@@ -0,0 +1,69 @@
+require 'libuv'
+require 'spider-gazelle/logger'
+
+
+module SpiderGazelle
+    class Reactor
+        include Singleton
+        attr_reader :thread
+
+
+        def initialize
+            @thread = ::Libuv::Loop.default
+            @logger = Logger.instance
+            @running = false
+            @shutdown = method(:shutdown)
+            @shutdown_called = false
+        end        
+
+        def run(&block)
+            if @running
+                @thread.schedule block
+            else
+                @running = true
+                @thread.run { |logger|
+                    logger.progress method(:log)
+                    
+                    # Listen for the signal to shutdown
+                    @thread.signal :INT, @shutdown
+
+                    block.call
+                }
+            end
+        end
+
+        def shutdown(_ = nil)
+            if @shutdown_called
+                @logger.warn "Shutdown called twice! Callstack:\n#{caller.join("\n")}"
+                return
+            end
+
+            @thread.schedule do
+                return if @shutdown_called
+                @shutdown_called = true
+
+                # Signaller will manage the shutdown of the gazelles
+                signaller = Signaller.instance.shutdown
+                signaller.finally do
+                    @thread.stop
+                    # New line on exit to avoid any ctrl-c characters
+                    # We check for pipe as we only want the master process to print this
+                    puts "\nSpider-Gazelle leaps through the veldt\n" unless @logger.pipe
+                end
+            end
+        end
+
+        # This is an unhandled error on the Libuv Event loop
+        def log(level, errorid, error)
+            msg = ''
+            if error.respond_to?(:backtrace)
+                msg << "unhandled exception: #{error.message} (#{level} - #{errorid})"
+                backtrace = error.backtrace
+                msg << "\n#{backtrace.join("\n")}" if backtrace
+            else
+                msg << "unhandled exception: #{args}"
+            end
+            @logger.error msg
+        end
+    end
+end

data/lib/spider-gazelle/signaller.rb

@@ -0,0 +1,214 @@
+require 'libuv'
+
+
+module SpiderGazelle
+    class Signaller
+        include Singleton
+
+
+        attr_reader   :thread, :pipe
+        attr_accessor :gazelle
+
+
+        def initialize
+            @thread = ::Libuv::Loop.default
+            @logger = Logger.instance
+
+            # This is used to check if an instance of spider-gazelle is already running
+            @is_master = false
+            @is_client = false
+            @is_connected = false
+            @client_check = @thread.defer
+            @validated = [] # Set requires more processing
+            @validating = {}
+        end
+
+        def request(options)
+            defer = @thread.defer
+
+            defer.resolve(true)
+
+            defer.promise
+        end
+
+        def check
+            @thread.next_tick do
+                connect_to_sg_master
+            end
+            @client_check.promise
+        end
+
+        def shutdown
+            defer = @thread.defer
+
+            # Close the SIGNAL_SERVER pipe
+            @pipe.close if @is_connected
+
+            # Request spider or gazelle process to shutdown
+            if @gazelle
+                @gazelle.shutdown(defer)
+            end
+
+            if defined?(::SpiderGazelle::Spider)
+                Spider.instance.shutdown(defer)
+            else
+                # This must be the master process
+                @thread.next_tick do
+                    defer.resolve(true)
+                end
+            end
+
+            defer.promise
+        end
+
+        # ------------------------------
+        # Called from the spider process
+        # ------------------------------
+        def authenticate(password)
+            @pipe.write "\x02validate #{password}\x03"
+        end
+
+        def general_failure
+            @pipe.write "\x02Signaller general_failure\x03".freeze
+        rescue
+        ensure
+            Reactor.instance.shutdown
+        end
+
+        def self.general_failure(_)
+            Reactor.instance.shutdown
+        end
+
+
+        protected
+
+
+        def connect_to_sg_master
+            @pipe = @thread.pipe :ipc
+
+            process = method(:process_response)
+            @pipe.connect(SIGNAL_SERVER) do |client|
+                @is_client = true
+                @is_connected = true
+
+                @logger.verbose "Client connected to SG Master".freeze
+                
+                require 'uv-rays/buffered_tokenizer'
+                @parser = ::UV::BufferedTokenizer.new({
+                    indicator: "\x02",
+                    delimiter: "\x03"
+                })
+
+                client.progress process
+                client.start_read
+                @client_check.resolve(true)
+            end
+
+            @pipe.catch do |reason|
+                if !@is_client
+                    @client_check.resolve(false)
+                end
+            end
+
+            @pipe.finally do
+                if @is_client
+                    @is_connected = false
+                    panic!(nil)
+                else
+                    # Assume the role of master
+                    become_sg_master
+                end
+            end
+        end
+
+        def become_sg_master
+            @is_master = true
+            @is_client = false
+            @is_connected = true
+
+            # Load the server request processor here
+            require 'spider-gazelle/signaller/signal_parser'
+            @pipe = @thread.pipe :ipc
+
+            begin
+                File.unlink SIGNAL_SERVER
+            rescue
+            end
+
+            process = method(:process_request)
+            @pipe.bind(SIGNAL_SERVER) do |client|
+                @logger.verbose { "Client <0x#{client.object_id.to_s(16)}> connection made" }
+                @validating[client.object_id] = SignalParser.new
+
+                client.catch do |error|
+                    @logger.print_error(error, "Client <0x#{client.object_id.to_s(16)}> connection error")
+                end
+
+                client.finally do
+                    @validated.delete client
+                    @validating.delete client.object_id
+                    @logger.verbose { "Client <0x#{client.object_id.to_s(16)}> disconnected, #{@validated.length} remaining" }
+
+                    # If all the process connections are gone then we want to shutdown
+                    # This should never happen under normal conditions
+                    if @validated.length == 0
+                        Reactor.instance.shutdown
+                    end
+                end
+
+                client.progress process
+                client.start_read
+            end
+
+            # catch server errors
+            @pipe.catch method(:panic!)
+            @pipe.finally { @is_connected = false }
+
+            # start listening
+            @pipe.listen(INTERNAL_PIPE_BACKLOG)
+        end
+
+        def panic!(reason)
+            #@logger.error "Master pipe went missing: #{reason}"
+            # Server most likely exited
+            # We'll shutdown here
+            Reactor.instance.shutdown
+        end
+
+        # The server processes requests here
+        def process_request(data, client)
+            validated = @validated.include?(client)
+            parser = @validating[client.object_id]
+
+            if validated
+                parser.process data
+            else
+                result = parser.signal(data)
+
+                case result
+                when :validated
+                    @validated.each do |old|
+                        old.write "\x02update\x03".freeze
+                    end
+                    @validated << client
+                    if @validated.length > 1
+                        client.write "\x02wait\x03".freeze
+                    else
+                        client.write "\x02ready\x03".freeze
+                    end
+                    @logger.verbose { "Client <0x#{client.object_id.to_s(16)}> connection was validated" }
+                when :close_connection
+                    client.close
+                    @logger.warn "Client <0x#{client.object_id.to_s(16)}> connection was closed due to bad credentials"
+                end
+            end
+        end
+
+        # The client processes responses here
+        def process_response(data, server)
+            @parser.extract(data).each do |msg|
+                Spider.instance.__send__(msg)
+            end
+        end
+    end
+end

data/lib/spider-gazelle/signaller/signal_parser.rb

@@ -0,0 +1,66 @@
+require 'uv-rays'
+
+
+module SpiderGazelle
+    class Signaller
+        class SignalParser
+            def initialize
+                @tokenizer = ::UV::BufferedTokenizer.new({
+                    indicator: "\x02",
+                    delimiter: "\x03"
+                })
+                @logger = Logger.instance
+                @launchctrl = LaunchControl.instance
+            end
+
+            def process(msg)
+                @tokenizer.extract(msg).each do |cmd|
+                    perform cmd
+                end
+            end
+
+            # These are signals that can be sent
+            # While the remote client is untrusted
+            def signal(msg)
+                result = nil
+                @tokenizer.extract(msg).each do |request|
+                    result = check request
+                end
+                result
+            end
+
+
+            protected
+
+
+            def perform(cmd)
+                begin
+                    klass, action, data = cmd.split(' ', 3)
+                    SpiderGazelle.const_get(klass).__send__(action, data)
+                rescue => e
+                    @logger.print_error(e, 'Error executing command in SignalParser')
+                end
+            end
+
+            def check(cmd)
+                comp = cmd.split(' ', 2)
+                request = comp[0].to_sym
+                data = comp[1]
+
+                case request
+                when :validate
+                    if data == @launchctrl.password
+                        return :validated
+                    else
+                        return :close_connection
+                    end
+                when :reload
+                when :Logger
+                    perform cmd
+                end
+
+                request
+            end
+        end
+    end
+end

data/lib/spider-gazelle/spider.rb

@@ -1,391 +1,353 @@
-require 'spider-gazelle/const'
-require 'set'
-require 'thread'
-require 'logger'
-require 'singleton'
-require 'fileutils' # mkdir_p
-require 'forwardable' # run method
+require 'spider-gazelle/spider/binding'        # Holds a reference to a bound port
+require 'securerandom'
+
 
 module SpiderGazelle
-  class Spider
-    include Const
-    include Singleton
-
-    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
-    }
-
-    attr_reader :state, :mode, :threads, :logger
-    def in_mode?(mode)
-      mode.to_sym == @mode
-    end
+    class Spider
+        include Singleton
 
-    extend Forwardable
-    def_delegators :@web, :run
 
-    def self.run(app, options = {})
-      options = DEFAULT_OPTIONS.merge options
+        # This allows applications to recieve a callback once the server has
+        # completed loading the applications. Port binding is in progress
+        def loaded
+            @load_complete.promise
+        end
 
-      ENV['RACK_ENV'] = options[:environment].to_s if options[:environment]
+        # Applications can query the availability of various modes to share resources
+        def in_mode?(mode)
+            !!@loading[mode.to_sym]
+        end
 
-      puts "Look out! Here comes Spider-Gazelle #{SPIDER_GAZELLE_VERSION}!"
-      puts "* Environment: #{ENV['RACK_ENV']} on #{RUBY_ENGINE || 'ruby'} #{RUBY_VERSION}"
+        attr_reader :logger, :threads
 
-      server = instance
-      server.run do |logger|
-        logger.progress server.method(:log)
-        server.loaded.then do
-          puts "* Loading: #{app}"
 
-          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
+        def initialize
+            @logger = Logger.instance
+            @signaller = Signaller.instance
+            @thread = @signaller.thread
 
-          puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
-        end
-      end
-    end
+            # Gazelle pipe connection management
+            @gazelles = {
+                # process: [],
+                # thread: [],
+                # no_ipc: gazelle_instance
+            }
+            @counts = {
+                # process: number
+                # thread: number
+            }
+            @loading = {}     # mode => load defer
+            @bindings = {}    # port => binding
+            @iterators = {}   # mode => gazelle round robin iterator
+            @iterator_source = {}   # mode => gazelle pipe array (iterator source)
 
-    def initialize
-      # Threaded mode by default
-      reanimating!
-      @bindings = {}
-      # @bindings = {
-      #   id => [bind1, bind2]
-      # }
-
-      # Single reactor in development
-      if ENV['RACK_ENV'].to_sym == :development
-        @mode = :no_ipc
-      else
-        mode = ENV['SG_MODE'] || :thread
-        @mode = mode.to_sym
-      end
-
-      @delegate = method(no_ipc? ? :direct_delegate : :delegate)
-      @squash = method(:squash)
-
-      log_path = ENV['SG_LOG'] || File.expand_path('log/sg.log', Dir.pwd)
-      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
-      reanimate
-    end
+            @password = SecureRandom.hex
 
-    # Modes
-    def thread?
-      @mode == :thread
-    end
-    def process?
-      @mode == :process
-    end
-    def no_ipc?
-      @mode == :no_ipc
-    end
+            @running = true
+            @loaded = false
+            @bound = false
 
-    # 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
+            @load_complete = @thread.defer
+        end
 
-    # 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
+        def run!(options)
+            @options = options
+            @logger.verbose { "Spider Pid: #{Process.pid} started" }
+            if options[0][:isolate]
+                ready
+            else
+                @signaller.authenticate(options[0][:spider])
+            end
+        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
+        # Load gazelles and make the required bindings
+        def ready
+            start_gazelle_server
+            load_promise = load_applications
+            load_promise.then do
+                # Check a shutdown request didn't occur as we were loading
+                if @running
+                    @logger.verbose "All gazelles running".freeze
+
+                    # This happends on the master thread so we don't need to check
+                    # for the shutdown events here
+                    bind_application_ports
+                else
+                    @logger.warn "A shutdown event occured while loading".freeze
+                    perform_shutdown
+                end
+            end
 
-      ports = [ports] if ports.is_a?(Hash)
-      ports << {} if ports.empty?
+            # Provide applications with a load complete callback
+            @load_complete.resolve(load_promise)
+        end
 
-      @web.schedule do
-        begin
-          app_id = AppStore.load app
-          bindings = @bindings[app_id] ||= []
+        # Load gazelles and wait for the bindings to be sent
+        def wait
+            
+        end
 
-          ports.each { |options| bindings << Binding.new(@web, @delegate, app_id, options) }
+        # Pass existing bindings to the master process
+        def update
 
-          defer.resolve(running? ? start(app, app_id) : true)
-        rescue Exception => e
-          defer.reject e
         end
-      end
 
-      defer.promise
-    end
+        # Load a second application (requires a new port binding)
+        def load
 
-    # 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
 
-      defer.promise
-    end
+        # Shutdown after current requests have completed
+        def shutdown(finished)
+            @shutdown_defer = finished
 
-    # 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)
+            @logger.verbose { "Spider Pid: #{Process.pid} shutting down" }
+
+            if @loaded
+                perform_shutdown
+            else
+                @running = false
+            end
         end
-      else
-        defer.reject 'application not loaded'
-      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}").finally do
-        client.close
-      end
-    end
+        # This starts the server the gazelles will be connecting to
+        def start_gazelle_server
+            @pipe_file = "#{SPIDER_SERVER}#{Process.pid}"
+            @logger.verbose { "Spider server starting on #{@pipe_file}" }
 
-    def direct_delegate(client, tls, port, app_id)
-      indicator = tls ? USE_TLS : NO_TLS
-      @gazelle.__send__(:new_connection, "#{indicator} #{port} #{app_id}", client)
-    end
+            @pipe = @thread.pipe :ipc
+            begin
+                File.unlink @pipe_file
+            rescue
+            end
 
-    # Triggers the creation of gazelles
-    def reanimate
-
-      # 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
-
-      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
-        @delegator = @web.pipe :with_socket_support
-        @delegator.bind(DELEGATE_PIPE, @accept_handler)
-        @delegator.listen INTERNAL_PIPE_BACKLOG
-
-        # Bind the pipe for communicating with gazelle
-        begin
-          File.unlink SIGNAL_PIPE
-        rescue
+            shutdown = false
+            check = method(:check_credentials)
+            @pipe.bind(@pipe_file) do |client|
+                @logger.verbose { "Gazelle <0x#{client.object_id.to_s(16)}> connection made" }
+
+                # Shutdown if there is an error with any of the gazelles
+                client.catch do |error|
+                    begin
+                        @logger.print_error(error, "Gazelle <0x#{client.object_id.to_s(16)}> connection error")
+                    rescue
+                    end
+                end
+
+                # Client closed gracefully
+                client.finally do
+                    begin
+                        @logger.verbose { "Gazelle <0x#{client.object_id.to_s(16)}> disconnected" }
+                    rescue
+                    ensure
+                        @gazelles.delete client
+                        if !shutdown
+                            shutdown = true
+                            @signaller.general_failure
+                        end
+                    end
+                end
+
+                client.progress check
+                client.start_read
+            end
+
+            # catch server errors
+            @pipe.catch do |error|
+                @logger.print_error(error)
+                @signaller.general_failure
+            end
+
+            # start listening
+            @pipe.listen(INTERNAL_PIPE_BACKLOG)
         end
-        @signaller = @web.pipe
-        @signaller.bind(SIGNAL_PIPE, @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
+
+        def check_credentials(data, gazelle)
+            password, mode = data.split(' ', 2)
+            mode_sym = mode.to_sym
+
+            if password == @password && MODES.include?(mode_sym)
+                @gazelles[mode_sym] ||= []
+                gazelles = @gazelles[mode_sym]
+                gazelles << gazelle
+                @logger.verbose { "Gazelle <0x#{gazelle.object_id.to_s(16)}> connection was validated" }
+
+                # All the gazelles have loaded. Lets start processing requests
+                if gazelles.length == @counts[mode_sym]
+                    @logger.verbose { "#{mode.capitalize} gazelles are ready" }
+
+                    @iterator_source[mode_sym] = gazelles
+                    @iterators[mode_sym] = gazelles.cycle
+                    @loading[mode_sym].resolve(true)
+                end
+            else
+                @logger.warn "Gazelle <0x#{gazelle.object_id.to_s(16)}> connection closed due to bad credentials"
+                gazelle.close
+            end
         end
-      end
 
-      # Signal gazelle death here
-      @web.signal :INT, @squash
+        def load_applications
+            loaded = []
+            @logger.info "Environment: #{ENV['RACK_ENV']} on #{RUBY_ENGINE || 'ruby'} #{RUBY_VERSION}"
 
-      # Update state only once the event loop is ready
-      @gazelles_loaded.promise
-    end
+            # Load the different types of gazelles required
+            @options.each do |app|
+                @logger.info "Loading: #{app[:rackup]}" if app[:rackup]
 
-    # 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
+                mode = app[:mode]
+                loaded << load_gazelles(mode, app[:count], @options) unless @loading[mode]
             end
-            begin
-              @signaller.close
-              File.unlink SIGNAL_PIPE
-            rescue
+
+            # Return a promise that resolves when all the gazelles are loaded
+            # Gazelles will only load the applications that apply to them based on the application type
+            @thread.all(*loaded)
+        end
+
+            
+        def load_gazelles(mode, count, options)
+            defer = @thread.defer
+            @loading[mode] = defer
+
+            pass = options[0][:spider]
+
+            if mode == :no_ipc
+                # Provide the password to the gazelle instance
+                options[0][:gazelle] = @password
+
+                # Start the gazelle
+                require 'spider-gazelle/gazelle'
+                gaz = ::SpiderGazelle::Gazelle.new(@thread, mode).run!(options)
+                @gazelles[:no_ipc] = gaz
+
+                # Setup the round robin
+                @iterator_source[mode] = gaz
+                @iterators[mode] = gaz
+                defer.resolve(true)
+            else
+                require 'thread'
+
+                # Provide the password to the gazelle instance
+                options[0][:gazelle] = @password
+                options[0][:gazelle_ipc] = @pipe_file
+
+                count = @counts[mode] = count || ::Libuv.cpu_count || 1
+                @logger.info "#{mode.to_s.capitalize} count: #{count}"
+
+                if mode == :thread
+                    require 'spider-gazelle/gazelle'
+                    reactor = Reactor.instance
+
+                    @threads = []
+                    count.times do
+                        thread = ::Libuv::Loop.new
+                        @threads << thread
+
+                        Thread.new { load_gazelle_thread(reactor, thread, mode, options) }
+                    end
+                else
+                    # Remove the spider option
+                    args = LaunchControl.instance.args - ['-s', pass]
+
+                    # Build the command with the gazelle option
+                    args = [EXEC_NAME, '-g', @password, '-f', @pipe_file] + args
+
+                    @logger.verbose { "Launching #{count} gazelle processes" }
+                    count.times do
+                        Thread.new { launch_gazelle(args) }
+                    end
+                end
             end
 
-            @web.stop
-            dead!
-          end
+            defer.promise
         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
+        def load_gazelle_thread(reactor, thread, mode, options)
+            thread.run do |logger|
+                # Log any unhandled errors
+                logger.progress reactor.method(:log)
 
-    def start_bindings
-      running!
+                # Start the gazelle
+                ::SpiderGazelle::Gazelle.new(thread, :thread).run!(options)
+            end
+        end
 
-      # Start any bindings that are already present
-      @bindings.each { |key, val| start(key) }
+        def launch_gazelle(cmd)
+            # Wait for the process to close
+            result = system(*cmd)
+
+            # Kill the spider if a process exits unexpectedly
+            if @running
+                @thread.schedule do
+                    if result
+                        @logger.verbose "Gazelle process exited with exit status 0".freeze
+                    else
+                        @logger.error "Gazelle process exited unexpectedly".freeze
+                    end
+                     
+                    @signaller.general_failure
+                end
+            end
+        end
 
-      # Inform any listeners that we have completed loading
-      @gazelles_loaded.resolve @gazelle_count
-    end
+        def bind_application_ports
+            @bound = true
+            @loaded = true
 
-    # 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
+            @options.each_index do |id|
+                options = @options[id]
+                iterator = @iterators[options[:mode]]
 
-    # 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.backtrace
-      else
-        msg << "unhandled exception: #{args}"
-      end
-      @logger.error msg
-      ::Libuv::Q.reject @web, msg
+                binding = @bindings[options[:port]] = Binding.new(iterator, id.to_s, options)
+                binding.bind
+            end
+        end
+
+
+        # -------------------
+        # Shutdown Management
+        # -------------------
+        def perform_shutdown
+            if @bound
+                # Unbind any ports we are bound to
+                ports = []
+                @bindings.each do |port, binding|
+                    ports << binding.unbind
+                end
+
+                # Shutdown once the ports are all closed
+                @thread.finally(*ports).then do
+                    shutdown_gazelles
+                end
+            else
+                shutdown_gazelles
+            end
+        end
+
+        def shutdown_gazelles
+            @bound = false
+            promises = []
+
+            @iterator_source.each do |mode, gazelles|
+                if mode == :no_ipc
+                    # itr is a gazelle in no_ipc mode
+                    defer = @thread.defer
+                    gazelles.shutdown(defer)
+                    promises << defer.promise
+
+                else
+                    # End communication with the gazelle threads / processes
+                    gazelles.each do |gazelle|
+                        promises << gazelle.close
+                    end
+                end
+            end
+
+            # Finish shutdown after all signals have been sent
+            @shutdown_defer.resolve(@thread.finally(*promises))
+        end
     end
-  end
 end