spider-gazelle 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3081d50c47f8dd30b20deca6f8ff4ab4f6b96b04
-  data.tar.gz: 6d33aab9f1fe72354d919b59d6232918cd452c2b
+  metadata.gz: f6835ff8fc79a090958589cc6c64474d27446b98
+  data.tar.gz: be7c36e4a3a219ee14ee0c35d4099f534b2fa9ee
 SHA512:
-  metadata.gz: fe5cc932cb5a8616da336f5806ff8c46ae7fba0743f42e688d9e9c6a3e9371c05cf1a01081e3f077283a9b8c35b4c93263e75fb6875a7039ef030aaf4314704e
-  data.tar.gz: 1a1ef9210f7edd32884f5e7dba6f7257ff8c4c33b2ee18ab83a2f209e48aa5bc13cf0a455b61316cd7d78702cf0f9b2d89cb41f57f5d9247711b390cdc662f79
+  metadata.gz: 52c7dabc77dbe369030abff53cf86b1c120601de0fc88a03f5e84ce888c7513c99bbe7c2281597d525cb80eac92137e3ebb78e18fd2b0298f2a0b1f0ee47454d
+  data.tar.gz: 4b97ce2d2131da24f716d438c0d82c1e76ed7c94c3b5acdf9263c9175a0b7c8152737e7113ead316116c4fcfae7752ddb2b9548aef6ece7a6336ce22bc06d4d9

data/bin/sg

@@ -6,23 +6,25 @@ require 'optparse'
 
 
 options = {
-    Host: "0.0.0.0",
-    Port: 3000,
+    host: "0.0.0.0",
+    port: 3000,
+    tls: false,
     environment: ENV['RACK_ENV'] || 'development',
-    rackup: "#{Dir.pwd}/config.ru"
+    rackup: "#{Dir.pwd}/config.ru",
+    quiet: false
 }
 
 parser = OptionParser.new do |opts|
     opts.on "-p", "--port PORT", Integer, "Define what port TCP port to bind to (default: 3000)" do |arg|
-        options[:Port] = arg
+        options[:port] = arg
     end
 
     opts.on "-a", "--address HOST", "bind to HOST address (default: 0.0.0.0)" do |arg|
-        options[:Host] = arg
+        options[:host] = arg
     end
 
-    opts.on "-q", "--quiet", "Quiet down the output" do
-        options[:Quiet] = true
+    opts.on "-q", "--quiet", "quiet down the output" do
+        options[:quiet] = true
     end
 
     opts.on "-e", "--environment ENVIRONMENT", "The environment to run the Rack app on (default: development)" do |arg|
@@ -32,6 +34,14 @@ parser = OptionParser.new do |opts|
     opts.on "-r", "--rackup FILE", "Load Rack config from this file (default: config.ru)" do |arg|
         options[:rackup] = arg
     end
+
+    opts.on "-l", "--logfile FILE", "Location of the servers log file (default: logs/server.log)" do |arg|
+        options[:rackup] = arg
+    end
+
+    opts.on "-m", "--mode MODE", "Either thread, process or no_ipc (default: thread)" do |arg|
+        ENV['SG_MODE'] = arg
+    end
 end
 
 parser.banner = "sg <options> <rackup file>"
@@ -50,15 +60,34 @@ unless File.exists?(options[:rackup])
     abort "No rackup found at #{options[:rackup]}"
 end
 
-app, rack_options = Rack::Builder.parse_file options[:rackup]
-server = ::SpiderGazelle::Spider.new(app, options)
-
-puts "Look out! Here comes Spider-Gazelle #{::SpiderGazelle::VERSION}!"
-puts "* Environment: #{ENV['RACK_ENV']}"
-puts "* Listening on tcp://#{options[:Host]}:#{options[:Port]}"
+ENV['RACK_ENV'] = options[:environment].to_s
+# Force process mode on Windows (pipes + sockets not working at the moment)
+ENV['SG_MODE'] = 'no_ipc' if ::FFI::Platform.windows?
+
+::Libuv::Loop.default.run do |logger|
+    logger.progress do |level, errorid, error|
+        begin
+            puts "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+        rescue Exception
+            p 'error in gazelle logger'
+        end
+    end
 
-begin
-    server.run
-ensure
-    puts "\nSpider-Gazelle leaps through the veldt"
+    puts "Look out! Here comes Spider-Gazelle #{::SpiderGazelle::VERSION}!"
+    puts "* Environment: #{ENV['RACK_ENV']} on #{RUBY_ENGINE || 'ruby'} #{RUBY_VERSION}"
+    server = ::SpiderGazelle::Spider.instance
+    server.loaded.then do
+        puts "* Loading: #{options[:rackup]}"
+        server.load(options[:rackup], 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
+            p 'server failed to load - shutting down'
+            server.shutdown
+        end
+
+        puts "* Listening on tcp://#{options[:host]}:#{options[:port]}"
+    end
 end
+
+puts "\nSpider-Gazelle leaps through the veldt"

data/lib/spider-gazelle.rb

@@ -6,8 +6,13 @@ require "spider-gazelle/version"
 require "spider-gazelle/request"        # Holds request information and handles request processing
 require "spider-gazelle/connection"     # Holds connection information and handles request pipelining
 require "spider-gazelle/gazelle"        # Processes data received from connections
+
+require "spider-gazelle/app_store"      # Holds references to the loaded rack applications
+require "spider-gazelle/binding"        # Holds a reference to a bound port and associated rack application
 require "spider-gazelle/spider"         # Accepts connections and offloads them to gazelles
 
+require "spider-gazelle/upgrades/websocket"  # Websocket implementation
+
 
 module SpiderGazelle
     # Delegate pipe used for passing sockets to the gazelles

data/lib/spider-gazelle/app_store.rb

@@ -0,0 +1,67 @@
+require 'thread'
+require 'radix'
+
+
+module SpiderGazelle
+    module AppStore
+        # Basic compression using UTF (more efficient for ID's stored as strings)
+        B65 = ::Radix::Base.new(::Radix::BASE::B62 + ['-', '_', '~'])
+        B10 = ::Radix::Base.new(10)
+
+        @mutex = Mutex.new
+        @count = 0
+        @apps = ThreadSafe::Cache.new
+        @loaded = ThreadSafe::Cache.new
+
+        # Load an app and assign it an ID
+        def self.load(rackup)
+            id = @loaded[rackup.to_sym]
+
+            if id.nil?
+                app, options = ::Rack::Builder.parse_file rackup
+
+                count = 0
+                @mutex.synchronize {
+                    count = @count += 1
+                }
+                id = Radix.convert(count, B10, B65).to_sym
+                @apps[id] = app
+                @loaded[rackup.to_sym] = id
+            end
+
+            id
+        end
+
+        # Manually load an app
+        def self.add(app)
+            id = @loaded[app.__id__]
+
+            if id.nil?
+                count = 0
+                @mutex.synchronize {
+                    count = @count += 1
+                }
+                id = Radix.convert(count, B10, B65).to_sym
+                @apps[id] = app
+                @loaded[app.__id__] = id
+            end
+
+            id
+        end
+
+        # Lookup an application
+        def self.lookup(app)
+            if app.is_a?(String) || app.is_a?(Symbol)
+                @apps[@loaded[app.to_sym]]
+            else
+                @apps[@loaded[app.__id__]]
+            end
+        end
+
+        # Get an app using the id directly
+        def self.get(id)
+            id = id.to_sym if id.is_a?(String)
+            @apps[id]
+        end
+    end
+end

data/lib/spider-gazelle/binding.rb

@@ -0,0 +1,72 @@
+require 'thread'
+require 'set'
+
+
+module SpiderGazelle
+    class Binding
+        DEFAULT_OPTIONS = {
+            :host => '0.0.0.0',
+            :port => 3000,
+            :tls => false,
+            :optimize_for_latency => true,
+            :backlog => 1024
+        }
+
+
+        attr_reader :app_id
+
+
+        def initialize(loop, delegate, app_id, options = {})
+            @app_id = app_id
+            @options = DEFAULT_OPTIONS.merge(options)
+            @loop = loop
+            @delegate = delegate
+            @port = @options[:port]
+            @tls = @options[:tls]
+            @optimize = @options[:optimize_for_latency]
+
+            # Connection management functions
+            @new_connection = method(:new_connection)
+            @accept_connection = method(:accept_connection)
+        end
+
+        # Bind the application to the selected port
+        def bind
+            # Bind the socket
+            @tcp = @loop.tcp
+            @tcp.bind(@options[:host], @port, @new_connection)
+            @tcp.listen(@options[:backlog])
+
+            # Delegate errors
+            @tcp.catch do |e|
+                @loop.log :error, 'application bind failed', e
+            end
+            @tcp
+        end
+
+        # Close the bindings
+        def unbind
+            # close unless we've never been bound
+            @tcp.close unless @tcp.nil?
+            @tcp
+        end
+
+
+        protected
+
+
+        # There is a new connection pending
+        # We accept it
+        def new_connection(server)
+            server.accept @accept_connection
+        end
+
+        # Once the connection is accepted we disable Nagles Algorithm
+        # This improves performance as we are using vectored or scatter/gather IO
+        # Then the spider delegates to the gazelle loops
+        def accept_connection(client)
+            client.enable_nodelay if @optimize == true
+            @delegate.call(client, @tls, @port, @app_id)
+        end
+    end
+end

data/lib/spider-gazelle/connection.rb

@@ -3,18 +3,35 @@ require 'stringio'
 
 module SpiderGazelle
     class Connection
+        Hijack = Struct.new(:socket, :env)
 
 
-        SET_INSTANCE_TYPE = proc {|inst| inst.type = :request}
+        RACK = 'rack'.freeze            # used for filtering headers
+        CLOSE = 'close'.freeze
+        CONNECTION = 'Connection'.freeze
+        CONTENT_LENGTH = 'Content-Length'.freeze
+        TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+        CHUNKED = 'chunked'.freeze
+        COLON_SPACE = ': '.freeze
+        EOF = "0\r\n\r\n".freeze
+        CRLF = "\r\n".freeze
 
+        HTTP_11_400 = "HTTP/1.1 400 Bad Request\r\n\r\n".freeze
 
+
+        def self.on_progress(data, socket); end
+        DUMMY_PROGRESS = self.method(:on_progress)
+
+
+        # For Gazelle
         attr_reader :state, :parsing
-        attr_accessor :queue_worker
+        # For Request
+        attr_reader :tls, :port, :loop, :socket, :async_callback
 
 
-        def initialize(loop, socket, queue) # TODO:: port information
+        def initialize(gazelle, loop, socket, port, state, app, queue)
             # A single parser instance per-connection (supports pipelining)
-            @state = ::HttpParser::Parser.new_instance &SET_INSTANCE_TYPE
+            @state = state
             @pending = []
 
             # Work callback for thread pool processing
@@ -27,24 +44,38 @@ module SpiderGazelle
 
             # Used to chain promises (ensures requests are processed in order)
             @process_next = method(:process_next)
+            @write_chunk = method(:write_chunk)
             @current_worker = queue # keep track of work queue head to prevent unintentional GC
             @queue_worker = queue   # start queue with an existing resolved promise (::Libuv::Q::ResolvedPromise.new(@loop, true))
             
             # Socket for writing the response
             @socket = socket
+            @app = app
+            @port = port
+            @tls = @socket.tls?
             @loop = loop
+            @gazelle = gazelle
+            @async_callback = method(:deferred_callback)
+
+            # Remove connection if the socket closes
+            socket.finally &method(:unlink)
+        end
+
+        # Lazy eval the IP
+        def remote_ip
+            @remote_ip ||= @socket.peername[0]
         end
 
         # Creates a new request state object
-        def start_parsing(request)
-            @parsing = request
+        def start_parsing
+            @parsing = Request.new(self, @app)
         end
 
         # Chains the work in a promise queue
         def finished_parsing
             if !@state.keep_alive?
                 @parsing.keep_alive = false
-                @socket.stop_read   # we don't want to do any more work then we need to
+                @socket.stop_read   # we don't want to do any more work than we need to
             end
             @parsing.upgrade = @state.upgrade?
             @pending.push @parsing
@@ -53,52 +84,251 @@ module SpiderGazelle
 
         # The parser encountered an error
         def parsing_error
-            # TODO::log error (available in the @request object)
-            p "parsing error #{@state.error}"
+            # Grab the error
+            send_error(@state.error)
 
             # We no longer care for any further requests from this client
             # however we will finish processing any valid pipelined requests before shutting down
             @socket.stop_read
             @queue_worker = @queue_worker.then do
                 # TODO:: send response (400 bad request)
+                @socket.write HTTP_11_400
                 @socket.shutdown
             end
         end
 
+        # Schedule send
+        def response(data)
+            @loop.schedule
+        end
+
 
         protected
 
 
+        # --------------
+        # State handlers:
+        # --------------
+
+
+        # Called when an error occurs at any point while responding
+        def send_error(reason)
+            # Close the socket as this is fatal (file read error, gazelle error etc)
+            @socket.close
+
+            # Log the error in a worker thread
+            @loop.work do
+                msg = "connection error: #{reason.message}\n#{reason.backtrace.join("\n") if reason.backtrace}\n"
+                puts msg
+                @gazelle.logger.error msg
+            end
+        end
+
+        # We use promise chaining to move the requests forward
+        # This provides an elegant way to handle persistent and pipelined connections
+        def process_next(result)
+            @request = @pending.shift
+            @current_worker = @loop.work @work
+            @current_worker.then @send_response, @send_error   # resolves the promise with a promise
+        end
+
+        # returns the response as the result of the work
+        # We support the unofficial rack async api (multi-call version for chunked responses)
+        def work
+            @request.execute!
+        end
+
+        # Unlinks the connection from the rack app
+        # This occurs when requested and when the socket closes
+        def unlink
+            if not @gazelle.nil?
+                @socket.progress &DUMMY_PROGRESS        # unlink the progress callback (prevent funny business)
+                @gazelle.discard(self)
+                @gazelle = nil
+                @state = nil
+            end
+        end
+
+
+        # ----------------------
+        # Core response handlers:
+        # ----------------------
+
+
         def send_response(result)
             # As we have come back from another thread the socket may have closed
             # This check is an optimisation, the call to write and shutdown would fail safely
-            if !@socket.closed
-                @socket.write @request.response
-                if @request.keep_alive == false
-                    @socket.shutdown
+
+            if @request.hijacked
+                unlink              # unlink the management of the socket
+                        
+                # Pass the hijack response to the captor using the promise
+                # This forwards the socket and environment as well as moving
+                #  continued execution onto the event loop.
+                @request.hijacked.resolve(Hijack.new(@socket, @request.env))
+
+            elsif !@socket.closed
+                if @request.deferred
+                    # Wait for the response using this promise
+                    promise = @request.deferred.promise
+
+                    # Process any responses that might have made it here first
+                    if @deferred_responses
+                        @deferred_responses.each &method(:respond_with)
+                        @deferred_responses = nil
+                    end
+
+                    return promise
+
+                # NOTE:: Somehow getting to here with a nil request... needs investigation
+                elsif not result.nil?
+                    # clear any cached responses just in case
+                    # could be set by error in the rack application
+                    @deferred_responses = nil if @deferred_responses
+
+                    status, headers, body = result
+
+                    # If a file, stream the body in a non-blocking fashion
+                    if body.respond_to? :to_path
+                        headers[CONNECTION] = CLOSE if @request.keep_alive == false
+
+                        if headers[CONTENT_LENGTH]
+                            type = :raw
+                        else
+                            type = :http
+                            headers[TRANSFER_ENCODING] = CHUNKED
+                        end
+
+                        write_headers(status, headers)
+
+                        file = @loop.file(body.to_path, File::RDONLY)
+                        file.progress do    # File is open and available for reading
+                            file.send_file(@socket, type).finally do
+                                file.close
+                                if @request.keep_alive == false
+                                    @socket.shutdown
+                                end
+                            end
+                        end
+
+                        return file
+                    else
+                        write_response(status, headers, body)
+                    end
                 end
             end
+
             # continue processing (don't wait for write to complete)
             # if the write fails it will close the socket
             nil
         end
 
-        def send_error(reason)
-            p "send error: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
-            # log error reason
-            # TODO:: send response (500 internal error)
-            # no need to close the socket as this isn't fatal
-            nil
+        def write_response(status, headers, body)
+            headers[CONNECTION] = CLOSE if @request.keep_alive == false
+
+            if headers[CONTENT_LENGTH]
+                headers[CONTENT_LENGTH] = headers[CONTENT_LENGTH].to_s
+                write_headers(status, headers)
+
+                # Stream the response (pass directly into @socket.write)
+                body.each &@socket.method(:write)
+
+                if @request.deferred
+                    @request.deferred.resolve(true)
+                    @request.deferred = nil # prevent data being sent after completed
+                end
+
+                @socket.shutdown if @request.keep_alive == false
+            else
+                headers[TRANSFER_ENCODING] = CHUNKED
+                write_headers(status, headers)
+
+                # Stream the response
+                body.each &@write_chunk
+
+                if @request.deferred.nil?
+                    @socket.write EOF
+                    @socket.shutdown if @request.keep_alive == false
+                else
+                    @async_state = :chunked
+                end
+            end
         end
 
-        def process_next(result)
-            @request = @pending.shift
-            @current_worker = @loop.work @work
-            @current_worker.then @send_response, @send_error   # resolves the promise with a promise
+        def write_headers(status, headers)
+            header = "HTTP/1.1 #{status}\r\n"
+            headers.each do |key, value|
+                next if key.start_with? RACK
+
+                header << key
+                header << COLON_SPACE
+                header << value
+                header << CRLF
+            end
+            header << CRLF
+            @socket.write header
         end
 
-        def work
-            @request.execute!
+        def write_chunk(part)
+            chunk = part.bytesize.to_s(16) << CRLF << part << CRLF
+            @socket.write chunk
+        end
+
+
+        # ------------------------
+        # Async response functions:
+        # ------------------------
+
+
+        # Callback from a response that was marked async
+        def deferred_callback(data)
+            # We call close here, like on a regular response
+            body = data[2]
+            body.close if body.respond_to?(:close)
+            @loop.next_tick do
+                callback(data)
+            end
+        end
+
+        # Process a response that was marked as async
+        # Save the data if the request hasn't responded yet
+        def callback(data)
+            begin
+                if @request.deferred && @deferred_responses.nil?
+                    respond_with(data)
+                else
+                    @deferred_responses ||= []
+                    @deferred_responses << data
+                end
+            rescue Exception => e
+                # This provides the same level of protection that
+                #  the regular responses provide
+                send_error(e)
+            end
+        end
+
+        # Process the async request in the same way as Mizuno
+        # See: http://polycrystal.org/2012/04/15/asynchronous_responses_in_rack.html
+        def respond_with(data)
+            status, headers, body = data
+
+            if @async_state.nil?
+                # Respond with the headers here
+                write_response(status, headers, body)
+            elsif body.empty?
+                @socket.write EOF
+                @socket.shutdown if @request.keep_alive == false
+
+                # Complete the request here
+                deferred = @request.deferred
+                @request.deferred = nil # prevent data being sent after completed
+                @async_state = nil
+                deferred.resolve(true)
+            else
+                # Send the chunks provided
+                body.each &@write_chunk
+            end
+            nil
         end
     end
 end