spider-gazelle 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1eb9ae4b8211936cdaf58a02132000044bb58ae3
-  data.tar.gz: 7044a353674ec95eb7aea471e1fc619641b4ec15
+  metadata.gz: 89774225b2801a3f2556563940da21588a6fef70
+  data.tar.gz: 441d840391e7ccb87d98b4bd2830b80a2ed6b1e6
 SHA512:
-  metadata.gz: deff3abf19ba3fdf58250e0b47b27658b4ec183cc5ee5d8f3860c47563314a144aeed2e4efd40de1157d4777976fbfd962fdd74c280d1882264c1b038306a24c
-  data.tar.gz: 72d2d3b04dc181fd1f39d97425123664d2b5c4c2886f2e50d74cd58751231414b2a2de99ecfe82a77a5b711e0586eb775e14080e360ad5a3a8629412d6f0d37b
+  metadata.gz: 96c3c3b76bf21d2756db7e9b51a50f4125ed26a8b60f12ba8e789b0e73aff65ccdd0a933254485bb600f340ce82b42f9bc8c324deb27eec29a1f14002c762712
+  data.tar.gz: 1208f6382502b44b2f02099fd527441d0e923100c7c26801fd5582a48fb53c698d25672e7b85f4f95ddd159ca7c29d7570523bf514b389a64fdbf137855d75b4

data/lib/spider-gazelle/gazelle/app_store.rb

@@ -62,13 +62,12 @@ module SpiderGazelle
             end
 
             PROTOCOLS = ['h2', 'http/1.1'].freeze
-            FALLBACK = 'http/1.1'
             def self.configure_tls(opts)
                 return false unless opts[:tls]
 
                 tls = {
                     protocols: PROTOCOLS,
-                    fallback: FALLBACK
+                    fallback: 'http/1.1'
                 }
                 tls[:verify_peer] = true if opts[:verify_peer]
                 tls[:ciphers] = opts[:ciphers] if opts[:ciphers]

data/lib/spider-gazelle/gazelle/http1.rb

@@ -31,11 +31,6 @@ module SpiderGazelle
                     req.header.frozen? ? req.header = header : req.header << header
                 end
 
-                DASH       = '-'
-                UNDERSCORE = '_'
-                HTTP_META  = 'HTTP_'
-                COMMA      = ', '
-
                 def on_header_value(parser, value)
                     req = @connection.parsing
                     if req.header.frozen?
@@ -43,11 +38,11 @@ module SpiderGazelle
                     else
                         header = req.header
                         header.upcase!
-                        header.gsub!(DASH, UNDERSCORE)
-                        header.prepend(HTTP_META)
+                        header.gsub!('-', '_')
+                        header.prepend('HTTP_')
                         header.freeze
                         if req.env[header]
-                            req.env[header] << COMMA
+                            req.env[header] << ', '
                             req.env[header] << value
                         else
                             req.env[header] = String.new(value)
@@ -99,16 +94,13 @@ module SpiderGazelle
             def self.on_progress(data, socket); end
             DUMMY_PROGRESS = self.method :on_progress
 
-            HTTP = 'http'
-            HTTPS = 'https'
-
             def load(socket, port, app, tls)
                 @socket = socket
                 @port = port
                 @app = app
 
                 @remote_ip = socket.peername[0]
-                @scheme = tls ? HTTPS : HTTP
+                @scheme = tls ? 'https' : 'http'
 
                 set_on_close(socket)
             end
@@ -161,12 +153,10 @@ module SpiderGazelle
                 @parsing = Request.new @thread, @app, @port, @remote_ip, @scheme, @socket
             end
 
-            REQUEST_METHOD = 'REQUEST_METHOD'
             def headers_complete
-                @parsing.env[REQUEST_METHOD] = @state.http_method.to_s
+                @parsing.env['REQUEST_METHOD'] = @state.http_method.to_s
             end
 
-            ASYNC = "async.callback"
             def finished_parsing
                 request = @parsing
                 @parsing = nil
@@ -180,7 +170,7 @@ module SpiderGazelle
                 # Process the async request in the same way as Mizuno
                 # See: http://polycrystal.org/2012/04/15/asynchronous_responses_in_rack.html
                 # Process a response that was marked as async.
-                request.env[ASYNC] = proc { |data|
+                request.env['async.callback'] = proc { |data|
                     @thread.schedule { request.defer.resolve([request, data]) }
                 }
                 request.upgrade = @state.upgrade?
@@ -235,16 +225,6 @@ module SpiderGazelle
                 process_next
             end
 
-
-            HEAD = 'HEAD'
-            ETAG = 'ETag'
-            HTTP_ETAG = 'HTTP_ETAG'
-            CONTENT_LENGTH2 = 'Content-Length'
-            TRANSFER_ENCODING = 'Transfer-Encoding'
-            CHUNKED = 'chunked'
-            ZERO = '0'
-            NOT_MODIFIED_304 = "HTTP/1.1 304 Not Modified\r\n"
-
             def send_next_response
                 request, result = @responses.shift
                 @transmitting = request
@@ -262,7 +242,7 @@ module SpiderGazelle
                     body.close if body.respond_to?(:close)
                 else
                     status, headers, body = result
-                    send_body = request.env[REQUEST_METHOD] != HEAD
+                    send_body = request.env['REQUEST_METHOD'] != 'HEAD'
 
                     # If a file, stream the body in a non-blocking fashion
                     if body.respond_to? :to_path
@@ -280,17 +260,17 @@ module SpiderGazelle
                                 #if etag == request.env[HTTP_ETAG]
                                 #    header = NOT_MODIFIED_304.dup
                                 #    add_header(header, ETAG, etag)
-                                #    header << LINE_END
+                                #    header << "\r\n"
                                 #    @socket.write header
                                 #    return
                                 #end
                                 #headers[ETAG] ||= etag
 
-                                if headers[CONTENT_LENGTH2]
+                                if headers['Content-Length']
                                     type = :raw
                                 else
                                     type = :http
-                                    headers[TRANSFER_ENCODING] = CHUNKED
+                                    headers['Transfer-Encoding'] = 'chunked'
                                 end
 
                                 data_written = true
@@ -339,7 +319,7 @@ module SpiderGazelle
                         # Optimize the response
                         begin
                             if body.size < 2
-                                headers[CONTENT_LENGTH2] = body.size == 1 ? body[0].bytesize.to_s : ZERO
+                                headers['Content-Length'] = body.size == 1 ? body[0].bytesize.to_s : '0'
                             end
                         rescue # just in case
                         end
@@ -359,59 +339,51 @@ module SpiderGazelle
                 end
             end
 
-            CLOSE_CHUNKED = "0\r\n\r\n"
             def write_response(request, status, headers, body)
                 keep_alive = request.keep_alive
 
-                if headers[CONTENT_LENGTH2]
-                    headers[CONTENT_LENGTH2] = headers[CONTENT_LENGTH2].to_s
+                if headers['Content-Length']
+                    headers['Content-Length'] = headers['Content-Length'].to_s
                     write_headers keep_alive, status, headers
 
                     # Stream the response (pass directly into @socket.write)
                     body.each &@socket.method(:write)
                     @socket.shutdown if keep_alive == false
                 else
-                    headers[TRANSFER_ENCODING] = CHUNKED
+                    headers['Transfer-Encoding'] = 'chunked'
                     write_headers keep_alive, status, headers
 
                     # Stream the response
                     body.each &@write_chunk
 
-                    @socket.write CLOSE_CHUNKED
+                    @socket.write "0\r\n\r\n"
                     @socket.shutdown if keep_alive == false
                 end
 
                 body.close if body.respond_to?(:close)
             end
 
-            COLON_SPACE = ': '
-            LINE_END = "\r\n"
             def add_header(header, key, value)
                 header << key
-                header << COLON_SPACE
+                header << ': '
                 header << value
-                header << LINE_END
+                header << "\r\n"
             end
 
-            CONNECTION = "Connection"
-            NEWLINE = "\n"
-            CLOSE = "close"
-            RACK = "rack"
             def write_headers(keep_alive, status, headers)
-                headers[CONNECTION] = CLOSE if keep_alive == false
+                headers['Connection'] = 'close' if keep_alive == false
 
                 header = String.new("HTTP/1.1 #{status} #{fetch_code(status)}\r\n")
                 headers.each do |key, value|
-                    next if key.start_with? RACK
-                    value.to_s.split(NEWLINE).each {|val| add_header(header, key, val)}
+                    next if key.start_with? 'rack'
+                    value.to_s.split("\n").each {|val| add_header(header, key, val)}
                 end
-                header << LINE_END
+                header << "\r\n"
                 @socket.write header
             end
 
-            HEX_ENCODED = 16
             def write_chunk(part)
-                chunk = part.bytesize.to_s(HEX_ENCODED) << LINE_END << part << LINE_END
+                chunk = part.bytesize.to_s(16) << "\r\n" << part << "\r\n"
                 @socket.write chunk
             end
 
@@ -446,19 +418,17 @@ module SpiderGazelle
                 end
             end
 
-            ERROR_400_RESPONSE = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
             def send_parsing_error
                 @logger.info "Parsing error!"
                 @socket.stop_read
-                @socket.write ERROR_400_RESPONSE
+                @socket.write "HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
                 @socket.shutdown
             end
 
-            ERROR_500_RESPONSE = "HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
             def send_internal_error
                 @logger.info "Internal error"
                 @socket.stop_read
-                @socket.write ERROR_500_RESPONSE
+                @socket.write "HTTP/1.1 500 Internal Server Error\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
                 @socket.shutdown
             end
         end

data/lib/spider-gazelle/gazelle/request.rb

@@ -5,46 +5,26 @@ require 'rack'            # Ruby webserver abstraction
 
 module SpiderGazelle
     class Request < ::Libuv::Q::DeferredPromise
-        RACK_VERSION = 'rack.version'
-        RACK_ERRORS = 'rack.errors'
-        RACK_MULTITHREAD = "rack.multithread"
-        RACK_MULTIPROCESS = "rack.multiprocess"
-        RACK_RUN_ONCE = "rack.run_once"
-        SCRIPT_NAME = "SCRIPT_NAME"
-        EMPTY = ''
-        SERVER_PROTOCOL = "SERVER_PROTOCOL"
-        HTTP_11 = "HTTP/1.1"
-        SERVER_SOFTWARE = "SERVER_SOFTWARE"
-        GATEWAY_INTERFACE = "GATEWAY_INTERFACE"
-        CGI_VER = "CGI/1.2"
-        SERVER = "SpiderGazelle"
-        LOCALHOST = 'localhost'
-
 
         # 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 => true,        # 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
+            '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'] || '',   #  The virtual path of the app base (empty if root)
+            'SERVER_PROTOCOL' => 'HTTP/1.1',
+
+            'GATEWAY_INTERFACE' => 'CGI/1.2',
+            'SERVER_SOFTWARE'   => 'SpiderGazelle'
         }
 
         attr_accessor :env, :url, :header, :body, :keep_alive, :upgrade
         attr_reader :hijacked, :defer, :is_async
 
 
-        SERVER_PORT = "SERVER_PORT"
-        REMOTE_ADDR = "REMOTE_ADDR"
-        RACK_URL_SCHEME = "rack.url_scheme"
-
         def initialize(thread, app, port, remote_ip, scheme, socket)
             super(thread, thread.defer)
 
@@ -54,81 +34,53 @@ module SpiderGazelle
             @header = String.new
             @url = String.new
             @env = PROTO_ENV.dup
-            @env[SERVER_PORT] = port
-            @env[REMOTE_ADDR] = remote_ip
-            @env[RACK_URL_SCHEME] = scheme
+            @env['SERVER_PORT'] = port
+            @env['REMOTE_ADDR'] = remote_ip
+            @env['rack.url_scheme'] = scheme
         end
-
-
-        CONTENT_LENGTH = "CONTENT_LENGTH"
-        HTTP_CONTENT_LENGTH = "HTTP_CONTENT_LENGTH"
-        CONTENT_TYPE = "CONTENT_TYPE"
-        HTTP_CONTENT_TYPE = "HTTP_CONTENT_TYPE"
-        DEFAULT_TYPE = "text/plain"
-        REQUEST_URI= "REQUEST_URI"
-        ASCII_8BIT = "ASCII-8BIT"
-        RACK_INPUT = "rack.input"
-        PATH_INFO = "PATH_INFO"
-        REQUEST_PATH = "REQUEST_PATH"
-        QUERY_STRING = "QUERY_STRING"
-        HTTP_HOST = "HTTP_HOST"
-        COLON = ":"
-        SERVER_NAME = "SERVER_NAME"
-        # Hijacking IO is supported
-        HIJACK_P = "rack.hijack?"
-        # Callback for indicating that this socket will be hijacked
-        HIJACK = "rack.hijack"
-        # The object for performing IO on after hijack is called
-        HIJACK_IO = "rack.hijack_io"
-        QUESTION_MARK = "?"
         
-        HTTP_UPGRADE = 'HTTP_UPGRADE'
-        USE_HTTP2 = 'h2c'
-
-
-
 
         def execute!
-            @env[CONTENT_LENGTH] = @env.delete(HTTP_CONTENT_LENGTH) || @body.bytesize.to_s
-            @env[CONTENT_TYPE] = @env.delete(HTTP_CONTENT_TYPE) || DEFAULT_TYPE
-            @env[REQUEST_URI] = @url.freeze
+            @env['CONTENT_LENGTH'] = @env.delete('HTTP_CONTENT_LENGTH') || @body.bytesize.to_s
+            @env['CONTENT_TYPE'] = @env.delete('HTTP_CONTENT_TYPE') || 'text/plain'
+            @env['REQUEST_URI'] = @url.freeze
 
             # For Rack::Lint on 1.9, ensure that the encoding is always for spec
-            @body.force_encoding(ASCII_8BIT)
-            @env[RACK_INPUT] = StringIO.new @body
+            @body.force_encoding(Encoding::ASCII_8BIT)
+            @env['rack.input'] = StringIO.new @body
 
             # Break the request into its components
-            query_start  = @url.index QUESTION_MARK
+            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
+                @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] = EMPTY
+                @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(COLON)
-                    @env[SERVER_NAME] = host[0, colon]
-                    @env[SERVER_PORT] = host[colon + 1, host.bytesize]
+            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_NAME'] = host
                 end
             else
-                @env[SERVER_NAME] = LOCALHOST
+                @env['SERVER_NAME'] = 'localhost'
             end
 
-            if @upgrade == true && @env[HTTP_UPGRADE] == USE_HTTP2
+            if @upgrade == true && @env['HTTP_UPGRADE'] == 'h2c'
                 # TODO:: implement the upgrade process here
             end
 
             # Provide hijack options
-            @env[HIJACK_P] = true
-            @env[HIJACK] = proc { @env[HIJACK_IO] = @socket }
+            @env['rack.hijack?'] = true
+            @env['rack.hijack'] = proc { @env['rack.hijack_io'] = @socket }
 
             # Execute the request
             # NOTE:: Catch was overloaded by Promise so this does the trick now

data/lib/spider-gazelle/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module SpiderGazelle
-    VERSION = '3.0.2'
+    VERSION = '3.0.3'
     EXEC_NAME = 'sg'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spider-gazelle
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-14 00:00:00.000000000 Z
+date: 2016-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-parser