async-http 0.31.1 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20c4728c088a68663d0f336b2326d3e988a342c5d1f1cd2890a12e43cefda133
-  data.tar.gz: da0503f98a16003b0a2c6606e4419ebb311365dac4be7ea685b18bb994b3613c
+  metadata.gz: a35d727fb4d1811ad0ddea60170aef62f60084759c1c2d0f658e335f3496be4d
+  data.tar.gz: 58004aea432052f2979346a359ad55f2d098f9fa1d9f03e4f89bd08474ced951
 SHA512:
-  metadata.gz: 5ecdd9b68abcaf50db65f02ab8f1db4e8ce1e4a00af980510df5d1323a0d4c3b2c135d85fe3683dcf02f5e818b364fe659c44ab5df25459b687ba2a50d8db9e2
-  data.tar.gz: 68536e0f1ea03914f0e4b34116e7a7f738c5fbc7cf2baf9f2d87f7dd6675329c6c48b444ece69cf8a977f4184a525df1fc14b25bb3f7cb3a85c4983519551eed
+  metadata.gz: cee0898153224018a6d9a6b04b5da0635895c59aeb3f37fe5ee3fa20260529a887ee73398afa34ec98ab443a5699d0506bf40fab54123705c1f336ff7e381d72
+  data.tar.gz: fb39c47f2edb32732b16d8a8ac3cd8158f6f78212d4dae6af2201eedc24b6bdf30085a1670b4040fb23f384b51efdf9fcaa4b09994a25c86004da9672a4104e2

data/lib/async/http/body.rb

@@ -20,3 +20,20 @@
 
 require_relative 'body/writable'
 require_relative 'body/buffered'
+
+module Async
+	module HTTP
+		# These classes implement a general IO model for streaming HTTP bodies.
+		module Body
+			# The implementation assumes a sequential unbuffered stream of data.
+			# class Body
+			# 	def each -> yield(String | nil)
+			# 	def read -> String | nil
+			# 	def join -> String
+			
+			# 	def finish -> buffer the stream and close it.
+			# 	def close(error = nil) -> close the stream immediately.
+			# end
+		end
+	end
+end

data/lib/async/http/body/buffered.rb

@@ -54,6 +54,10 @@ module Async
 					@index = 0
 				end
 				
+				def finish
+					self
+				end
+				
 				def length
 					@length ||= @chunks.inject(0) {|sum, chunk| sum + chunk.bytesize}
 				end
@@ -62,10 +66,6 @@ module Async
 					@index >= @chunks.length
 				end
 				
-				def close
-					self
-				end
-				
 				def read
 					if chunk = @chunks[@index]
 						@index += 1

data/lib/async/http/body/chunked.rb

@@ -36,9 +36,14 @@ module Async
 					@finished
 				end
 				
-				def stop(error)
-					@protocol.close
-					@finished = true
+				def close(error = nil)
+					# We only close the connection if we haven't completed reading the entire body:
+					unless @finished
+						@protocol.close
+						@finished = true
+					end
+					
+					super
 				end
 				
 				def read

data/lib/async/http/body/deflate.rb

@@ -55,6 +55,12 @@ module Async
 					@output_length = 0
 				end
 				
+				def close(error = nil)
+					@stream.close unless @stream.closed?
+					
+					super
+				end
+				
 				def length
 					# We don't know the length of the output until after it's been compressed.
 					nil
@@ -71,13 +77,6 @@ module Async
 					end
 				end
 				
-				def stop(error)
-					# There are two ways for the stream to be closed. Either #read returns nil or #stop is called.
-					@stream.close unless @stream.closed?
-					
-					super
-				end
-				
 				def inspect
 					"#{super} | \#<#{self.class} #{(ratio*100).round(2)}%>"
 				end

data/lib/async/http/body/file.rb

@@ -46,6 +46,13 @@ module Async
 					end
 				end
 				
+				def close(error = nil)
+					@file.close
+					@remaining = 0
+					
+					super
+				end
+				
 				attr :offset
 				attr :length
 				
@@ -57,11 +64,6 @@ module Async
 					@file.seek(@offset)
 				end
 				
-				def close
-					@file.close
-					@remaining = 0
-				end
-				
 				def read
 					if @remaining > 0
 						amount = [@remaining, @block_size].min
@@ -70,8 +72,6 @@ module Async
 							@remaining -= chunk.bytesize
 							
 							return chunk
-						else
-							@file.close
 						end
 					end
 				end

data/lib/async/http/body/fixed.rb

@@ -37,10 +37,12 @@ module Async
 					@remaining == 0
 				end
 				
-				def stop(error)
+				def close(error = nil)
 					if @remaining != 0
 						@stream.close
 					end
+					
+					super
 				end
 				
 				def read
@@ -75,9 +77,11 @@ module Async
 					@stream.closed?
 				end
 				
-				def stop(error)
+				def close(error = nil)
 					# We can't really do anything in this case except close the connection.
 					@stream.close
+					
+					super
 				end
 				
 				def read

data/lib/async/http/body/readable.rb

@@ -25,9 +25,17 @@ module Async
 		module Body
 			# A generic base class for wrapping body instances. Typically you'd override `#read`.
 			class Readable
-				# Read all remaining chunks into a buffered body.
-				def close
-					Buffered.for(self)
+				# Read all remaining chunks into a buffered body and close the underlying input.
+				def finish
+					buffered = Buffered.for(self)
+					
+					self.close
+					
+					return buffered
+				end
+				
+				# The consumer can call stop to signal that the stream output has terminated.
+				def close(error = nil)
 				end
 				
 				# Will read return any data?
@@ -44,11 +52,7 @@ module Async
 					nil
 				end
 				
-				# The consumer can call stop to signal that the stream output has terminated.
-				def stop(error)
-				end
-				
-				# Enumerate all chunks until finished. If an error is thrown, #stop will be invoked.
+				# Enumerate all chunks until finished. Then invoke `#close`.
 				def each
 					return to_enum unless block_given?
 					
@@ -56,10 +60,8 @@ module Async
 						yield chunk
 						# chunk.clear
 					end
-				rescue
-					stop($!)
-					
-					raise
+				ensure
+					self.close($!)
 				end
 				
 				# Read all remaining chunks into a single binary string.

data/lib/async/http/body/reader.rb

@@ -34,24 +34,19 @@ module Async
 					end
 				end
 				
-				# Immediately stop reading the body. May close the underlying connection. Discards body.
-				def stop(error = EOFError)
-					if self.body
-						self.body.stop(error)
-						self.body = nil
-					end
-				end
-				
 				# Gracefully finish reading the body. This will buffer the remainder of the body.
 				def finish
 					if self.body
-						self.body = self.body.close
+						self.body = self.body.finish
 					end
 				end
 				
-				# Close the connection as quickly as possible. Discards body.
-				def close
-					self.stop
+				# Close the connection as quickly as possible. Discards body. May close the underlying connection if necessary to terminate the stream.
+				def close(error = nil)
+					if self.body
+						self.body.close(error)
+						self.body = nil
+					end
 				end
 				
 				# Whether there is a body?

data/lib/async/http/body/rewindable.rb

@@ -23,7 +23,7 @@ require_relative 'wrapper'
 module Async
 	module HTTP
 		module Body
-			# A body which buffers all it's contents.
+			# A body which buffers all it's contents as it is `#read`.
 			class Rewindable < Wrapper
 				def initialize(body)
 					super(body)

data/lib/async/http/body/streamable.rb

@@ -44,7 +44,7 @@ module Async
 					@remaining = remaining
 				end
 				
-				def stop(*)
+				def close(*)
 					super
 					
 					@callback.call

data/lib/async/http/body/wrapper.rb

@@ -29,6 +29,20 @@ module Async
 					@body = body
 				end
 				
+				# The wrapped body.
+				attr :body
+				
+				# Buffer any remaining body.
+				def finish
+					@body.finish
+				end
+				
+				def close(error = nil)
+					@body.close(error)
+					
+					super
+				end
+				
 				def empty?
 					@body.empty?
 				end
@@ -37,22 +51,11 @@ module Async
 					@body.length
 				end
 				
-				# Buffer any remaining body.
-				def close
-					@body = @body.close
-					
-					return self
-				end
-				
 				# Read the next available chunk.
 				def read
 					@body.read
 				end
 				
-				def stop(error)
-					@body.stop(error)
-				end
-				
 				def inspect
 					return @body.inspect
 				end

data/lib/async/http/body/writable.rb

@@ -27,13 +27,30 @@ module Async
 		module Body
 			# A dynamic body which you can write to and read from.
 			class Writable < Readable
+				class Closed < StandardError
+				end
+				
 				def initialize
 					@queue = Async::Queue.new
 					
 					@count = 0
 					
 					@finished = false
-					@stopped = nil
+					
+					@closed = false
+					@error = nil
+				end
+				
+				# Stop generating output; cause the next call to write to fail with the given error.
+				def close(error = nil)
+					unless @closed
+						@queue.enqueue(nil)
+						
+						@closed = true
+						@error = error
+					end
+					
+					super
 				end
 				
 				# Has the producer called #finish and has the reader consumed the nil token?
@@ -43,11 +60,6 @@ module Async
 				
 				# Read the next available chunk.
 				def read
-					# I'm not sure if this is a good idea.
-					# if @stopped
-					# 	raise @stopped
-					# end
-					
 					return if @finished
 					
 					unless chunk = @queue.dequeue
@@ -57,17 +69,12 @@ module Async
 					return chunk
 				end
 				
-				# Stop generating output; cause the next call to write to fail with the given error.
-				def stop(error)
-					@stopped ||= error
-				end
-				
 				# Write a single chunk to the body. Signal completion by calling `#finish`.
 				def write(chunk)
 					# If the reader breaks, the writer will break.
 					# The inverse of this is less obvious (*)
-					if @stopped
-						raise @stopped
+					if @closed
+						raise(@error || Closed)
 					end
 					
 					# TODO should this yield if the queue is full?
@@ -78,11 +85,6 @@ module Async
 				
 				alias << write
 				
-				# Signal that output has finished. This must be called at least once.
-				def finish
-					@queue.enqueue(nil)
-				end
-				
 				def inspect
 					"\#<#{self.class} #{@count} chunks written#{@finished ? ', finished' : ''}>"
 				end

data/lib/async/http/protocol/http2/request.rb

@@ -70,7 +70,7 @@ module Async
 						end
 						
 						if end_stream
-							@input.finish
+							@input.close
 						end
 					end
 					

data/lib/async/http/protocol/http2/response.rb

@@ -70,9 +70,9 @@ module Async
 						end
 						
 						if end_stream
-							@input.finish
+							@input.close
 						end
-					rescue EOFError
+					rescue
 						@stream.send_reset_stream(0)
 					end
 					

data/lib/async/http/protocol/http2/stream.rb

@@ -56,7 +56,10 @@ module Async
 						elsif chunk = @body.read
 							# There was a new chunk of data to send
 						else
-							@body = nil
+							if @body
+								@body.close
+								@body = nil
+							end
 							
 							# @body.read above might take a while and a stream reset might be received in the mean time.
 							unless closed?
@@ -109,7 +112,7 @@ module Async
 						error_code = super
 						
 						if @body
-							@body.stop(EOFError.new(error_code))
+							@body.close(EOFError.new(error_code))
 							@body = nil
 						end
 						

data/lib/async/http/statistics.rb

@@ -75,7 +75,7 @@ module Async
 					end
 				end
 				
-				def stop(error)
+				def close(error = nil)
 					complete_statistics(error)
 					
 					super

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.31.1"
+		VERSION = "0.32.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.31.1
+  version: 0.32.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-30 00:00:00.000000000 Z
+date: 2018-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async