uv-rays 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11a2e081253e15248cae96c1f6ddeff70c72898e
-  data.tar.gz: d8eb1fec708fcdc68a2fb2d4a09a08e2a5e77c9b
+  metadata.gz: 558fed8aba820a41ca678d1eff92f5ffcfe7ffda
+  data.tar.gz: 973e700f3dc30174988ed0e43305bedfd1045adc
 SHA512:
-  metadata.gz: 0cb78756f4aa14503eed42df13a0a0cf0b2c1ff69e44ebb6d2104924fdeabb8184937e68b84cb68b85d789ba51bec1088c8e43e40ab22c783f885a23fd0940d7
-  data.tar.gz: e0a26a535f56e79edc480624c41a64d251b6ff92d206d6ded3ce9fdac412886785bbc32dfd1b441547dc94f184e26a9af7303b850c41a843edb61c9abda1a94c
+  metadata.gz: 4b165b0a04fde386e7ec551f1047bf21dd2086c311281f1c243ad39f825cdcd3a99d48ae6ea0ad04b6c4a498ce687c480679ed792a2d7d16f90f1fc062fa9727
+  data.tar.gz: 2bd96402a8f3be5ce823a7f8c893c2fea25060125ba21aafd677fd0aeb55f895ae28c2ec82a7efc1a126eed67ccc55052578981c488897c08351dd867cee825d

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

@@ -45,7 +45,7 @@ module UV
                 @defer.reject(reason)
             end
 
-            def send(transport, error)
+            def execute(transport, error)
                 head, body = build_request, @options[:body]
 
                 @endpoint.middleware.each do |m|

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

@@ -14,16 +14,14 @@ module UV
         end
 
         class Response
-            def initialize(requests)
-                @requests = requests
-
+            def initialize
                 @parser = ::HttpParser::Parser.new(self)
                 @state = ::HttpParser::Parser.new_instance
                 @state.type = :response
             end
 
 
-            attr_reader :request
+            attr_accessor :request
 
 
             # Called on connection disconnect
@@ -51,7 +49,6 @@ module UV
             ##
             # Parser Callbacks:
             def on_message_begin(parser)
-                @request = @requests.shift
                 @headers = Headers.new
                 @body = ''
                 @chunked = false
@@ -123,7 +120,7 @@ module UV
             # We need to flush the response on disconnect if content-length is undefined
             # As per the HTTP spec
             def eof
-                if @headers.nil? && @request.headers[:'Content-Length'].nil?
+                if @headers.nil? && @request.headers && @request.headers[:'Content-Length'].nil?
                     on_message_complete(nil)
                 else
                     # Reject if this is a partial response

data/lib/uv-rays/http_endpoint.rb

@@ -47,10 +47,9 @@ module UV
         }
 
         attr_reader :scheme, :host, :port, :using_tls, :loop, :cookiejar
-        attr_reader :connect_timeout, :inactivity_timeout
+        attr_reader :inactivity_timeout
 
         def initialize(uri, options = {})
-            @connect_timeout     = options[:connect_timeout] ||= 5        # default connection setup timeout
             @inactivity_timeout  = options[:inactivity_timeout] ||= 10   # default connection inactivity (post-setup) timeout
 
 
@@ -66,29 +65,24 @@ module UV
             #@transport = @loop.tcp
 
             # State flags
-            @ready = false
+            @closed = true
+            @closing = false
             @connecting = false
 
             # Current requests
             @pending_requests = []
-            @pending_responses = []
-            @connection_pending = []
+            @staging_request = nil
+            @waiting_response = nil
             @cookiejar = CookieJar.new
 
             # Callback methods
-            @connection_method = method(:get_connection)
-            @next_request_method = method(:next_request)
             @idle_timeout_method = method(:idle_timeout)
-            @connect_timeout_method = method(:connect_timeout)
-
-            # Used to indicate when we can start the next send
-            @breakpoint = ::Libuv::Q::ResolvedPromise.new(@loop, true)
 
             # Manages the tokenising of response from the input stream
-            @response = Http::Response.new(@pending_responses)
+            @response = Http::Response.new
 
             # Timeout timer
-            if @connect_timeout || @inactivity_timeout
+            if @inactivity_timeout > 0
                 @timer = @loop.timer
             end
         end
@@ -109,12 +103,23 @@ module UV
 
             # Setup the request with callbacks
             request = Http::Request.new(self, options)
-            request.then proc { |result|
-                if !result[:headers].keep_alive
+            request.then(proc { |result|
+                @waiting_response = nil
+
+                if @closed || result[:headers].keep_alive
+                    next_request
+                else
+                    @closing = true
                     @transport.close
                 end
+
                 result
-            }
+            }, proc { |err|
+                @waiting_response = nil
+                next_request
+
+                ::Libuv::Q.reject(@loop, err)
+            })
 
             ##
             # TODO:: Add response middleware here
@@ -122,54 +127,35 @@ module UV
 
             # Add to pending requests and schedule using the breakpoint
             @pending_requests << request
-            @breakpoint.finally @next_request_method
-            if options[:pipeline] == true
-                options[:keepalive] = true
-            else
-                @breakpoint = request
+            if !@waiting_response && !@staging_request
+                next_request
             end
 
             # return the request
             request
         end
 
-        def middleware
-            # TODO:: allow for middle ware
-            []
-        end
 
-        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
+        def next_request
+            @staging_request = @pending_requests.shift
+            process_request unless @staging_request.nil?
         end
 
-        def on_close
-            @ready = false
-            @connecting = false
-            stop_timer
-
-            # Flush any processing request
-            @response.eof if @response.request
+        def process_request
+            if @closed && !@connecting
+                @transport = @loop.tcp
 
-            # Reject any requests waiting on a response
-            @pending_responses.each do |request|
-                request.reject(:disconnected)
-            end
-            @pending_responses.clear
-            
-            # Re-connect if there are pending requests
-            if not @connection_pending.empty?
-                do_connect
+                @connecting = @staging_request
+                ::UV.try_connect(@transport, self, @host, @port)
+            elsif !@closing
+                try_send
             end
         end
 
+
         def on_connect(transport)
             @connecting = false
-            @ready = true
+            @closed = false
 
             # start tls if connection is encrypted
             use_tls() if @https
@@ -183,71 +169,89 @@ module UV
 
             # Kick off pending requests
             @response.reset!
-            @connection_pending.each do |callback|
-                callback.call
-            end
-            @connection_pending.clear
+            try_send  # we only connect if there is a request waiting
         end
 
 
-        protected
-
-
-        def do_connect
-            @transport = @loop.tcp
+        def on_close
+            @closed = true
+            clear_staging = @connecting == @staging_request
+            @connecting = false
+            stop_timer
 
-            if @connect_timeout > 0
-                @timer.progress @connect_timeout_method
-                @timer.start @connect_timeout * 1000
+            # 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
+        end
+
+        def try_send
+            @waiting_response = @staging_request
+            @response.request = @staging_request
+            @staging_request = nil
 
-            @connecting = true
-            ::UV.try_connect(@transport, self, @host, @port)
+            @timer.again if @inactivity_timeout > 0
+            @waiting_response.execute(@transport, proc { |err|
+                @transport.close
+                @waiting_response.reject(err)
+            })
         end
 
-        def get_connection(callback = nil, &blk)
-            callback ||= blk
-
-            if @connecting
-                @connection_pending << callback
-            elsif !@ready
-                @connection_pending << callback
-                do_connect
-            elsif @transport.closing?
-                @connection_pending << callback
-            else
-                callback.call(@connection)
-            end
+
+        def middleware
+            # TODO:: allow for middle ware
+            []
         end
 
-        def connect_timeout
-            @timer.stop
-            @transport.close
-            @connection_pending.clear
+        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 idle_timeout
-            @timer.stop
-            @transport.close
-            @pending_responses.each do |request|
-                request.reject(:idle_timeout)
+        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)
         end
 
-        def next_request
-            request = @pending_requests.shift
 
-            get_connection do
-                @pending_responses << request
+        protected
 
-                @timer.again if @inactivity_timeout > 0
 
-                # TODO:: have request deal with the error internally
-                request.send(@transport, proc { |err|
-                    @transport.close
-                    request.reject(err)
-                })
-            end
+        def idle_timeout
+            @timer.stop
+            @transport.close
         end
 
         def stop_timer

data/lib/uv-rays/version.rb

@@ -1,3 +1,3 @@
 module UV
-    VERSION = '0.2.6'
+    VERSION = '0.3.0'
 end

data/spec/http_endpoint_spec.rb

@@ -40,33 +40,6 @@ module OldServer
 end
 
 
-#
-# TODO:: Write tests for bad server responses
-# Need to be able to recover when: 
-# * no response is sent
-# * disconnect
-# * bad length etc
-#
-module BadServer
-	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.0 200 OK\r\nContent-type: text/html\r\nContent-length: 0\r\n\r\n")
-	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
 		@loop = Libuv::Loop.new
@@ -155,47 +128,6 @@ describe UV::HttpEndpoint do
 			expect(@response2[:headers].cookies).to eq({})
 			expect(@response2[:headers].keep_alive).to eq(true)
 		end
-
-		it "should send pipelined requests on the same connection" 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', 3250, HttpServer
-				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
-
-				request = server.get(:path => '/', :pipeline => true)
-				request.then(proc { |response|
-					@response = response
-					#@loop.stop
-				}, @request_failure)
-				
-				request2 = server.get(:path => '/', :pipeline => true)
-				request2.then(proc { |response|
-					@response2 = response
-					tcp.close
-					@loop.stop
-				}, @request_failure)
-			}
-
-			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)
-		end
 	end
 
 	describe 'old http request' do
@@ -268,41 +200,5 @@ describe UV::HttpEndpoint do
 			expect(@response2[:headers].cookies).to eq({})
 			expect(@response2[:headers].keep_alive).to eq(false)
 		end
-
-		it "should fail to send pipelined 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', 3250, OldServer
-				server = UV::HttpEndpoint.new 'http://127.0.0.1:3250'
-
-				request = server.get(:path => '/', :pipeline => true)
-				request.then(proc { |response|
-					@response = response
-					#@loop.stop
-				}, @request_failure)
-				
-				request2 = server.get(:path => '/', :pipeline => true)
-				request2.then(proc { |response|
-					@response2 = response
-					tcp.close
-					@loop.stop
-				}, @request_failure)
-			}
-
-			expect(@general_failure).to eq([:disconnected])
-			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)
-			# Response 2 was the general failure
-		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uv-rays
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-20 00:00:00.000000000 Z
+date: 2014-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libuv
@@ -202,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Abstractions for working with Libuv