uv-rays 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e0ed8546ca888cff20ded4605bd07311bcce602
-  data.tar.gz: 9752390a4161b472d39fb9a3d5d34abb72ff690d
+  metadata.gz: bbe9019bb0b5b548daf337f12f4f6d6eed42d3d6
+  data.tar.gz: 1b5779c34179033260c79ec5afeb088c470a8180
 SHA512:
-  metadata.gz: b03214fac41e0522af1674774306d7c2ae705f62a376ec6175b49927ae29887d29dfdd33f5b128aa4b09bc3422a5fcca8e195172130583bb7597001a99501fe1
-  data.tar.gz: 1fb5c2a2cd90ecbb2856826e8d3bdcf1c2ff87621d50f393176a4dd06d6f7f33680a5082550f70b68513a266839138f4b06b55f8d331189fb5450be550037700
+  metadata.gz: 7e14c928bf63dbd3ebfd230dbf2dfcff281328e7e6376d551838ba0f3a3fd7c8d5891e8ab5b54ca913267b5053f26cbe53b31062b0cfc7ec40acf556fd9384e2
+  data.tar.gz: e3aad461e23c4e60a52fbea8114a8e54b7fcb94f327f08ca6db810f5c8a41e3aa9a607bfb4185f7136f2bbd78dda3a6cfdd7216db04651ff2790f957f1035e42

data/lib/uv-rays.rb

@@ -24,7 +24,7 @@ require 'http-parser'       # Parses HTTP request / responses
 require 'addressable/uri'   # URI parser
 require 'uv-rays/http/encoding'
 require 'uv-rays/http/request'
-require 'uv-rays/http/response'
+require 'uv-rays/http/parser'
 require 'uv-rays/http_endpoint'
 
 

data/lib/uv-rays/http/{response.rb → parser.rb}

@@ -11,35 +11,42 @@ module UV
             attr_accessor :cookies
 
             attr_accessor :keep_alive
+
+            attr_accessor :body
+
+            def to_s
+                "HTTP#{http_version} #{status} - keep alive: #{keep_alive}\nheaders: #{super}\nbody: #{body}"
+            end
+
+            alias_method :inspect, :to_s
         end
 
-        class Response
+        class Parser
             def initialize
                 @parser = ::HttpParser::Parser.new(self)
                 @state = ::HttpParser::Parser.new_instance
                 @state.type = :response
+                @headers = nil
             end
 
 
-            attr_accessor :request
+            attr_reader :request
 
 
-            # Called on connection disconnect
-            def reset!
+            def new_request(request)
+                @headers = nil
+                @request = request
+                @headers_complete = false
                 @state.reset!
             end
 
-            # Socket level data is forwarded as it arrives
-            def receive(data)
-                # Returns true if error
+            def received(data)
                 if @parser.parse(@state, data)
                     if @request
                         @request.reject(@state.error)
                         @request = nil
+                        @response = nil
                         return true
-                    #else # silently fail here
-                    #    p 'parse error and no request..'
-                    #    p @state.error
                     end
                 end
 
@@ -52,6 +59,7 @@ module UV
                 @headers = Headers.new
                 @body = ''
                 @chunked = false
+                @close_connection = false
             end
 
             def on_status(parser, data)
@@ -86,50 +94,66 @@ module UV
             end
 
             def on_headers_complete(parser)
-                headers = @headers
-                @headers = nil
-                @header = nil
+                @headers_complete = true
 
                 # https://github.com/joyent/http-parser indicates we should extract
                 # this information here
-                headers.http_version = @state.http_version
-                headers.status = @state.http_status
-                headers.cookies = @request.cookies_hash
-                headers.keep_alive = !@close_connection
+                @headers.http_version = @state.http_version
+                @headers.status = @state.http_status
+                @headers.cookies = @request.cookies_hash
+                @headers.keep_alive = !@close_connection
 
                 # User code may throw an error
                 # Errors will halt the processing and return a PAUSED error
-                @request.set_headers(headers)
+                @request.set_headers(@headers)
             end
 
             def on_body(parser, data)
-                @body << data
-                # TODO:: What if it is a chunked response body?
-                # We should buffer complete chunks
-                @request.notify(data)
+                if @request.streaming?
+                    @request.notify(data)
+                else
+                    @body << data
+                end
             end
 
             def on_message_complete(parser)
-                req = @request
-                bod = @body
-
-                # Clean up memory
-                @request = nil
-                @body = nil
+                @headers.body = @body
 
-                req.resolve(self, bod)
+                if @request.resolve(@headers)
+                    cleanup
+                else
+                    req = @request
+                    cleanup
+                    new_request(req)
+                end
             end
 
             # We need to flush the response on disconnect if content-length is undefined
             # As per the HTTP spec
+            attr_accessor :reason
             def eof
-                if @headers.nil? && @request.headers && @request.headers[:'Content-Length'].nil?
+                return if @request.nil?
+
+                if @headers_complete && @headers[:'Content-Length'].nil?
                     on_message_complete(nil)
                 else
                     # Reject if this is a partial response
-                    @request.reject(:partial_response)
+                    @request.reject(@reason || :partial_response)
+                    cleanup
                 end
             end
+
+
+            private
+
+
+            def cleanup
+                @request = nil
+                @body = nil
+                @headers = nil
+                @reason = nil
+                @headers_complete = false
+            end
         end
     end
 end

data/lib/uv-rays/http/request.rb

@@ -1,3 +1,5 @@
+require 'rubyntlm'
+
 module UV
     module Http
         class Request < ::Libuv::Q::DeferredPromise
@@ -9,9 +11,7 @@ module UV
             CRLF="\r\n"
 
 
-            attr_reader :path
-            attr_reader :method
-            attr_reader :headers, :options
+            attr_reader :path, :method, :options
 
 
             def cookies_hash
@@ -23,35 +23,33 @@ module UV
             end
             
 
-            def initialize(endpoint, options, using_ntlm)
-                super(endpoint.loop, endpoint.loop.defer)
+            def initialize(endpoint, options)
+                super(endpoint.thread, endpoint.thread.defer)
 
                 @options = options
                 @endpoint = endpoint
-                @ntlm_retries = using_ntlm ? 0 : nil
+                @ntlm_creds = options[:ntlm]
 
                 @path = options[:path]
                 @method = options[:method]
                 @uri = "#{endpoint.scheme}#{encode_host(endpoint.host, endpoint.port)}#{@path}"
+
+                @error = proc { |reason| reject(reason) }
             end
 
-            def resolve(response, body)
-                if @ntlm_retries == 0 && @headers.status == 401 && @headers[:"WWW-Authenticate"]
-                    @options[:headers][:Authorization] = @endpoint.ntlm_auth_header(@headers[:"WWW-Authenticate"])
+
+
+            def resolve(response, parser = nil)
+                if response.status == 401 && @ntlm_creds && @ntlm_retries == 0 && response[:"WWW-Authenticate"]
+                    @options[:headers][:Authorization] = ntlm_auth_header(response[:"WWW-Authenticate"])
                     @ntlm_retries += 1
 
-                    response.request = self
-                    execute(*@exec_params)
+                    execute(@transport)
+                    false
                 else
-                    if @ntlm_retries == 1
-                        @endpoint.clear_ntlm_header
-                    end
-
-                    @exec_params = nil
-                    @defer.resolve({
-                        headers: @headers,
-                        body: body
-                    })
+                    @transport = nil
+                    @defer.resolve(response)
+                    true
                 end
             end
 
@@ -59,9 +57,15 @@ module UV
                 @defer.reject(reason)
             end
 
-            def execute(transport, error)
+            def execute(transport)
+                # configure ntlm request headers
+                if @options[:ntlm]
+                    @options[:headers] ||= {}
+                    @options[:headers][:Authorization] ||= ntlm_auth_header
+                end
+
                 head, body = build_request, @options[:body]
-                @exec_params = [transport, error]
+                @transport = transport
 
                 @endpoint.middleware.each do |m|
                     head, body = m.request(self, head, body) if m.respond_to?(:request)
@@ -94,23 +98,23 @@ module UV
 
                 if body
                     request_header << body
-                    transport.write(request_header).catch error
+                    transport.write(request_header).catch @error
                 elsif file
-                    transport.write(request_header).catch error
+                    transport.write(request_header).catch @error
 
                     # Send file
                     fileRef = @endpoint.loop.file file, File::RDONLY
                     fileRef.progress do
                         # File is open and available for reading
                         pSend = fileRef.send_file(transport, :raw)
-                        pSend.catch error
+                        pSend.catch @error
                         pSend.finally do
                             fileRef.close
                         end
                     end
-                    fileRef.catch error
+                    fileRef.catch @error
                 else
-                    transport.write(request_header).catch error
+                    transport.write(request_header).catch @error
                 end
             end
 
@@ -119,19 +123,17 @@ module UV
             end
 
             def set_headers(head)
-                @headers = head
-                if not @headers_callback.nil?
-                    @headers_callback.call(@headers)
-                end
+                @headers_callback.call(head) if @headers_callback
             end
 
+
+
             def on_headers(callback, &blk)
-                callback ||= blk
-                if @headers.nil?
-                    @headers_callback = callback
-                else
-                    callback.call(@headers)
-                end
+                @headers_callback = callback
+            end
+
+            def streaming?
+                @options[:streaming]
             end
 
 
@@ -173,6 +175,36 @@ module UV
 
                 head
             end
+
+            def ntlm_auth_header(challenge = nil)
+                if @ntlm_auth && challenge.nil?
+                    return @ntlm_auth
+                elsif challenge
+                    scheme, param_str = parse_ntlm_challenge_header(challenge)
+                    if param_str.nil?
+                        @ntlm_auth = nil
+                        return ntlm_auth_header(@ntlm_creds)
+                    else
+                        t2 = Net::NTLM::Message.decode64(param_str)
+                        t3 = t2.response(@ntlm_creds, ntlmv2: true)
+                        @ntlm_auth = "NTLM #{t3.encode64}"
+                        return @ntlm_auth
+                    end
+                else
+                    @ntlm_retries = 0
+                    domain = @ntlm_creds[:domain]
+                    t1 = Net::NTLM::Message::Type1.new()
+                    t1.domain = domain if domain
+                    @ntlm_auth = "NTLM #{t1.encode64}"
+                    return @ntlm_auth
+                end
+            end
+
+            def parse_ntlm_challenge_header(challenge)
+                scheme, param_str = challenge.scan(/\A(\S+)(?:\s+(.*))?\z/)[0]
+                return nil if scheme.nil?
+                return scheme, param_str
+            end
         end
     end
 end

data/lib/uv-rays/http_endpoint.rb

@@ -1,5 +1,4 @@
-require 'rubyntlm'
-
+require 'uri'
 
 module UV
     class CookieJar
@@ -28,69 +27,81 @@ module UV
         end
     end # CookieJar
 
+    class HttpEndpoint
+        class Connection < OutboundConnection
+            def initialize(host, port, tls, client)
+                @client = client
+                @request = nil
+                super(host, port)
+                use_tls(client.tls_options) if tls
+            end
 
-    class HttpEndpoint < OutboundConnection
-        TRANSFER_ENCODING="TRANSFER_ENCODING".freeze
-        CONTENT_ENCODING="CONTENT_ENCODING".freeze
-        CONTENT_LENGTH="CONTENT_LENGTH".freeze
-        CONTENT_TYPE="CONTENT_TYPE".freeze
-        LAST_MODIFIED="LAST_MODIFIED".freeze
-        KEEP_ALIVE="CONNECTION".freeze
-        LOCATION="LOCATION".freeze
-        HOST="HOST".freeze
-        ETAG="ETAG".freeze
-        CRLF="\r\n".freeze
-        HTTPS="https://".freeze
-        HTTP="http://".freeze
+            attr_accessor :request
 
+            def on_read(data, *args) # user to define
+                @client.data_received(data)
+            end
 
-        @@defaults = {
-            :path => '/',
-            :keepalive => true
-        }
+            def post_init(*args)
+            end
 
-        attr_reader :scheme, :host, :port, :using_tls, :loop, :cookiejar
-        attr_reader :inactivity_timeout
+            def on_connect(transport) # user to define
+                @client.connection_ready
+            end
 
-        def initialize(uri, options = {})
-            @inactivity_timeout  = options[:inactivity_timeout] ||= 10000   # default connection inactivity (post-setup) timeout
-            @ntlm_creds = options[:ntlm]
+            def on_close # user to define
+                req = @request
+                @request = nil
+                @client.connection_closed(req)
+            end
 
-            uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
-            @https = uri.scheme == "https"
-            uri.port ||= (@https ? 443 : 80)
-            @scheme = @https ? HTTPS : HTTP
+            def close_connection(request = nil)
+                if request.is_a? Http::Request
+                    @request = request
+                    super(:after_writing)
+                else
+                    super(request)
+                end
+            end
+        end
 
 
-            @loop = Libuv::Loop.current || Libuv::Loop.default
-            @host = uri.host
-            @port = uri.port
-            #@transport = @loop.tcp
+        @@defaults = {
+            :path => '/',
+            :keepalive => true
+        }
 
-            # State flags
-            @closed = true
-            @closing = false
-            @connecting = false
 
-            # Current requests
-            @pending_requests = []
-            @staging_request = nil
-            @waiting_response = nil
-            @cookiejar = CookieJar.new
+        def initialize(host, options = {})
+            @queue = []
+            @parser = Http::Parser.new
+            @thread = Libuv::Loop.current || Libuv::Loop.default
+            @connection = nil
 
-            # Callback methods
+            @options = @@defaults.merge(options)
+            @tls_options = options[:tls_options] || {}
+            @inactivity_timeout = options[:inactivity_timeout] || 10000
             @idle_timeout_method = method(:idle_timeout)
 
-            # Manages the tokenising of response from the input stream
-            @response = Http::Response.new
-
-            # Timeout timer
             if @inactivity_timeout > 0
-                @timer = @loop.timer
+                @timer = @thread.timer
             end
+
+            uri = URI.parse host
+            @port = uri.port
+            @host = uri.host
+            @scheme = uri.scheme
+            @tls = @scheme == 'https'
+            @cookiejar = CookieJar.new
+            @middleware = []
         end
 
 
+        attr_reader :inactivity_timeout, :thread
+        attr_reader :tls_options, :port, :host, :tls, :scheme
+        attr_reader :cookiejar, :middleware
+
+
         def get      options = {}, &blk;  request(:get,     options, &blk); end
         def head     options = {}, &blk;  request(:head,    options, &blk); end
         def delete   options = {}, &blk;  request(:delete,  options, &blk); end
@@ -101,205 +112,124 @@ module UV
 
 
         def request(method, options = {}, &blk)
-            options = @@defaults.merge(options)
+            options = @options.merge(options)
             options[:method] = method
 
             # Setup the request with callbacks
-            request = Http::Request.new(self, options, @ntlm_creds)
-            request.then(proc { |result|
-                @waiting_response = nil
-
-                if @closed || result[:headers].keep_alive
-                    next_request
+            request = Http::Request.new(self, options)
+            request.then(proc { |response|
+                if response.keep_alive
+                    restart_timer
                 else
-                    @closing = true
-                    @transport.close
+
+                    close_connection
                 end
 
-                result
-            }, proc { |err|
-                @waiting_response = nil
                 next_request
 
-                ::Libuv::Q.reject(@loop, err)
+                response
+            }, proc { |err|
+                close_connection
+                next_request
+                ::Libuv::Q.reject(@thread, err)
             })
 
-            ##
-            # TODO:: Add response middleware here
-            request.then blk if blk
-
-            # Add to pending requests and schedule using the breakpoint
-            @pending_requests << request
-            if !@waiting_response && !@staging_request
+            @queue.unshift(request)
+            if @queue.length == 1 && @parser.request.nil?
                 next_request
             end
 
-            # return the request
             request
         end
 
-
-        def next_request
-            @staging_request = @pending_requests.shift
-            process_request unless @staging_request.nil?
-        end
-
-        def process_request
-            if @closed && !@connecting
-                @transport = @loop.tcp
-
-                @connecting = @staging_request
-                ::UV.try_connect(@transport, self, @host, @port)
-            elsif !@closing
-                try_send
+        # Callbacks
+        def connection_ready
+            if @queue.length > 0
+                restart_timer
+                next_request
+            else
+                close_connection
             end
         end
 
+        def connection_closed(request)
+            # We may have closed a previous connection
+            if request.nil? || request == @parser.request
+                @connection = nil
+                stop_timer
 
-        def on_connect(transport)
-            @connecting = false
-            @closed = false
-
-            # start tls if connection is encrypted
-            use_tls() if @https
-
-            # Update timeouts
-            stop_timer
-            if @inactivity_timeout > 0
-                @timer.progress @idle_timeout_method
-                @timer.start @inactivity_timeout
+                @parser.eof
             end
-
-            # Kick off pending requests
-            @response.reset!
-            try_send  # we only connect if there is a request waiting
         end
 
-
-        def on_close
-            @closed = true
-            @ntlm_auth = nil
-            clear_staging = @connecting == @staging_request
-            @connecting = false
-            stop_timer
-
-            # On close may be called before on data
-            @loop.next_tick do
-                if @closing
-                    @closing = false
-                    @connecting = false
-
-                    if @staging_request
-                        process_request
-                    else
-                        next_request
-                    end
-                else
-                    if clear_staging
-                        @staging_request.reject(:connection_refused)
-                    elsif @waiting_response
-                        # Flush any processing request
-                        @response.eof if @response.request
-
-                        # Reject any requests waiting on a response
-                        @waiting_response.reject(:disconnected)
-                    elsif @staging_request
-                        # Try reconnect
-                        process_request
-                    end
-                end
-            end
+        def data_received(data)
+            restart_timer
+            close_connection if @parser.received(data)
         end
 
-        def try_send
-            @waiting_response = @staging_request
-            @response.request = @staging_request
-            @staging_request = nil
-
-            if @ntlm_creds
-                opts = @waiting_response.options
-                opts[:headers] ||= {}
-                opts = opts[:headers]
-                opts[:Authorization] = ntlm_auth_header
+        def cancel_all
+            @queue.each do |request|
+                request.reject(:cancelled)
             end
-
-            @timer.again if @inactivity_timeout > 0
-            @waiting_response.execute(@transport, proc { |err|
-                @transport.close
-                @waiting_response.reject(err)
-            })
+            if @parser.request
+                @parser.request.reject(:cancelled)
+                @parser.eof
+            end
+            @queue = []
+            close_connection
         end
 
 
-        def middleware
-            # TODO:: allow for middle ware
-            []
-        end
+        private
 
-        def on_read(data, *args)
-            @timer.again if @inactivity_timeout > 0
 
-            # returns true on error
-            # Response rejects the request
-            if @response.receive(data)
-                @transport.close
-            end
-        end
+        def next_request
+            return if @parser.request || @queue.length == 0
 
-        def close_connection(after_writing = false)
-            stop_timer
-            reqs = @pending_requests
-            @pending_requests.clear
-            reqs.each do |request|
-                request.reject(:close_connection)
-            end
-            super(after_writing) if @transport
-        end
+            if @connection
+                req = @queue.pop
+                @connection.request = req
+                @parser.new_request(req)
 
-        def ntlm_auth_header(challenge = nil)
-            if @ntlm_auth && challenge.nil?
-                return @ntlm_auth
-            elsif challenge
-                scheme, param_str = parse_ntlm_challenge_header(challenge)
-                if param_str.nil?
-                    @ntlm_auth = nil
-                    return ntlm_auth_header(@ntlm_creds)
-                else
-                    t2 = Net::NTLM::Message.decode64(param_str)
-                    t3 = t2.response(@ntlm_creds, ntlmv2: true)
-                    @ntlm_auth = "NTLM #{t3.encode64}"
-                    return @ntlm_auth
-                end
+                req.execute(@connection)
             else
-                domain = @ntlm_creds[:domain]
-                t1 = Net::NTLM::Message::Type1.new()
-                t1.domain = domain if domain
-                @ntlm_auth = "NTLM #{t1.encode64}"
-                return @ntlm_auth
+                new_connection
             end
         end
 
-        def clear_ntlm_header
-            @ntlm_auth = nil
+        def new_connection
+            if @queue.length > 0 && @connection.nil?
+                @connection = Connection.new(@host, @port, @tls, self)
+                start_timer
+            end
+            @connection
         end
 
+        def close_connection
+            return if @connection.nil?
+            @connection.close_connection(@parser.request)
+            stop_timer
+            @connection = nil
+        end
 
-        protected
 
+        def start_timer
+            return if @timer.nil?
+            @timer.progress @idle_timeout_method
+            @timer.start @inactivity_timeout
+        end
 
-        def idle_timeout
-            @timer.stop
-            @transport.close
+        def restart_timer
+            @timer.again unless @timer.nil?
         end
 
         def stop_timer
             @timer.stop unless @timer.nil?
         end
 
-        def parse_ntlm_challenge_header(challenge)
-            scheme, param_str = challenge.scan(/\A(\S+)(?:\s+(.*))?\z/)[0]
-            return nil if scheme.nil?
-            return scheme, param_str
+        def idle_timeout
+            @parser.reason = :timeout
+            close_connection
         end
     end
 end

data/lib/uv-rays/version.rb

@@ -1,3 +1,3 @@
 module UV
-    VERSION = '1.2.3'
+    VERSION = '1.3.0'
 end

data/spec/http_endpoint_spec.rb

@@ -66,6 +66,81 @@ module OldServer
 	end
 end
 
+module WeirdServer
+	def post_init
+		@parser = ::HttpParser::Parser.new(self)
+        @state = ::HttpParser::Parser.new_instance
+        @state.type = :request
+	end
+
+	def on_message_complete(parser)
+		write("HTTP/1.1 200 OK\r\nContent-type: text/html\r\n\r\nnolength")
+		close_connection(:after_writing)
+	end
+
+	def on_read(data, connection)
+		if @parser.parse(@state, data)
+            p 'parse error'
+            p @state.error
+        end
+	end
+end
+
+module BrokenServer
+	@@req = 0
+
+	def post_init
+		@parser = ::HttpParser::Parser.new(self)
+        @state = ::HttpParser::Parser.new_instance
+        @state.type = :request
+	end
+
+	def on_message_complete(parser)
+		if @@req == 0
+			@state = ::HttpParser::Parser.new_instance
+			write("HTTP/1.1 401 Unauthorized\r\nContent-type: text/ht")
+			close_connection(:after_writing)
+		else
+			write("HTTP/1.1 200 OK\r\nContent-type: text/html\r\nContent-length: 3\r\n\r\nyes")
+		end
+		@@req += 1
+	end
+
+	def on_read(data, connection)
+		if @parser.parse(@state, data)
+            p 'parse error'
+            p @state.error
+        end
+	end
+end
+
+module SlowServer
+	@@req = 0
+
+	def post_init
+		@parser = ::HttpParser::Parser.new(self)
+        @state = ::HttpParser::Parser.new_instance
+        @state.type = :request
+	end
+
+	def on_message_complete(parser)
+		if @@req == 0
+			@state = ::HttpParser::Parser.new_instance
+			write("HTTP/1.1 200 OK\r\nContent-")
+		else
+			write("HTTP/1.1 200 OK\r\nContent-type: text/html\r\nContent-length: 3\r\n\r\nokg")
+		end
+		@@req += 1
+	end
+
+	def on_read(data, connection)
+		if @parser.parse(@state, data)
+            p 'parse error'
+            p @state.error
+        end
+	end
+end
+
 
 describe UV::HttpEndpoint do
 	before :each do
@@ -106,13 +181,45 @@ describe UV::HttpEndpoint do
 			}
 
 			expect(@general_failure).to eq([])
-			expect(@response[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response[:headers].http_version).to eq('1.1')
-			expect(@response[:headers].status).to eq(200)
-			expect(@response[:headers].cookies).to eq({})
-			expect(@response[:headers].keep_alive).to eq(true)
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.1')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(true)
 
-			expect(@response[:body]).to eq('y')
+			expect(@response.body).to eq('y')
+		end
+
+		it "should return the response when no length is given and the connection is closed" do
+			# I've seen IoT devices do this (projector screen controllers etc)
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 3250, WeirdServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.1')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(true)
+
+			expect(@response.body).to eq('nolength')
 		end
 
 		it "should send multiple requests on the same connection" do
@@ -128,13 +235,13 @@ describe UV::HttpEndpoint do
 				tcp = UV.start_server '127.0.0.1', 3250, HttpServer
 				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
 
-				request = server.get(:path => '/')
+				request = server.get(path: '/', req: 1)
 				request.then(proc { |response|
 					@response = response
 					#@loop.stop
 				}, @request_failure)
 				
-				request2 = server.get(:path => '/')
+				request2 = server.get(path: '/', req: 2)
 				request2.then(proc { |response|
 					@response2 = response
 					tcp.close
@@ -143,17 +250,17 @@ describe UV::HttpEndpoint do
 			}
 
 			expect(@general_failure).to eq([])
-			expect(@response[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response[:headers].http_version).to eq('1.1')
-			expect(@response[:headers].status).to eq(200)
-			expect(@response[:headers].cookies).to eq({})
-			expect(@response[:headers].keep_alive).to eq(true)
-
-			expect(@response2[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response2[:headers].http_version).to eq('1.1')
-			expect(@response2[:headers].status).to eq(200)
-			expect(@response2[:headers].cookies).to eq({})
-			expect(@response2[:headers].keep_alive).to eq(true)
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.1')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(true)
+
+			expect(@response2[:"Content-type"]).to eq('text/html')
+			expect(@response2.http_version).to eq('1.1')
+			expect(@response2.status).to eq(200)
+			expect(@response2.cookies).to eq({})
+			expect(@response2.keep_alive).to eq(true)
 		end
 	end
 
@@ -180,11 +287,11 @@ describe UV::HttpEndpoint do
 			}
 
 			expect(@general_failure).to eq([])
-			expect(@response[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response[:headers].http_version).to eq('1.0')
-			expect(@response[:headers].status).to eq(200)
-			expect(@response[:headers].cookies).to eq({})
-			expect(@response[:headers].keep_alive).to eq(false)
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.0')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(false)
 		end
 
 		it "should send multiple requests" do
@@ -197,8 +304,8 @@ describe UV::HttpEndpoint do
 					end
 				end
 
-				tcp = UV.start_server '127.0.0.1', 3250, OldServer
-				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
+				tcp = UV.start_server '127.0.0.1', 3251, OldServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3251'
 
 				request = server.get(:path => '/')
 				request.then(proc { |response|
@@ -215,17 +322,17 @@ describe UV::HttpEndpoint do
 			}
 
 			expect(@general_failure).to eq([])
-			expect(@response[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response[:headers].http_version).to eq('1.0')
-			expect(@response[:headers].status).to eq(200)
-			expect(@response[:headers].cookies).to eq({})
-			expect(@response[:headers].keep_alive).to eq(false)
-
-			expect(@response2[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response2[:headers].http_version).to eq('1.0')
-			expect(@response2[:headers].status).to eq(200)
-			expect(@response2[:headers].cookies).to eq({})
-			expect(@response2[:headers].keep_alive).to eq(false)
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.0')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(false)
+
+			expect(@response2[:"Content-type"]).to eq('text/html')
+			expect(@response2.http_version).to eq('1.0')
+			expect(@response2.status).to eq(200)
+			expect(@response2.cookies).to eq({})
+			expect(@response2.keep_alive).to eq(false)
 		end
 	end
 
@@ -240,8 +347,8 @@ describe UV::HttpEndpoint do
 					end
 				end
 
-				tcp = UV.start_server '127.0.0.1', 3250, NTLMServer
-				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250', ntlm: {
+				tcp = UV.start_server '127.0.0.1', 3252, NTLMServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:3252', ntlm: {
 					user: 'username',
 					password: 'password',
 					domain: 'domain'
@@ -256,12 +363,98 @@ describe UV::HttpEndpoint do
 			}
 
 			expect(@general_failure).to eq([])
-			expect(@response[:headers][:"Content-type"]).to eq('text/html')
-			expect(@response[:headers].http_version).to eq('1.1')
-			expect(@response[:headers].status).to eq(200)
-			expect(@response[:headers].cookies).to eq({})
-			expect(@response[:headers].keep_alive).to eq(true)
-			expect(@response[:body]).to eq('y')
+			expect(@response[:"Content-type"]).to eq('text/html')
+			expect(@response.http_version).to eq('1.1')
+			expect(@response.status).to eq(200)
+			expect(@response.cookies).to eq({})
+			expect(@response.keep_alive).to eq(true)
+			expect(@response.body).to eq('y')
+		end
+	end
+
+	describe 'when things go wrong' do
+		it "should reconnect after connection dropped and continue sending requests" do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 6353, BrokenServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:6353'
+
+				@response = nil
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, proc { |error|
+					@error = error
+				})
+				
+				request2 = server.get(:path => '/')
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@response).to eq(nil)
+			expect(@error).to eq(:partial_response)
+
+			expect(@response2[:"Content-type"]).to eq('text/html')
+			expect(@response2.http_version).to eq('1.1')
+			expect(@response2.status).to eq(200)
+			expect(@response2.cookies).to eq({})
+			expect(@response2.keep_alive).to eq(true)
+			expect(@response2.body).to eq('yes')
+		end
+
+		it "should reconnect after timeout and continue sending requests" do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				tcp = UV.start_server '127.0.0.1', 6363, SlowServer
+				server = UV::HttpEndpoint.new 'http://127.0.0.1:6363', inactivity_timeout: 500
+
+				@response = nil
+				request = server.get(:path => '/')
+				request.then(proc { |response|
+					@response = response
+					#@loop.stop
+				}, proc { |error|
+					@error = error
+				})
+				
+				request2 = server.get(:path => '/')
+				request2.then(proc { |response|
+					@response2 = response
+					tcp.close
+					@loop.stop
+				}, @request_failure)
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@response).to eq(nil)
+			expect(@error).to eq(:timeout)
+
+			expect(@response2[:"Content-type"]).to eq('text/html')
+			expect(@response2.http_version).to eq('1.1')
+			expect(@response2.status).to eq(200)
+			expect(@response2.cookies).to eq({})
+			expect(@response2.keep_alive).to eq(true)
+			expect(@response2.body).to eq('okg')
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uv-rays
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-19 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libuv
@@ -180,8 +180,8 @@ files:
 - lib/uv-rays/buffered_tokenizer.rb
 - lib/uv-rays/connection.rb
 - lib/uv-rays/http/encoding.rb
+- lib/uv-rays/http/parser.rb
 - lib/uv-rays/http/request.rb
-- lib/uv-rays/http/response.rb
 - lib/uv-rays/http_endpoint.rb
 - lib/uv-rays/scheduler.rb
 - lib/uv-rays/scheduler/cron.rb