spider-gazelle 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ffd0e265eacee179a3ecd3ef2b55546656aaa31
-  data.tar.gz: 65f4d1cc2bfb36040840492dc6013733bdd2bd99
+  metadata.gz: 523c991f5e4470fe7b6170fad1fd32a59226c12d
+  data.tar.gz: 92b58b38698befe73be3fd9aa20d54beb675bb7e
 SHA512:
-  metadata.gz: 9579a2a0879d1ee81059f4ed7d19a0827630aa5d0737b37fac4c4485dc36b7ddf47f3cece95f065c3d454cb8b9ad712cd7f09b0a01b7762da8fdc2333609efa9
-  data.tar.gz: 8168496effeeaaef233c9e318251dab67b345ff8136012e1242b2e4bdf2ace18dfb2828cbc840f78dfb325119a53a1285abe5634f3d79fec8dd20af747cc2260
+  metadata.gz: 7b469356bdda20fdaa8caea8769d02595002a9f943dbd08320043f1a6e57026150f0e2cfe1692d3c929f3cc68b7a3007dd6835cda4dddfe2835609d9eea31bff
+  data.tar.gz: 75b41769b7c3006dd084d978b34a66eff5ab9669dc25f8ac695f45ac0852d87a9b5576105b186470f75174b5459325f53b833530a329c9cc03b77c5d8d06e399

data/README.md

@@ -1,5 +1,7 @@
 # spider-gazelle
 
+[<img src="https://codeclimate.com/github/cotag/spider-gazelle.png" />](https://codeclimate.com/github/cotag/spider-gazelle)
+
 
 A fast, parallel and concurrent web server for ruby
 
@@ -28,3 +30,8 @@ Look out! Here comes the Spidergazelle!
 
 For other command line options look at [the source](/bin/sg)
 
+
+## Community support
+
+* [GitHub issues](https://github.com/cotag/spider-gazelle/issues).
+* IRC channel `#spider-gazelle` at `irc.freenode.net`.

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

@@ -1,39 +1,37 @@
-require 'rack/handler'
-require 'spider-gazelle'
-
+require "rack/handler"
+require "spider-gazelle"
+require "spider-gazelle/const"
 
 module Rack
-    module Handler
-        module SpiderGazelle
-            DEFAULT_OPTIONS = {
-                :Host => '0.0.0.0',
-                :Port => 8080,
-                :Verbose => false
-            }
-
-            def self.run(app, options = {})
-                options = DEFAULT_OPTIONS.merge(options)
-
-                if options[:Verbose]
-                    app = Rack::CommonLogger.new(app, STDOUT)
-                end
-
-                if options[:environment]
-                    ENV['RACK_ENV'] = options[:environment].to_s
-                end
-
-                ::SpiderGazelle::Spider.run app, options
-            end
+  module Handler
+    module SpiderGazelle
+      DEFAULT_OPTIONS = {
+        :Host => "0.0.0.0",
+        :Port => 8080,
+        :Verbose => false
+      }
+
+      def self.run(app, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+
+        if options[:Verbose]
+          app = Rack::CommonLogger.new(app, STDOUT)
+        end
 
-            def self.valid_options
-                {
-                    "Host=HOST"       => "Hostname to listen on (default: 0.0.0.0)",
-                    "Port=PORT"       => "Port to listen on (default: 8080)",
-                    "Quiet"           => "Don't report each request"
-                }
-            end
+        if options[:environment]
+          ENV["RACK_ENV"] = options[:environment].to_s
         end
 
-        register :'spider-gazelle', SpiderGazelle
+        ::SpiderGazelle::Spider.run app, options
+      end
+
+      def self.valid_options
+        { "Host=HOST"       => "Hostname to listen on (default: 0.0.0.0)",
+          "Port=PORT"       => "Port to listen on (default: 8080)",
+          "Quiet"           => "Don't report each request" }
+      end
     end
+
+    register :"spider-gazelle", SpiderGazelle
+  end
 end

data/lib/spider-gazelle.rb

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

data/lib/spider-gazelle/app_store.rb

@@ -1,69 +1,64 @@
 require 'thread'
 require 'radix/base'
 
-
 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)
+  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
+    @mutex = Mutex.new
+    @apps = ThreadSafe::Cache.new
+    @loaded = ThreadSafe::Cache.new
+    @count = 0
 
-        # Load an app and assign it an ID
-        def self.load(app, options={})
-            is_rack_app = !app.is_a?(String)
-            app_key = is_rack_app ? app.class.name.to_sym : app.to_sym
-            id = @loaded[app_key]
+    # Load an app and assign it an ID
+    def self.load(app, options={})
+      is_rack_app = !app.is_a?(String)
+      app_key = is_rack_app ? app.class.name.to_sym : app.to_sym
+      id = @loaded[app_key]
 
-            if id.nil?
-                app, options = ::Rack::Builder.parse_file(app) unless is_rack_app
+      if id.nil?
+        app, options = ::Rack::Builder.parse_file(app) unless is_rack_app
 
-                count = 0
-                @mutex.synchronize {
-                    count = @count += 1
-                }
-                id = Radix.convert(count, B10, B65).to_sym
-                @apps[id] = app
-                @loaded[app_key] = id
-            end
+        count = 0
+        @mutex.synchronize { count = @count += 1 }
+        id = Radix.convert(count, B10, B65).to_sym
+        @apps[id] = app
+        @loaded[app_key] = id
+      end
 
-            id
-        end
+      id
+    end
 
-        # Manually load an app
-        def self.add(app)
-            id = @loaded[app.__id__]
+    # 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
+      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
+      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
+    # 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
+    # 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

@@ -1,65 +1,59 @@
-require 'thread'
+require 'spider-gazelle/const'
 require 'set'
-
+require 'thread'
 
 module SpiderGazelle
-    class Binding
-
-
-        attr_reader :app_id
-
-
-        def initialize(loop, delegate, app_id, options = {})
-            @app_id = app_id
-            @options = options
-            @loop = loop
-            @delegate = delegate
-            @tls = @options[:tls] || false
-            @port = @options[:Port] || (@tls ? 443 : 80)
-            @optimize = @options[:optimize_for_latency] || true
-
-            # 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
+  class Binding
+    include Const
+
+    attr_reader :app_id
+
+    def initialize(loop, delegate, app_id, options = {})
+      @app_id = app_id
+      @options = options
+      @loop = loop
+      @delegate = delegate
+      @tls = @options[:tls] || false
+      @port = @options[:Port] || (@tls ? PORT_443 : PORT_80)
+      @optimize = @options[:optimize_for_latency] || true
+
+      # Connection management functions
+      @new_connection = method :new_connection
+      @accept_connection = method :accept_connection
+    end
 
-        # Close the bindings
-        def unbind
-            # close unless we've never been bound
-            @tcp.close unless @tcp.nil?
-            @tcp
-        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 { |e| @loop.log(:error, 'application bind failed', e) }
+      @tcp
+    end
 
-        protected
+    # 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
+    # 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
+    # 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

@@ -1,366 +1,330 @@
+require 'spider-gazelle/const'
 require 'stringio'
 
-
 module SpiderGazelle
-    class Connection
-        Hijack = Struct.new(:socket, :env)
-
-        REQUEST_METHOD = 'REQUEST_METHOD'.freeze # NOTE:: duplicate in gazelle.rb
-        HEAD = 'HEAD'.freeze
-
-        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
-        NEWLINE = "\n".freeze
-        ZERO = '0'.freeze
-
-        HTTP_STATUS_CODES = ::Rack::Utils::HTTP_STATUS_CODES
-        HTTP_STATUS_DEFAULT = proc { 'CUSTOM' }
-
-        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
-        # For Request
-        attr_reader :tls, :port, :loop, :socket, :async_callback
-
-
-        def initialize(gazelle, loop, socket, port, state, app, queue)
-            # A single parser instance per-connection (supports pipelining)
-            @state = state
-            @pending = []
-
-            # Work callback for thread pool processing
-            @request = nil
-            @work = method(:work)
-
-            # Called after the work on the thread pool is complete
-            @send_response = method(:send_response)
-            @send_error = method(:send_error)
-
-            # Used to chain promises (ensures requests are processed in order)
-            @process_next = method(:process_next)
-            @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
-            @parsing = Request.new(self, @app)
-        end
+  class Connection
+    include Const
+
+    Hijack = Struct.new :socket, :env
+
+    def self.on_progress(data, socket); end
+    DUMMY_PROGRESS = self.method :on_progress
+
+    # For Gazelle
+    attr_reader :state, :parsing
+    # For Request
+    attr_reader :tls, :port, :loop, :socket, :async_callback
+
+    def initialize(gazelle, loop, socket, port, state, app, queue)
+      # A single parser instance per-connection (supports pipelining)
+      @state = state
+      @pending = []
+
+      # Work callback for thread pool processing
+      @request = nil
+      @work = method :work
+
+      # Called after the work on the thread pool is complete
+      @send_response = method :send_response
+      @send_error = method :send_error
+
+      # Used to chain promises (ensures requests are processed in order)
+      @process_next = method :process_next
+      @write_chunk = method :write_chunk
+      # Keep track of work queue head to prevent unintentional GC
+      @current_worker = queue
+      # Start queue with an existing resolved promise (::Libuv::Q::ResolvedPromise.new(@loop, true))
+      @queue_worker = queue
+
+      # 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
 
-        # 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 than we need to
-            end
-            @parsing.upgrade = @state.upgrade?
-            @pending.push @parsing
-            @queue_worker = @queue_worker.then @process_next
-        end
+    # Lazy eval the IP
+    def remote_ip
+      @remote_ip ||= @socket.peername[0]
+    end
 
-        # The parser encountered an error
-        def parsing_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
+    # Creates a new request state object
+    def start_parsing
+      @parsing = Request.new self, @app
+    end
 
-        # Schedule send
-        def response(data)
-            @loop.schedule
-        end
+    # Chains the work in a promise queue
+    def finished_parsing
+      if !@state.keep_alive?
+        @parsing.keep_alive = false
+        # We don't want to do any more work than we need to
+        @socket.stop_read
+      end
+
+      @parsing.upgrade = @state.upgrade?
+      @pending.push @parsing
+      @queue_worker = @queue_worker.then @process_next
+    end
 
+    # The parser encountered an error
+    def parsing_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
+        @socket.write ERROR_400_RESPONSE
+        @socket.shutdown
+      end
+    end
 
-        protected
+    # Schedule send
+    def response(data)
+      @loop.schedule
+    end
 
+    protected
 
-        # --------------
-        # State handlers:
-        # --------------
+    ##
+    # 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
 
-        # 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"
+        @gazelle.logger.error msg
+      end
+    end
 
-            # 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
+      # Resolves the promise with a promise
+      @current_worker.then @send_response, @send_error
+    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
 
-        # 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?
+        # Unlink the progress callback (prevent funny business)
+        @socket.progress &DUMMY_PROGRESS
+        @gazelle.discard self
+        @gazelle = nil
+        @state = nil
+      end
+    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
+    ##
+    # 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 @request.hijacked
+        # Unlink the management of the socket
+        unlink
+
+        # 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
+
+          send_body = @request.env[REQUEST_METHOD] != HEAD
+
+          # If a file, stream the body in a non-blocking fashion
+          if body.respond_to? :to_path
+            if headers[CONTENT_LENGTH2]
+              type = :raw
+            else
+              type = :http
+              headers[TRANSFER_ENCODING] = CHUNKED
             end
-        end
 
+            write_headers status, headers
 
-        # ----------------------
-        # 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 @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
-
-                    send_body = @request.env[REQUEST_METHOD] != HEAD
-
-                    # If a file, stream the body in a non-blocking fashion
-                    if body.respond_to? :to_path
-                        if headers[CONTENT_LENGTH]
-                            type = :raw
-                        else
-                            type = :http
-                            headers[TRANSFER_ENCODING] = CHUNKED
-                        end
-
-                        write_headers(status, headers)
-
-                        if send_body
-                            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
-                        end
-                    else
-                        # Optimize the response
-                        begin
-                            body_size = body.size
-                            if body_size < 2
-                                if body_size == 1
-                                    headers[CONTENT_LENGTH] = body[0].bytesize
-                                else
-                                    headers[CONTENT_LENGTH] = ZERO
-                                end
-                            end
-                        rescue # just in case
-                        end
-
-                        if send_body
-                            write_response(status, headers, body)
-                        else
-                            write_headers(status, headers)
-                            @socket.shutdown if @request.keep_alive == false
-                        end
-                    end
+            if send_body
+              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
+                  @socket.shutdown if @request.keep_alive == false
                 end
+              end
+              return file
+            end
+          else
+            # Optimize the response
+            begin
+              if body.size < 2
+                headers[CONTENT_LENGTH2] = body.size == 1 ? body[0].bytesize : ZERO
+              end
+            rescue # just in case
             end
 
-            # continue processing (don't wait for write to complete)
-            # if the write fails it will close the socket
-            nil
+            if send_body
+              write_response status, headers, body
+            else
+              write_headers status, headers
+              @socket.shutdown if @request.keep_alive == false
+            end
+          end
         end
+      end
 
-        def write_response(status, headers, body)
-            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
+      # continue processing (don't wait for write to complete)
+      # if the write fails it will close the socket
+      nil
+    end
 
-                @socket.shutdown if @request.keep_alive == false
-            else
-                headers[TRANSFER_ENCODING] = CHUNKED
-                write_headers(status, headers)
+    def write_response(status, headers, body)
+      if headers[CONTENT_LENGTH2]
+        headers[CONTENT_LENGTH2] = headers[CONTENT_LENGTH2].to_s
+        write_headers status, headers
 
-                # Stream the response
-                body.each &@write_chunk
+        # Stream the response (pass directly into @socket.write)
+        body.each &@socket.method(:write)
 
-                if @request.deferred.nil?
-                    @socket.write EOF
-                    @socket.shutdown if @request.keep_alive == false
-                else
-                    @async_state = :chunked
-                end
-            end
+        if @request.deferred
+          @request.deferred.resolve true
+          # Prevent data being sent after completed
+          @request.deferred = nil
         end
 
-        def write_headers(status, headers)
-            headers[CONNECTION] = CLOSE if @request.keep_alive == false
+        @socket.shutdown if @request.keep_alive == false
+      else
+        headers[TRANSFER_ENCODING] = CHUNKED
+        write_headers status, headers
 
-            header = "HTTP/1.1 #{status} #{fetch_code(status)}\r\n"
-            headers.each do |key, value|
-                next if key.start_with? RACK
+        # Stream the response
+        body.each &@write_chunk
 
-                value.split(NEWLINE).each do |unique_value|
-                    header << key
-                    header << COLON_SPACE
-                    header << unique_value
-                    header << CRLF
-                end
-            end
-            header << CRLF
-            @socket.write header
+        if @request.deferred.nil?
+          @socket.write CLOSE_CHUNKED
+          @socket.shutdown if @request.keep_alive == false
+        else
+          @async_state = :chunked
         end
+      end
+    end
 
-        def write_chunk(part)
-            chunk = part.bytesize.to_s(16) << CRLF << part << CRLF
-            @socket.write chunk
-        end
+    def write_headers(status, headers)
+      headers[CONNECTION] = CLOSE if @request.keep_alive == false
 
-        def fetch_code(status)
-            HTTP_STATUS_CODES.fetch(status, &HTTP_STATUS_DEFAULT)
+      header = "HTTP/1.1 #{status} #{fetch_code(status)}\r\n"
+      headers.each do |key, value|
+        next if key.start_with? RACK
+
+        value.split(NEWLINE).each do |unique_value|
+          header << key
+          header << COLON
+          header << unique_value
+          header << LINE_END
         end
+      end
+      header << LINE_END
+      @socket.write header
+    end
 
+    def write_chunk(part)
+      chunk = part.bytesize.to_s(HEX_SIZE_CHUNKED_RESPONSE) << LINE_END << part << LINE_END
+      @socket.write chunk
+    end
 
-        # ------------------------
-        # Async response functions:
-        # ------------------------
+    def fetch_code(status)
+      HTTP_STATUS_CODES.fetch(status, &HTTP_STATUS_DEFAULT)
+    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
+    # 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 { callback(data) }
+    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
+    # 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
+    # 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 CLOSE_CHUNK
+        @socket.shutdown if @request.keep_alive == false
+
+        # Complete the request here
+        deferred = @request.deferred
+        # Prevent data being sent after completed
+        @request.deferred = nil
+        @async_state = nil
+        deferred.resolve true
+      else
+        # Send the chunks provided
+        body.each &@write_chunk
+      end
+
+      nil
     end
+  end
 end