async-io 1.21.0 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef50d94f2e881c86637e32d46f307a88b457537e9a649592d851e768474ffe2a
-  data.tar.gz: 24aac313f12b07478e080fa5713432b6e270be5d74e21688bb39efed2d4cf296
+  metadata.gz: 368fe5eb02962730d8f47e3ab180913aa922085eb554cc2e430b8c15113e8f33
+  data.tar.gz: '09c5660537d3a7ce792bdf89674e79d0e40391346788c27808d14edbde1dfb13'
 SHA512:
-  metadata.gz: '02688618b5035611cc4753acd581c0691c957ea0daefbdd4c357c52a4a31c12783b44dae77a5654aed36022abccac05a0813d300974dd94be26e97d5b25c47e9'
-  data.tar.gz: 811063ba4e91b823be5e8037fcf537bb40aa35bbbf7210df5fe21348b1394e579f27a7c0721114da9671c2ad108d0a70413040850d0643f5602cfc7ad5abc44f
+  metadata.gz: 27929ee0118185c0dadb8216ce88f5d4296633481215d0c3865396b56e5c9d73f63bd8b6d6f01db5e641a3eb6e78209746b36bf0e91b17cb9e7d8550819d8a37
+  data.tar.gz: 35c33f0d712a94d7468c69aaa178139e756a3fcb1e56daf78671a2f347a790b141172ea6a3d993d4640da017d6f12624e1f10124225d0c4a877d2b39351b0b6f

data/lib/async/io/socket.rb

@@ -26,13 +26,15 @@ require_relative 'generic'
 module Async
 	module IO
 		module Peer
+			include ::Socket::Constants
+			
 			# Is it likely that the socket is still connected?
 			# May return false positive, but won't return false negative.
 			def connected?
 				return false if @io.closed?
 				
 				# If we can wait for the socket to become readable, we know that the socket may still be open.
-				result = to_io.recv_nonblock(1, Socket::MSG_PEEK, exception: false)
+				result = to_io.recv_nonblock(1, MSG_PEEK, exception: false)
 				
 				# Either there was some data available, or we can wait to see if there is data avaialble.
 				return !result.empty? || result == :wait_readable
@@ -47,8 +49,8 @@ module Async
 				super
 				
 				case self.protocol
-				when 0, Socket::IPPROTO_TCP
-					self.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, value ? 1 : 0)
+				when 0, IPPROTO_TCP
+					self.setsockopt(IPPROTO_TCP, TCP_NODELAY, value ? 1 : 0)
 				else
 					Async.logger.warn(self) {"Unsure how to sync=#{value} for #{self.protocol}!"}
 				end
@@ -61,8 +63,8 @@ module Async
 			
 			def sync
 				case self.protocol
-				when Socket::IPPROTO_TCP
-					self.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY).bool
+				when IPPROTO_TCP
+					self.getsockopt(IPPROTO_TCP, TCP_NODELAY).bool
 				else
 					true
 				end && super
@@ -106,8 +108,6 @@ module Async
 			
 			wrap_blocking_method :recvfrom, :recvfrom_nonblock
 			
-			include ::Socket::Constants
-			
 			# @raise Errno::EAGAIN the connection failed due to the remote end being overloaded.
 			def connect(*args)
 				begin
@@ -149,15 +149,15 @@ module Async
 				socket = wrapped_klass.new(*args)
 				
 				if reuse_address
-					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, 1)
+					socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
 				end
 				
 				if reuse_port
-					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
+					socket.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
 				end
 				
 				if linger
-					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, linger)
+					socket.setsockopt(SOL_SOCKET, SO_LINGER, linger)
 				end
 				
 				yield socket
@@ -184,6 +184,11 @@ module Async
 				
 				wrapper = build(remote_address.afamily, remote_address.socktype, remote_address.protocol, **options) do |socket|
 					if local_address
+						if defined?(IP_BIND_ADDRESS_NO_PORT)
+							# Inform the kernel (Linux 4.2+) to not reserve an ephemeral port when using bind(2) with a port number of 0. The port will later be automatically chosen at connect(2) time, in a way that allows sharing a source port as long as the 4-tuple is unique.
+							socket.setsockopt(SOL_IP, IP_BIND_ADDRESS_NO_PORT, 1)
+						end
+						
 						socket.bind(local_address.to_sockaddr)
 					end
 				end

data/lib/async/io/stream.rb

@@ -163,7 +163,17 @@ module Async
 				@io.closed?
 			end
 			
-			# Closes the stream and flushes any unwritten data.
+			def close_read
+				@io.close_read
+			end
+			
+			def close_write
+				flush
+			ensure
+				@io.close_write
+			end
+			
+			# Best effort to flush any unwritten data, and then close the underling IO.
 			def close
 				return if @io.closed?
 				

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.21.0"
+		VERSION = "1.22.0"
 	end
 end

data/spec/async/io/c10k_spec.rb

@@ -21,59 +21,44 @@
 require 'async/io'
 require 'benchmark'
 
+require 'ruby-prof'
+
 RSpec.describe "echo client/server" do
 	# macOS has a rediculously hard time to do this.
 	# sudo sysctl -w net.inet.ip.portrange.first=10000
 	# sudo sysctl -w net.inet.ip.portrange.hifirst=10000
 	# Probably due to the use of select.
 	
-	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 200 : 10000}
-	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 10102)}
+	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 1000 : 10000}
+	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 10101)}
 	
 	def echo_server(server_address)
 		Async do |task|
-			connection_count = 0
+			connections = []
 			
-			connections_complete = task.async do
-				last_count = 0
+			Async::IO::Socket.bind(server_address) do |server|
+				server.listen(Socket::SOMAXCONN)
 				
-				while connection_count < repeats
-					if connection_count != last_count
-						puts "#{connection_count}/#{repeats} simultaneous connections."
-						last_count = connection_count
-					end
-					
-					task.sleep(1.0)
+				while connections.count < repeats
+					peer, address = server.accept
+					connections << peer
 				end
-				
-				puts "Releasing all connections..."
-			end
+			end.wait
 			
-			# This is a synchronous block within the current task:
-			Async::IO::Socket.accept(server_address) do |client|
-				connection_count += 1
-				
-				# Wait until we've got all the connections:
-				connections_complete.wait
-				
-				# This is an asynchronous block within the current reactor:
-				data = client.read(512)
-				client.write(data)
+			puts "Releasing #{connections.count} connections..."
+			
+			while connection = connections.pop
+				connection.write(".")
+				connection.close
 			end
 		end
-	ensure
-		puts "echo_server: #{$!.inspect}"
 	end
 	
 	def echo_client(server_address, data, responses)
 		Async do |task|
 			begin
 				Async::IO::Socket.connect(server_address) do |peer|
-					result = peer.write(data)
-					
-					message = peer.read(512)
-					
-					responses << message
+					responses << peer.read(1)
 				end
 			rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EADDRINUSE
 				puts "#{data}: #{$!}..."
@@ -85,9 +70,16 @@ RSpec.describe "echo client/server" do
 	
 	def fork_server
 		pid = fork do
+			# profile = RubyProf::Profile.new(merge_fibers: true)
+			# profile.start
+			
 			echo_server(server_address)
+		# ensure
+		# 	result = profile.stop
+		# 	printer = RubyProf::FlatPrinter.new(result)
+		# 	printer.print(STDOUT)
 		end
-		
+
 		yield
 	ensure
 		Process.kill(:KILL, pid)
@@ -102,8 +94,11 @@ RSpec.describe "echo client/server" do
 		example.reporter.message "Handled #{repeats} connections in #{duration.round(2)}s: #{(repeats/duration).round(2)}req/s"
 	end
 	
-	it "should send/receive 10,000 messages" do
+	it "should wait until all clients are connected" do
 		fork_server do
+			# profile = RubyProf::Profile.new(merge_fibers: true)
+			# profile.start
+			
 			Async do |task|
 				responses = []
 				
@@ -119,6 +114,11 @@ RSpec.describe "echo client/server" do
 				
 				expect(responses.count).to be repeats
 			end
+			
+		# ensure
+		# 	result = profile.stop
+		# 	printer = RubyProf::FlatPrinter.new(result)
+		# 	printer.print(STDOUT)
 		end
 	end
 end

data/spec/async/io/socket/tcp_spec.rb

@@ -24,7 +24,8 @@ RSpec.describe Async::IO::Socket do
 	include_context Async::RSpec::Reactor
 	
 	# Shared port for localhost network tests.
-	let(:server_address) {Async::IO::Address.tcp("localhost", 6788)}
+	let(:server_address) {Async::IO::Address.tcp("127.0.0.1", 6788)}
+	let(:local_address) {Async::IO::Address.tcp("127.0.0.1", 0)}
 	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
 	let!(:server_task) do
@@ -54,6 +55,16 @@ RSpec.describe Async::IO::Socket do
 	end
 	
 	describe 'non-blocking tcp connect' do
+		it "can specify local address" do
+			reactor.async do |task|
+				Async::IO::Socket.connect(server_address, local_address: local_address) do |client|
+					client.write(data)
+					
+					expect(client.read(512)).to be == data
+				end
+			end
+		end
+		
 		it "should start server and send data" do
 			reactor.async do |task|
 				Async::IO::Socket.connect(server_address) do |client|

data/spec/async/io/stream_spec.rb

@@ -29,6 +29,29 @@ RSpec.describe Async::IO::Stream do
 	let!(:stream) {Async::IO::Stream.new(buffer)}
 	let(:io) {stream.io}
 	
+	describe '#close_read' do
+		let(:sockets) {@sockets = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)}
+		let!(:stream) {Async::IO::Stream.new(sockets.last)}
+		after(:each) {@sockets&.each(&:close)}
+		
+		it "can close the reading end of the stream" do
+			stream.close_read
+			
+			expect do
+				stream.read
+			end.to raise_error(IOError, /not opened for reading/)
+		end
+		
+		it "can close the writing end of the stream" do
+			stream.close_write
+			
+			expect do
+				stream.write("Oh no!")
+				stream.flush
+			end.to raise_error(IOError, /not opened for writing/)
+		end
+	end
+	
 	describe '#read' do
 		it "should read everything" do
 			io.write "Hello World"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.21.0
+  version: 1.22.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-25 00:00:00.000000000 Z
+date: 2019-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async