async-io 1.4.0 → 1.5.0

data/lib/async/io/ssl_socket.rb

@@ -28,11 +28,42 @@ module Async
 		
 		# Asynchronous TCP socket wrapper.
 		class SSLSocket < Generic
-			wraps ::OpenSSL::SSL::SSLSocket, :alpn_protocol, :cert, :cipher, :client_ca, :hostname=, :npn_protocol, :peer_cert, :peer_cert_chain, :pending, :post_connection_check, :session, :session=, :session_reused?, :ssl_version, :state
+			wraps ::OpenSSL::SSL::SSLSocket, :alpn_protocol, :cert, :cipher, :client_ca, :close, :context, :hostname, :hostname=, :npn_protocol, :peer_cert, :peer_cert_chain, :pending, :post_connection_check, :session, :session=, :session_reused?, :ssl_version, :state, :sync_close, :sync_close=, :sysclose, :verify_result, :tmp_key
 			
 			wrap_blocking_method :accept, :accept_nonblock
 			wrap_blocking_method :connect, :connect_nonblock
 			
+			alias syswrite write
+			alias sysread read
+			
+			# It's hard to know what #to_io / #io should do. So, they are omitted.
+			
+			def self.connect(socket, context, hostname = nil, &block)
+				client = self.wrap(socket, context)
+				
+				# Used for SNI:
+				if hostname
+					client.hostname = hostname
+				end
+				
+				begin
+					client.connect
+				rescue
+					# If the connection fails (e.g. certificates are invalid), the caller never sees the socket, so we close it and raise the exception up the chain.
+					client.close
+					
+					raise
+				end
+				
+				return client unless block_given?
+				
+				begin
+					yield client
+				ensure
+					client.close
+				end
+			end
+			
 			def local_address
 				@io.to_io.local_address
 			end
@@ -41,9 +72,8 @@ module Async
 				@io.to_io.remote_address
 			end
 			
-			# This method/implementation might change in the future, don't depend on it :)
-			def self.connect_socket(socket, context)
-				io = wrapped_klass.new(socket.to_io, context)
+			def self.wrap(socket, context)
+				io = @wrapped_klass.new(socket.to_io, context)
 				
 				# This ensures that when the internal IO is closed, it also closes the internal socket:
 				io.sync_close = true
@@ -52,6 +82,7 @@ module Async
 			end
 		end
 		
+		# We reimplement this from scratch because the native implementation doesn't expose the underlying server/context that we need to implement non-blocking accept.
 		class SSLServer
 			extend Forwardable
 			
@@ -60,13 +91,11 @@ module Async
 				@context = context
 			end
 			
-			def_delegators :@server, :local_address, :setsockopt, :getsockopt
+			def_delegators :@server, :local_address, :setsockopt, :getsockopt, :close
 			
 			attr :server
 			attr :context
 			
-			include ServerSocket
-			
 			def listen(*args)
 				@server.listen(*args)
 			end
@@ -74,7 +103,7 @@ module Async
 			def accept(task: Task.current)
 				peer, address = @server.accept
 				
-				wrapper = SSLSocket.connect_socket(peer, @context)
+				wrapper = SSLSocket.wrap(peer, @context)
 				
 				return wrapper, address unless block_given?
 				
@@ -82,6 +111,7 @@ module Async
 					task.annotate "accepting secure connection #{address}"
 					
 					begin
+						# You want to do this in a nested async task or you might suffer from head-of-line blocking.
 						wrapper.accept
 						
 						yield wrapper, address
@@ -92,6 +122,8 @@ module Async
 					end
 				end
 			end
+			
+			include Server
 		end
 	end
 end

data/lib/async/io/standard.rb

@@ -0,0 +1,29 @@
+# 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_relative 'generic'
+
+module Async
+	module IO
+		STDIN = Generic.new($stdin)
+		STDOUT = Generic.new($stdout)
+		STDERR = Generic.new($stderr)
+	end
+end

data/lib/async/io/tcp_socket.rb

@@ -49,6 +49,10 @@ module Async
 				@buffer = Stream.new(self)
 			end
 			
+			class << self
+				alias open new
+			end
+			
 			attr :buffer
 			
 			def_delegators :@buffer, :gets, :puts, :flush
@@ -72,8 +76,19 @@ module Async
 				
 				wrapper = TCPSocket.new(peer)
 				
-				return wrapper, address
+				return wrapper, address unless block_given?
+				
+				begin
+					yield wrapper, address
+				ensure
+					wrapper.close
+				end
 			end
+			
+			alias accept_nonblock accept
+			alias sysaccept accept
+			
+			include Server
 		end
 	end
 end

data/lib/async/io/unix_socket.rb

@@ -23,14 +23,12 @@ require_relative 'socket'
 module Async
 	module IO
 		class UNIXSocket < BasicSocket
-			wraps ::UNIXSocket, :path, :addr, :peeraddr
-			
-			# TODO Currently unimplemented.
-			# , :send_io, :recv_io
+			# `send_io`, `recv_io` and `recvfrom` may block but no non-blocking implementation available.
+			wraps ::UNIXSocket, :path, :addr, :peeraddr, :send_io, :recv_io, :recvfrom
 		end
 		
 		class UNIXServer < UNIXSocket
-			wraps ::UNIXServer
+			wraps ::UNIXServer, :listen
 			
 			def accept
 				peer = async_send(:accept_nonblock)
@@ -44,6 +42,9 @@ module Async
 					wrapper.close
 				end
 			end
+			
+			alias sysaccept accept
+			alias accept_nonblock accept
 		end
 	end
 end

data/lib/async/io/version.rb

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

data/spec/async/io/c10k_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe "echo client/server" do
 	# sudo sysctl -w net.inet.ip.portrange.hifirst=10000
 	# Probably due to the use of select.
 	
-	let(:repeats) {10000}
+	let(:repeats) {RUBY_PLATFORM =~ /darwin/ ? 100 : 10000}
 	let(:server_address) {Async::IO::Address.tcp('0.0.0.0', 10102)}
 	
 	def echo_server(server_address)

data/spec/async/io/endpoint_spec.rb

@@ -18,8 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-# This seems to break rbx
-# require 'async/io/endpoint'
+require 'async/io/endpoint'
+require 'async/io/tcp_socket'
 
 RSpec.describe Async::IO::Endpoint do
 	include_context Async::RSpec::Reactor
@@ -35,7 +35,7 @@ RSpec.describe Async::IO::Endpoint do
 	describe Async::IO::SocketEndpoint.new(TCPServer.new('0.0.0.0', 1234)) do
 		it "should bind to given socket" do
 			subject.bind do |server|
-				expect(server.io).to be == subject.specification
+				expect(server).to be == subject.socket
 			end
 		end
 	end

data/spec/async/io/generic_examples.rb

@@ -0,0 +1,24 @@
+
+RSpec.shared_examples Async::IO::Generic do |ignore_methods|
+	let(:instance_methods) {described_class.wrapped_klass.instance_methods(false) - (ignore_methods || [])}
+	let(:wrapped_instance_methods) {described_class.instance_methods}
+	
+	it "should wrap a class" do
+		expect(described_class.wrapped_klass).to_not be_nil
+	end
+	
+	it "should wrap underlying instance methods" do
+		expect(wrapped_instance_methods.sort).to include(*instance_methods.sort)
+	end
+	
+	# This needs to be reviewed in more detail.
+	#
+	# let(:singleton_methods) {described_class.wrapped_klass.singleton_methods(false)}
+	# let(:wrapped_singleton_methods) {described_class.singleton_methods(false)}
+	# 
+	# it "should wrap underlying class methods" do
+	# 	singleton_methods.each do |method|
+	# 		expect(wrapped_singleton_methods).to include(method)
+	# 	end
+	# end
+end

data/spec/async/io/generic_spec.rb

@@ -20,9 +20,15 @@
 
 require 'async/io'
 
+require_relative 'generic_examples'
+
 RSpec.describe Async::IO::Generic do
 	include_context Async::RSpec::Reactor
 	
+	it_should_behave_like Async::IO::Generic, [
+		:bytes, :chars, :codepoints, :each, :each_byte, :each_char, :each_codepoint, :each_line, :getbyte, :getc, :gets, :lineno, :lineno=, :lines, :print, :printf, :putc, :puts, :readbyte, :readchar, :readline, :readlines, :ungetbyte, :ungetc
+	]
+	
 	let(:pipe) {IO.pipe}
 	let(:input) {Async::IO::Generic.new(pipe.first)}
 	let(:output) {Async::IO::Generic.new(pipe.last)}

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

@@ -20,16 +20,16 @@
 
 require 'async/io/tcp_socket'
 
-RSpec.describe Async::Reactor do
-	include_context Async::RSpec::Leaks
+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(:data) {"The quick brown fox jumped over the lazy dog."}
 	
-	around(:each) do |example|
+	let!(:server_task) do
 		# Accept a single incoming connection and then finish.
-		subject.async do |task|
+		reactor.async do |task|
 			Async::IO::Socket.bind(server_address) do |server|
 				server.listen(10)
 				
@@ -39,21 +39,14 @@ RSpec.describe Async::Reactor do
 				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
+			reactor.async do
 				Async::IO::Socket.connect(server_address) do |client|
 					client.write(data)
+					
 					expect(client.read(512)).to be == data
 				end
 			end
@@ -62,53 +55,29 @@ RSpec.describe Async::Reactor do
 	
 	describe 'non-blocking tcp connect' do
 		it "should start server and send data" do
-			subject.async do |task|
+			reactor.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|
+			reactor.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_not be_nil
 				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
+				reactor.async do
+					socket.write(data)
+					
+					expect(socket.read(512)).to be == data
+					
+					socket.close
+				end
 			end
 		end
 	end

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

@@ -20,24 +20,26 @@
 
 require 'async/io/udp_socket'
 
-RSpec.describe Async::Reactor do
-	include_context Async::RSpec::Leaks
+RSpec.describe Async::IO::Socket 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."}
 	
+	let!(:server_task) do
+		reactor.async do
+			Async::IO::Socket.bind(server_address) do |server|
+				packet, address = server.recvfrom(512)
+				
+				server.send(packet, 0, address)
+			end
+		end
+	end
+	
 	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
+			reactor.async do
 				Async::IO::Socket.connect(server_address) do |client|
 					client.send(data)
 					response = client.recv(512)
@@ -45,20 +47,10 @@ RSpec.describe Async::Reactor do
 					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
+			reactor.async do
 				Async::IO::UDPSocket.wrap(server_address.afamily) do |client|
 					client.send(data, 0, server_address)
 					response, address = client.recvfrom(512)
@@ -66,8 +58,6 @@ RSpec.describe Async::Reactor do
 					expect(response).to be == data
 				end
 			end
-			
-			subject.run
 		end
 	end
 end