async-io 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de12378d6473944c46fa065b1b88b71069055f82fbcd565dc403e5430ed3f137
-  data.tar.gz: 65d6c18c5adc877aa518f4de267023dd5623440d0424fb302fb54af92f4a7c03
+  metadata.gz: b298c4c118c511eaabda86500a8d08bf02b01cd156e0858cb962f4d3005ce665
+  data.tar.gz: 1a231a883488b441d599991043409204b2f282df470fdd8b15d18afa6f9b8e06
 SHA512:
-  metadata.gz: 966cc66e1081be1c43f0a54ee5722c70689b12b63555ec3ff448714ed24e344347b0eb3e8716af027d42a293464a8f70c2f97eac71544f169eacdd68fd18b3ed
-  data.tar.gz: dd68773cafc1b02f8512e77f696b5ec4d12f4d4287ca6ff80084c54b57ef65e545116e6388bf8301aade58e946a3d2a7d2d118ef1b2bd02db502a7c95f16c48e
+  metadata.gz: 8b87b6ca52a9e6164e4c6e549eaa2581d2c71908488f1f8235f0a2a8bbe25dd6e551a419b65f9ebd4be6b5c0182e99315c552cf36cc309777d311cd79397accc
+  data.tar.gz: 1cd79fdb63398e13ce10041b4facf4bb1dc5498065c18eac8f3265cd2f842f6360b6f31e2b41acf11df29c62096810940050f4e51a7bceb4e9e242af9cfbf81d

data/README.md

@@ -22,7 +22,7 @@ And then execute:
 
 Or install it yourself as:
 
-	$ gem install async-socket
+	$ gem install async-io
 
 ## Usage
 

data/async-io.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 	spec.has_rdoc      = "yard"
 
 	spec.add_dependency "async", "~> 1.3"
-	spec.add_development_dependency "async-rspec", "~> 1.2"
+	spec.add_development_dependency "async-rspec", "~> 1.4"
 
 	spec.add_development_dependency "bundler", "~> 1.3"
 	spec.add_development_dependency "rake", "~> 10.0"

data/lib/async/io/notification.rb

@@ -29,8 +29,6 @@ module Async
 				
 				@input = pipe.first
 				@output = pipe.last
-				
-				@count = 0
 			end
 			
 			def close

data/lib/async/io/stream.rb

@@ -38,27 +38,49 @@ module Async
 			end
 			
 			attr :io
+			attr :block_size
 			
 			# Reads `size` bytes from the stream. If size is not specified, read until end of file.
 			def read(size = nil)
-				return "" if size == 0
+				return '' if size == 0
+				
+				if size
+					if size <= @block_size
+						fill_read_buffer until @eof or @read_buffer.size >= size
+					else
+						fill_read_buffer(size - @read_buffer.size) until @eof or @read_buffer.size >= size
+					end
+				else
+					fill_read_buffer until @eof
+				end
 				
-				until @eof || (size && size <= @read_buffer.size)
+				return consume_read_buffer(size)
+			end
+			
+			# Read at most `size` bytes from the stream. Will avoid reading from the underlying stream if possible.
+			def read_partial(size = nil)
+				return '' if size == 0
+				
+				if @read_buffer.empty? and !@eof
 					fill_read_buffer
 				end
-
+				
 				return consume_read_buffer(size)
 			end
-
+			
 			# Writes `string` to the buffer. When the buffer is full or #sync is true the
 			# buffer is flushed to the underlying `io`.
 			# @param string the string to write to the buffer.
 			# @return the number of bytes appended to the buffer.
 			def write(string)
-				@write_buffer << string
-				
-				if @write_buffer.size > @block_size
-					flush
+				if @write_buffer.empty? and string.bytesize >= @block_size
+					syswrite(string)
+				else
+					@write_buffer << string
+					
+					if @write_buffer.size >= @block_size
+						flush
+					end
 				end
 				
 				return string.bytesize
@@ -73,8 +95,10 @@ module Async
 
 			# Flushes buffered data to the stream.
 			def flush
-				syswrite(@write_buffer)
-				@write_buffer.clear
+				unless @write_buffer.empty?
+					syswrite(@write_buffer)
+					@write_buffer.clear
+				end
 			end
 
 			def gets(separator = $/)
@@ -138,15 +162,13 @@ module Async
 			private
 			
 			# Fills the buffer from the underlying stream.
-			def fill_read_buffer
-				if buffer = @io.read(@block_size)
-					@read_buffer << buffer
-				else
+			def fill_read_buffer(size = @block_size)
+				if !sysread(size, @read_buffer)
 					@eof = true
 				end
 			end
 
-			# Consumes `size` bytes from the buffer.
+			# Consumes at most `size` bytes from the buffer.
 			# @param size [Integer|nil] The amount of data to consume. If nil, consume entire buffer.
 			def consume_read_buffer(size = nil)
 				# If we are at eof, and the read buffer is empty, we can't consume anything.
@@ -154,7 +176,7 @@ module Async
 				
 				result = nil
 				
-				if size == nil || size == @read_buffer.size
+				if size == nil || size >= @read_buffer.size
 					# Consume the entire read buffer:
 					result = @read_buffer.dup
 					@read_buffer.clear
@@ -187,6 +209,15 @@ module Async
 				
 				return written
 			end
+			
+			# Read to 
+			def sysread(size, buffer)
+				if buffer.empty?
+					@io.read(size, buffer)
+				elsif chunk = @io.read(size)
+					buffer << chunk
+				end
+			end
 		end
 	end
 end

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.7.0"
+		VERSION = "1.8.0"
 	end
 end

data/spec/async/io/ssl_server_spec.rb

@@ -25,36 +25,100 @@ require_relative 'generic_examples'
 
 RSpec.describe Async::IO::SSLServer do
 	include_context Async::RSpec::Reactor
-	include_context Async::RSpec::SSL::VerifiedContexts
-	include_context Async::RSpec::SSL::ValidCertificate
 	
-	let(:endpoint) {Async::IO::Endpoint.tcp("127.0.0.1", 6780, reuse_port: true)}
-	let(:server_endpoint) {Async::IO::SecureEndpoint.new(endpoint, ssl_context: server_context)}
-	let(:client_endpoint) {Async::IO::SecureEndpoint.new(endpoint, ssl_context: client_context)}
-	
-	let(:data) {"What one programmer can do in one month, two programmers can do in two months."}
-	
-	it 'can accept_each connections' do
-		# Accept a single incoming connection and then finish.
-		server_task = reactor.async do |task|
-			server_endpoint.bind do |server|
-				server.listen(10)
-				
-				server.accept_each do |peer, address|
-					data = peer.read(512)
-					peer.write(data)
+	context 'single host' do
+		include_context Async::RSpec::SSL::VerifiedContexts
+		include_context Async::RSpec::SSL::ValidCertificate
+		
+		let(:endpoint) {Async::IO::Endpoint.tcp("127.0.0.1", 6780, reuse_port: true)}
+		let(:server_endpoint) {Async::IO::SecureEndpoint.new(endpoint, ssl_context: server_context)}
+		let(:client_endpoint) {Async::IO::SecureEndpoint.new(endpoint, ssl_context: client_context)}
+		
+		let(:data) {"What one programmer can do in one month, two programmers can do in two months."}
+		
+		it 'can accept_each connections' do
+			# Accept a single incoming connection and then finish.
+			server_task = reactor.async do |task|
+				server_endpoint.bind do |server|
+					server.listen(10)
+					
+					server.accept_each do |peer, address|
+						data = peer.read(512)
+						peer.write(data)
+					end
 				end
 			end
+			
+			reactor.async do
+				client_endpoint.connect do |client|
+					client.write(data)
+					
+					expect(client.read(512)).to be == data
+				end
+				
+				server_task.stop
+			end
 		end
+	end
+	
+	context 'multiple hosts' do
+		let(:hosts) {['test.com', 'example.com']}
+		
+		include_context Async::RSpec::SSL::HostCertificates
 		
-		reactor.async do
-			client_endpoint.connect do |client|
-				client.write(data)
+		let(:endpoint) {Async::IO::Endpoint.tcp("127.0.0.1", 6782, reuse_port: true)}
+		let(:server_endpoint) {Async::IO::SecureEndpoint.new(endpoint, ssl_context: server_context)}
+		let(:valid_client_endpoint) {Async::IO::SecureEndpoint.new(endpoint, hostname: 'example.com', ssl_context: client_context)}
+		let(:invalid_client_endpoint) {Async::IO::SecureEndpoint.new(endpoint, hostname: 'fleeb.com', ssl_context: client_context)}
+		
+		let(:data) {"What one programmer can do in one month, two programmers can do in two months."}
+		
+		it 'can select correct host' do
+			# Accept a single incoming connection and then finish.
+			server_task = reactor.async do |task|
+				server_endpoint.bind do |server|
+					server.listen(10)
+					
+					server.accept_each do |peer, address|
+						expect(peer.hostname).to be == 'example.com'
+						
+						data = peer.read(512)
+						peer.write(data)
+					end
+				end
+			end
+			
+			reactor.async do
+				valid_client_endpoint.connect do |client|
+					client.write(data)
+					
+					expect(client.read(512)).to be == data
+				end
 				
-				expect(client.read(512)).to be == data
+				server_task.stop
+			end
+		end
+		
+		it 'it fails with invalid host' do
+			# Accept a single incoming connection and then finish.
+			server_task = reactor.async do |task|
+				server_endpoint.bind do |server|
+					server.listen(10)
+					
+					server.accept_each do |peer, address|
+						peer.close
+					end
+				end
 			end
 			
-			server_task.stop
+			reactor.async do
+				expect do
+					invalid_client_endpoint.connect do |client|
+					end
+				end.to raise_error(OpenSSL::SSL::SSLError, /handshake failure/)
+				
+				server_task.stop
+			end
 		end
 	end
 end

data/spec/async/io/stream_spec.rb

@@ -26,16 +26,60 @@ RSpec.describe Async::IO::Stream do
 	
 	describe '#read' do
 		it "should read everything" do
-			io.puts "Hello World"
+			io.write "Hello World"
 			io.seek(0)
 			
-			expect(stream.read).to be == "Hello World\n"
+			expect(io).to receive(:read).and_call_original.twice
+			
+			expect(stream.read).to be == "Hello World"
+			expect(stream).to be_eof
+		end
+		
+		it "should read only the amount requested" do
+			io.write "Hello World"
+			io.seek(0)
+			
+			expect(io).to receive(:read).and_call_original.twice
+			
+			expect(stream.read(4)).to be == "Hell"
+			expect(stream).to_not be_eof
+			
+			expect(stream.read(20)).to be == "o World"
 			expect(stream).to be_eof
 		end
 	end
 	
+	describe '#flush' do
+		it "should not call write if write buffer is empty" do
+			expect(io).to_not receive(:write)
+			
+			stream.flush
+		end
+		
+		it "should flush underlying data when it exceeds block size" do
+			expect(io).to receive(:write).and_call_original.once
+			
+			stream.block_size.times do
+				stream.write("!")
+			end
+		end
+	end
+	
+	describe '#read_partial' do
+		it "should avoid calling read" do
+			io.write "Hello World" * 1024
+			io.seek(0)
+			
+			expect(io).to receive(:read).and_call_original.once
+			
+			expect(stream.read_partial(11)).to be == "Hello World"
+		end
+	end
+	
 	describe '#write' do
 		it "should read one line" do
+			expect(io).to receive(:write).and_call_original.once
+			
 			stream.write "Hello World\n"
 			stream.flush
 			

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2018-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement