async-io 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 152518b09c63b90c002c9e4fa832d075898c75e613cc0405e8b1df947f0c3bdd
-  data.tar.gz: 4ddb1b1b688bbc37bfc6beb705866706aba4f1e43efe53126b03e0f3f57c4733
+  metadata.gz: 8b5507d72c8c7e07851a347dc15eacfbb51f06a03a50ef438af12bb889b28a8c
+  data.tar.gz: b53e91190155fad15b9a8097ec5243a8af5fc81623f4acb2e68f5d1591752868
 SHA512:
-  metadata.gz: b057c8c881f386afa0151fa220a9b51660b2487d124e8c45dbc45c240c2c682e83fd16b8c92c69b311bc2ae0d3b638fec4218ceb7e76c417367fcbc0852ec9be
-  data.tar.gz: db8b25d2bbc5c069586ce61f17a030b9469d22b1173b618adf826dabdffe5251f3e4e387338adeb89fee93dafd303365e729cdf8cf3217401f9d306b10152e95
+  metadata.gz: dbbf5038f8a3d9bed87b8d51a81a34b2c454cb79a80405a560c857d1cfab1ec49e8ca75363eec37f0e71ff3dc2c177b7394b8562a2b7a965c01e9a67af0134a9
+  data.tar.gz: 2885f7b39a0bed3e4091900768499d3c0837a82b19e7cd5fb7d8770655a6f678283b4d49af2f195666b4fb6ffd003c093167f3d6ec7ce2f37ecbae436469a596

data/.travis.yml

@@ -5,11 +5,10 @@ cache: bundler
 
 matrix:
   include:
-    - rvm: 2.0
-    - rvm: 2.1
     - rvm: 2.2
     - rvm: 2.3
     - rvm: 2.4
+    - rvm: 2.5
     - rvm: jruby-head
       env: JRUBY_OPTS="--debug -X+O"
     - rvm: ruby-head

data/async-io.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 	spec.has_rdoc      = "yard"
 
-	spec.add_dependency "async", "~> 1.0"
+	spec.add_dependency "async", "~> 1.3"
 	spec.add_development_dependency "async-rspec", "~> 1.2"
 
 	spec.add_development_dependency "bundler", "~> 1.3"

data/lib/async/io/generic.rb

@@ -69,14 +69,12 @@ module Async
 				def wrap(*args)
 					wrapper = self.new(@wrapped_klass.new(*args))
 					
-					if block_given?
-						begin
-							yield wrapper
-						ensure
-							wrapper.close
-						end
-					else
-						return wrapper
+					return wrapper unless block_given?
+					
+					begin
+						yield wrapper
+					ensure
+						wrapper.close
 					end
 				end
 			end
@@ -133,6 +131,7 @@ module Async
 					end
 				end
 			else
+				# This is also correct for Rubinius.
 				def async_send(*args)
 					async do
 						@io.__send__(*args)

data/lib/async/io/notification.rb

@@ -43,8 +43,6 @@ module Async
 			def wait
 				wrapper = Async::IO::Generic.new(@input)
 				wrapper.read(1)
-			ensure
-				wrapper.send(:close_monitor) if wrapper
 			end
 			
 			# Signal to a given task that it should resume operations.

data/lib/async/io/socket.rb

@@ -45,18 +45,16 @@ module Async
 				
 				wrapper = Socket.new(peer, self.reactor)
 				
-				if block_given?
-					task.async do |task|
-						task.annotate "incoming connection #{address.inspect}"
-						
-						begin
-							yield wrapper, address
-						ensure
-							wrapper.close
-						end
+				return wrapper, address unless block_given?
+				
+				task.async do |task|
+					task.annotate "incoming connection #{address.inspect}"
+					
+					begin
+						yield wrapper, address
+					ensure
+						wrapper.close
 					end
-				else
-					return wrapper, address
 				end
 			end
 			
@@ -124,14 +122,12 @@ module Async
 					raise
 				end
 				
-				if block_given?
-					begin
-						yield wrapper, task
-					ensure
-						wrapper.close
-					end
-				else
-					return wrapper
+				return wrapper unless block_given?
+				
+				begin
+					yield wrapper, task
+				ensure
+					wrapper.close
 				end
 			end
 			
@@ -150,14 +146,12 @@ module Async
 					socket.bind(local_address.to_sockaddr)
 				end
 				
-				if block_given?
-					begin
-						yield wrapper, task
-					ensure
-						wrapper.close
-					end
-				else
-					return wrapper
+				return wrapper unless block_given?
+				
+				begin
+					yield wrapper, task
+				ensure
+					wrapper.close
 				end
 			end
 			

data/lib/async/io/ssl_socket.rb

@@ -76,22 +76,20 @@ module Async
 				
 				wrapper = SSLSocket.connect_socket(peer, @context)
 				
-				if block_given?
-					task.async do
-						task.annotate "accepting secure connection #{address}"
+				return wrapper, address unless block_given?
+				
+				task.async do
+					task.annotate "accepting secure connection #{address}"
+					
+					begin
+						wrapper.accept
 						
-						begin
-							wrapper.accept
-							
-							yield wrapper, address
-						rescue SSLError
-							Async.logger.error($!.class) {$!}
-						ensure
-							wrapper.close
-						end
+						yield wrapper, address
+					rescue SSLError
+						Async.logger.error($!.class) {$!}
+					ensure
+						wrapper.close
 					end
-				else
-					return wrapper, address
 				end
 			end
 		end

data/lib/async/io/stream.rb

@@ -24,10 +24,13 @@ require_relative 'generic'
 module Async
 	module IO
 		class Stream
-			def initialize(io, block_size: 1024*8)
+			def initialize(io, block_size: 1024*8, sync: true)
 				@io = io
 				@eof = false
 				
+				# We don't want Ruby to do any IO buffering.
+				@io.sync = sync
+				
 				@block_size = block_size
 				
 				@read_buffer = BinaryString.new
@@ -74,6 +77,20 @@ module Async
 				@write_buffer.clear
 			end
 
+			def gets(separator = $/)
+				flush
+				
+				read_until(separator)
+			end
+
+			def puts(*args, separator: $/)
+				args.each do |arg|
+					@write_buffer << arg << separator
+				end
+				
+				flush
+			end
+
 			# Closes the stream and flushes any unwritten data.
 			def close
 				flush rescue nil

data/lib/async/io/tcp_socket.rb

@@ -19,19 +19,61 @@
 # THE SOFTWARE.
 
 require_relative 'socket'
+require_relative 'stream'
+require 'fcntl'
 
 module Async
 	module IO
 		# Asynchronous TCP socket wrapper.
 		class TCPSocket < IPSocket
 			wraps ::TCPSocket
+			
+			def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
+				if remote_host.is_a? ::TCPSocket
+					super(remote_host)
+				else
+					remote_address = Addrinfo.tcp(remote_host, remote_port)
+					local_address = Addrinfo.tcp(local_host, local_port) if local_host
+					
+					# We do this unusual dance to avoid leaking an "open" socket instance.
+					socket = Socket.connect(remote_address, local_address)
+					fd = socket.fcntl(Fcntl::F_DUPFD)
+					socket.close
+					
+					super(::TCPSocket.for_fd(fd))
+					
+					# The equivalent blocking operation. Unfortunately there is no trivial way to make this non-blocking.
+					# super(::TCPSocket.new(remote_host, remote_port, local_host, local_port))
+				end
+				
+				@buffer = Stream.new(self)
+			end
+			
+			attr :buffer
+			
+			def_delegators :@buffer, :gets, :puts, :flush
 		end
 		
 		# Asynchronous TCP server wrappper.
 		class TCPServer < TCPSocket
 			wraps ::TCPServer, :listen
 			
-			include ServerSocket
+			def initialize(*args)
+				if args.first.is_a? ::TCPServer
+					super(args.first)
+				else
+					# We assume this operation doesn't block (for long):
+					super(::TCPServer.new(*args))
+				end
+			end
+			
+			def accept(task: Task.current)
+				peer, address = async_send(:accept_nonblock)
+				
+				wrapper = TCPSocket.new(peer)
+				
+				return wrapper, address
+			end
 		end
 	end
 end

data/lib/async/io/udp_socket.rb

@@ -26,8 +26,16 @@ module Async
 		class UDPSocket < IPSocket
 			wraps ::UDPSocket, :bind
 			
+			def initialize(family)
+				if family.is_a? ::UDPSocket
+					super(family)
+				else
+					super(::UDPSocket.new(family))
+				end
+			end
+			
 			# We pass `send` through directly, but in theory it might block. Internally, it uses sendto.
-			def_delegators :@io, :send
+			def_delegators :@io, :send, :connect
 			
 			# This function is so fucked. Why does `UDPSocket#recvfrom` return the remote address as an array, but `Socket#recfrom` return it as an `Addrinfo`? You should prefer `recvmsg`.
 			wrap_blocking_method :recvfrom, :recvfrom_nonblock

data/lib/async/io/unix_socket.rb

@@ -34,17 +34,14 @@ module Async
 			
 			def accept
 				peer = async_send(:accept_nonblock)
+				wrapper = UNIXSocket.new(peer, self.reactor)
 				
-				if block_given?
-					wrapper = UNIXSocket.new(peer, self.reactor)
-					
-					begin
-						yield wrapper
-					ensure
-						wrapper.close
-					end
-				else
-					return UNIXSocket.new(peer, self.reactor)
+				return wrapper unless block_given?
+				
+				begin
+					yield wrapper
+				ensure
+					wrapper.close
 				end
 			end
 		end

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.3.0"
+		VERSION = "1.4.0"
 	end
 end

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

@@ -0,0 +1,115 @@
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'async/io/tcp_socket'
+
+RSpec.describe Async::Reactor do
+	include_context Async::RSpec::Leaks
+	
+	# Shared port for localhost network tests.
+	let(:server_address) {Async::IO::Address.tcp("localhost", 6788)}
+	let(:data) {"The quick brown fox jumped over the lazy dog."}
+	
+	around(:each) do |example|
+		# Accept a single incoming connection and then finish.
+		subject.async do |task|
+			Async::IO::Socket.bind(server_address) do |server|
+				server.listen(10)
+				
+				server.accept do |peer, address|
+					data = peer.read(512)
+					peer.write(data)
+				end
+			end
+		end
+		
+		result = example.run
+		
+		if result.is_a? Exception
+			result 
+		else
+			subject.run
+		end
+	end
+	
+	describe 'basic tcp server' do
+		it "should start server and send data" do
+			subject.async do
+				Async::IO::Socket.connect(server_address) do |client|
+					client.write(data)
+					expect(client.read(512)).to be == data
+				end
+			end
+		end
+	end
+	
+	describe 'non-blocking tcp connect' do
+		it "should start server and send data" do
+			subject.async do |task|
+				Async::IO::Socket.connect(server_address) do |client|
+					client.write(data)
+					expect(client.read(512)).to be == data
+				end
+			end
+		end
+		
+		it "can connect socket and read/write in a different task" do
+			socket = nil
+			
+			subject.async do |task|
+				socket = Async::IO::Socket.connect(server_address)
+				
+				# Stop the reactor once the connection was made.
+				subject.stop
+			end
+		
+			subject.run
+			
+			expect(socket).to_not be_nil
+			expect(socket).to be_kind_of Async::Wrapper
+			
+			subject.async do
+				socket.write(data)
+				
+				expect(socket.read(512)).to be == data
+			end
+			
+			subject.run
+			
+			socket.close
+		end
+		
+		it "can't use a socket in nested tasks" do
+			subject.async do |task|
+				socket = Async::IO::Socket.connect(server_address)
+				expect(socket).to be_kind_of Async::Wrapper
+				
+				expect do
+					subject.async do
+						socket.write(data)
+						# expect(socket.read(512)).to be == data
+					end
+				end.to_not raise_error
+				
+				socket.close
+			end
+		end
+	end
+end

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

@@ -0,0 +1,73 @@
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'async/io/udp_socket'
+
+RSpec.describe Async::Reactor do
+	include_context Async::RSpec::Leaks
+	
+	# Shared port for localhost network tests.
+	let(:server_address) {Async::IO::Address.udp("127.0.0.1", 6778)}
+	let(:data) {"The quick brown fox jumped over the lazy dog."}
+	
+	describe 'basic udp server' do
+		it "should echo data back to peer" do
+			subject.async do
+				Async::IO::Socket.bind(server_address) do |server|
+					packet, address = server.recvfrom(512)
+					
+					server.send(packet, 0, address)
+				end
+			end
+			
+			subject.async do
+				Async::IO::Socket.connect(server_address) do |client|
+					client.send(data)
+					response = client.recv(512)
+					
+					expect(response).to be == data
+				end
+			end
+			
+			subject.run
+		end
+		
+		it "should use unconnected socket" do
+			subject.async do
+				Async::IO::Socket.bind(server_address) do |server|
+					packet, address = server.recvfrom(512)
+					
+					server.send(packet, 0, address)
+				end
+			end
+			
+			subject.async do
+				Async::IO::UDPSocket.wrap(server_address.afamily) do |client|
+					client.send(data, 0, server_address)
+					response, address = client.recvfrom(512)
+					
+					expect(response).to be == data
+				end
+			end
+			
+			subject.run
+		end
+	end
+end

data/spec/async/io/tcp_socket_spec.rb

@@ -5,7 +5,7 @@
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
+# furnished to do so, reactor to the following conditions:
 # 
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
@@ -20,96 +20,34 @@
 
 require 'async/io/tcp_socket'
 
-RSpec.describe Async::Reactor do
-	include_context Async::RSpec::Leaks
+RSpec.describe Async::IO::TCPSocket do
+	include_context Async::RSpec::Reactor
 	
 	# Shared port for localhost network tests.
 	let(:server_address) {Async::IO::Address.tcp("localhost", 6788)}
 	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
-	around(:each) do |example|
-		# Accept a single incoming connection and then finish.
-		subject.async do |task|
-			Async::IO::Socket.bind(server_address) do |server|
-				server.listen(10)
-				
-				server.accept do |peer, address|
-					data = peer.read(512)
-					peer.write(data)
-				end
-			end
-		end
-		
-		result = example.run
-		
-		if result.is_a? Exception
-			result 
-		else
-			subject.run
-		end
-	end
-	
 	describe 'basic tcp server' do
 		it "should start server and send data" do
-			subject.async do
-				Async::IO::Socket.connect(server_address) do |client|
-					client.write(data)
-					expect(client.read(512)).to be == data
-				end
-			end
-		end
-	end
-	
-	describe 'non-blocking tcp connect' do
-		it "should start server and send data" do
-			subject.async do |task|
-				Async::IO::Socket.connect(server_address) do |client|
-					client.write(data)
-					expect(client.read(512)).to be == data
-				end
-			end
-		end
-		
-		it "can connect socket and read/write in a different task" do
-			socket = nil
-			
-			subject.async do |task|
-				socket = Async::IO::Socket.connect(server_address)
+			# Accept a single incoming connection and then finish.
+			server_task = reactor.async do |task|
+				server = Async::IO::TCPServer.new("localhost", 6788)
+				peer, address = server.accept
 				
-				# Stop the reactor once the connection was made.
-				subject.stop
-			end
-		
-			subject.run
-			
-			expect(socket).to_not be_nil
-			expect(socket).to be_kind_of Async::Wrapper
-			
-			subject.async do
-				socket.write(data)
+				data = peer.gets
+				peer.puts(data)
 				
-				expect(socket.read(512)).to be == data
+				peer.close
+				server.close
 			end
 			
-			subject.run
+			client = Async::IO::TCPSocket.new("localhost", 6788)
 			
-			socket.close
-		end
-		
-		it "can't use a socket in nested tasks" do
-			subject.async do |task|
-				socket = Async::IO::Socket.connect(server_address)
-				expect(socket).to be_kind_of Async::Wrapper
-				
-				expect do
-					subject.async do
-						socket.write(data)
-						# expect(socket.read(512)).to be == data
-					end
-				end.to_not raise_error
-				
-				socket.close
-			end
+			client.puts(data)
+			expect(client.gets).to be == data
+			
+			client.close
+			server_task.wait
 		end
 	end
 end

data/spec/async/io/udp_socket_spec.rb

@@ -20,54 +20,33 @@
 
 require 'async/io/udp_socket'
 
-RSpec.describe Async::Reactor do
-	include_context Async::RSpec::Leaks
+RSpec.describe Async::IO::UDPSocket do
+	include_context Async::RSpec::Reactor
 	
-	# Shared port for localhost network tests.
-	let(:server_address) {Async::IO::Address.udp("127.0.0.1", 6778)}
 	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
 	describe 'basic udp server' do
 		it "should echo data back to peer" do
-			subject.async do
-				Async::IO::Socket.bind(server_address) do |server|
-					packet, address = server.recvfrom(512)
-					
-					server.send(packet, 0, address)
-				end
+			reactor.async do
+				server = Async::IO::UDPSocket.new(Socket::AF_INET)
+				server.bind("127.0.0.1", 6778)
+				
+				packet, address = server.recvfrom(512)
+				server.send(packet, 0, address[3], address[1])
+				
+				server.close
 			end
 			
-			subject.async do
-				Async::IO::Socket.connect(server_address) do |client|
-					client.send(data)
-					response = client.recv(512)
-					
-					expect(response).to be == data
-				end
+			reactor.async do
+				client = Async::IO::UDPSocket.new(Socket::AF_INET)
+				client.connect("127.0.0.1", 6778)
+				
+				client.send(data, 0)
+				response = client.recv(512)
+				client.close
+				
+				expect(response).to be == data
 			end
-			
-			subject.run
-		end
-		
-		it "should use unconnected socket" do
-			subject.async do
-				Async::IO::Socket.bind(server_address) do |server|
-					packet, address = server.recvfrom(512)
-					
-					server.send(packet, 0, address)
-				end
-			end
-			
-			subject.async do
-				Async::IO::UDPSocket.wrap(server_address.afamily) do |client|
-					client.send(data, 0, server_address)
-					response, address = client.recvfrom(512)
-					
-					expect(response).to be == data
-				end
-			end
-			
-			subject.run
 		end
 	end
 end

data/spec/async/io/unix_socket_spec.rb

@@ -30,6 +30,10 @@ RSpec.describe Async::Reactor do
 		FileUtils.rm_f path
 	end
 	
+	after do
+		FileUtils.rm_f path
+	end
+	
 	describe 'basic unix socket' do
 		it "should echo data back to peer" do
 			subject.async do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-14 00:00:00.000000000 Z
+date: 2018-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -115,6 +115,8 @@ files:
 - spec/async/io/generic_spec.rb
 - spec/async/io/notification_spec.rb
 - spec/async/io/protocol/line_spec.rb
+- spec/async/io/socket/tcp_spec.rb
+- spec/async/io/socket/udp_spec.rb
 - spec/async/io/socket_spec.rb
 - spec/async/io/ssl_socket_spec.rb
 - spec/async/io/stream_spec.rb
@@ -154,6 +156,8 @@ test_files:
 - spec/async/io/generic_spec.rb
 - spec/async/io/notification_spec.rb
 - spec/async/io/protocol/line_spec.rb
+- spec/async/io/socket/tcp_spec.rb
+- spec/async/io/socket/udp_spec.rb
 - spec/async/io/socket_spec.rb
 - spec/async/io/ssl_socket_spec.rb
 - spec/async/io/stream_spec.rb