async-io 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b5507d72c8c7e07851a347dc15eacfbb51f06a03a50ef438af12bb889b28a8c
-  data.tar.gz: b53e91190155fad15b9a8097ec5243a8af5fc81623f4acb2e68f5d1591752868
+  metadata.gz: 96b8fa83be7fa357a0aa41a783fb890389940717f110a67df2bcac406c0283ad
+  data.tar.gz: cf5fde9ff0c2b09f84b00cb2732606c4fd622f6819024fe2a1c10a48fa6564bf
 SHA512:
-  metadata.gz: dbbf5038f8a3d9bed87b8d51a81a34b2c454cb79a80405a560c857d1cfab1ec49e8ca75363eec37f0e71ff3dc2c177b7394b8562a2b7a965c01e9a67af0134a9
-  data.tar.gz: 2885f7b39a0bed3e4091900768499d3c0837a82b19e7cd5fb7d8770655a6f678283b4d49af2f195666b4fb6ffd003c093167f3d6ec7ce2f37ecbae436469a596
+  metadata.gz: 1efa54e086e3f3753a224bb1e7e4cb6a5fa59d15f570af9c1d2f3969eef5dae5698c657c7976ead21070ddfb6b9a87c5fe88f10c6625bd469cf422e05a1c2247
+  data.tar.gz: 3fc8f33825173f68d076ac6246e5a570db472613dfec9c3f2f30edd6f0d6719dd303138b802300a2d155c4cf423550a7286596aa26112d2415f05d7c881ef8d5

data/examples/broken_ssl.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'openssl'
+
+server = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
+server.bind(Addrinfo.tcp('127.0.0.1', 4433))
+server.listen(128)
+
+ssl_server = OpenSSL::SSL::SSLServer.new(server, OpenSSL::SSL::SSLContext.new)
+
+puts ssl_server.addr
+
+# openssl/ssl.rb:234:in `addr': undefined method `addr' for #<Socket:fd 8> (NoMethodError)

data/lib/async/io/{wrap/tcp.rb → address.rb}

@@ -18,45 +18,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative '../socket'
+require 'socket'
 
 module Async
 	module IO
-		module Wrap
-			module TCPServer
-				def self.new(*args)
-					return ::TCPServer.new(*args) unless Task.current?
-					
-					case args.size
-					when 2
-						local_address = Async::IO::Address.tcp(*args)
-					when 1
-						local_address = Async::IO::Address.tcp("0.0.0.0", *args)
-					else
-						raise ArgumentError, "TCPServer.new([hostname], port)"
-					end
-					
-					return Async::IO::Socket.bind(local_address)
-				end
-			end
-			
-			module TCPSocket
-				def self.new(remote_host, remote_port, local_host=nil, local_port=nil)
-					return ::TCPSocket.new(remote_host, remote_port, local_host, local_port) unless Task.current?
-					
-					remote_address = Async::IO::Address.tcp(remote_host, remote_port)
-					
-					if local_host && local_port
-						local_address = Async::IO::Address.tcp(local_host, local_port)
-					end
-					
-					return Async::IO::Socket.connect(remote_address, local_address)
-				end
-				
-				def self.open(*args)
-					self.new(*args)
-				end
-			end
-		end
+		Address = Addrinfo
 	end
 end

data/lib/async/io/endpoint.rb

@@ -18,109 +18,92 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'address'
 require_relative 'socket'
 require 'uri'
 
 module Async
 	module IO
-		Address = Addrinfo
-		
-		class Endpoint < Struct.new(:specification, :options)
-			include Comparable
-			
-			class << self
-				def parse(string, **options)
-					uri = URI.parse(string)
-					self.send(uri.scheme, uri.host, uri.port, **options)
-				end
-				
-				# args: nodename, service, family, socktype, protocol, flags
-				def tcp(*args, **options)
-					args[3] = ::Socket::SOCK_STREAM
-					
-					HostEndpoint.new(args, **options)
-				end
+		class Endpoint
+			def self.parse(string, **options)
+				uri = URI.parse(string)
 				
-				def udp(*args, **options)
-					args[3] = ::Socket::SOCK_DGRAM
-					
-					HostEndpoint.new(args, **options)
-				end
-				
-				def unix(*args, **options)
-					AddressEndpoint.new(Address.unix(*args), **options)
-				end
+				self.send(uri.scheme, uri.host, uri.port, **options)
+			end
+			
+			# args: nodename, service, family, socktype, protocol, flags
+			def self.tcp(*args, **options)
+				args[3] = ::Socket::SOCK_STREAM
 				
-				def ssl(*args, **options)
-					SecureEndpoint.new(self.tcp(*args, **options), **options)
-				end
+				HostEndpoint.new(args, **options)
+			end
+			
+			def self.udp(*args, **options)
+				args[3] = ::Socket::SOCK_DGRAM
 				
-				# Generate a list of endpoints from an array.
-				def each(specifications, &block)
-					return to_enum(:each, specifications) unless block_given?
-					
-					specifications.each do |specification|
-						if specification.is_a? self
-							yield specification
-						elsif specification.is_a? Array
-							yield self.send(*specification)
-						elsif specification.is_a? String
-							yield self.parse(specification)
-						elsif specification.is_a? ::BasicSocket
-							yield SocketEndpoint.new(specification)
-						elsif specification.is_a? Generic
-							yield Endpoint.new(specification)
-						else
-							raise ArgumentError.new("Not sure how to convert #{specification} to endpoint!")
-						end
-					end
-				end
+				HostEndpoint.new(args, **options)
 			end
 			
-			def initialize(specification, **options)
-				super(specification, options)
+			def self.unix(*args, **options)
+				AddressEndpoint.new(Address.unix(*args), **options)
 			end
 			
-			def bind
-				yield specification
+			def self.ssl(*args, **options)
+				SecureEndpoint.new(self.tcp(*args, **options), **options)
+			end
+			
+			def self.try_convert(specification)
+				if specification.is_a? self
+					specification
+				elsif specification.is_a? Array
+					self.send(*specification)
+				elsif specification.is_a? String
+					self.parse(specification)
+				elsif specification.is_a? ::BasicSocket
+					SocketEndpoint.new(specification)
+				elsif specification.is_a? Generic
+					Endpoint.new(specification)
+				else
+					raise ArgumentError.new("Not sure how to convert #{specification} to endpoint!")
+				end
 			end
 			
-			def accept(&block)
-				backlog = self.options.fetch(:backlog, Socket::SOMAXCONN)
+			# Generate a list of endpoint from an array.
+			def self.each(specifications, &block)
+				return to_enum(:each, specifications) unless block_given?
 				
+				specifications.each do |specification|
+					yield try_convert(specification)
+				end
+			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				yield self
+			end
+			
+			def accept(backlog = Socket::SOMAXCONN, &block)
 				bind do |server|
 					server.listen(backlog)
+					
 					server.accept_each(&block)
 				end
 			end
-			
-			def connect
-				yield specification
-			end
 		end
 		
 		class HostEndpoint < Endpoint
-			def bind(&block)
-				task = Task.current
-				tasks = []
-				
-				task.annotate("binding to #{specification.inspect}")
-				
-				Addrinfo.foreach(*specification).each do |address|
-					tasks << task.async do
-						Socket.bind(address, **options, &block)
-					end
-				end
-				
-				tasks.each(&:wait)
+			def initialize(specification, **options)
+				@specification = specification
+				@options = options
 			end
 			
 			def connect(&block)
 				last_error = nil
 				
-				Addrinfo.foreach(*specification).each do |address|
+				Addrinfo.foreach(*@specification).each do |address|
 					begin
-						return Socket.connect(address, &block)
+						return Socket.connect(address, **@options, &block)
 					rescue
 						last_error = $!
 					end
@@ -128,41 +111,60 @@ module Async
 				
 				raise last_error
 			end
-		end
-		
-		# This class will open and close the socket automatically.
-		class AddressEndpoint < Endpoint
+			
 			def bind(&block)
-				Socket.bind(specification, **options, &block)
+				Addrinfo.foreach(*@specification) do |address|
+					Socket.bind(address, **@options, &block)
+				end
 			end
 			
-			def connect(&block)
-				Socket.connect(specification, &block)
+			def each
+				return to_enum unless block_given?
+				
+				Addrinfo.foreach(*@specification).each do |address|
+					yield AddressEndpoint.new(address, **@options)
+				end
 			end
 		end
 		
-		# This class doesn't exert ownership over the specified socket, wraps a native ::IO.
-		class SocketEndpoint < Endpoint
+		# This class will open and close the socket automatically.
+		class AddressEndpoint < Endpoint
+			def initialize(address, **options)
+				@address = address
+				@options = options
+			end
+			
+			attr :address
+			attr :options
+			
 			def bind(&block)
-				yield Socket.new(specification)
+				Socket.bind(@address, **@options, &block)
 			end
 			
 			def connect(&block)
-				yield Async::IO.try_convert(specification)
+				Socket.connect(@address, **@options, &block)
 			end
 		end
 		
 		class SecureEndpoint < Endpoint
+			def initialize(endpoint, **options)
+				@endpoint = endpoint
+				@options = options
+			end
+			
+			attr :endpoint
+			attr :options
+			
 			def hostname
-				options[:hostname]
+				@options[:hostname]
 			end
 			
 			def params
-				options[:ssl_params]
+				@options[:ssl_params]
 			end
 			
 			def context
-				if context = options[:ssl_context]
+				if context = @options[:ssl_context]
 					if params = self.params
 						context = context.dup
 						context.set_params(params)
@@ -178,24 +180,47 @@ module Async
 				return context
 			end
 			
-			def bind(&block)
-				specification.bind do |server|
+			def bind
+				@endpoint.bind do |server|
 					yield SSLServer.new(server, context)
 				end
 			end
 			
 			def connect(&block)
-				specification.connect do |socket|
-					ssl_socket = SSLSocket.connect_socket(socket, context)
-					
-					# Used for SNI:
-					if hostname = self.hostname
-						ssl_socket.hostname = hostname
-					end
-					
-					ssl_socket.connect
-					
-					yield ssl_socket
+				SSLSocket.connect(@endpoint.connect, context, hostname, &block)
+			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				@endpoint.each do |endpoint|
+					yield self.class.new(endpoint, @options)
+				end
+			end
+		end
+		
+		# This class doesn't exert ownership over the specified socket, wraps a native ::IO.
+		class SocketEndpoint < Endpoint
+			def initialize(socket)
+				# This socket should already be in the required state.
+				@socket = Async::IO.try_convert(socket)
+			end
+			
+			attr :socket
+			
+			def bind(&block)
+				if block_given?
+					yield @socket
+				else
+					return @socket
+				end
+			end
+			
+			def connect(&block)
+				if block_given?
+					yield @socket
+				else
+					return @socket
 				end
 			end
 		end

data/lib/async/io/generic.rb

@@ -25,7 +25,11 @@ module Async
 	module IO
 		# Convert a Ruby ::IO object to a wrapped instance:
 		def self.try_convert(io, &block)
-			Generic::WRAPPERS[io.class].wrap(io, &block)
+			if wrapper_class = Generic::WRAPPERS[io.class]
+				wrapper_class.new(io, &block)
+			else
+				raise ArgumentError.new("Unsure how to wrap #{io.class}!")
+			end
 		end
 		
 		# Represents an asynchronous IO within a reactor.
@@ -79,15 +83,39 @@ module Async
 				end
 			end
 			
-			wraps ::IO, :external_encoding, :internal_encoding, :autoclose?, :autoclose=, :pid, :stat, :binmode, :flush, :set_encoding, :to_io, :to_i, :reopen, :fileno, :fsync, :fdatasync, :sync, :sync=, :tell, :seek, :rewind, :pos, :pos=, :eof, :eof?, :close_on_exec?, :close_on_exec=, :closed?, :close_read, :close_write, :isatty, :tty?, :binmode?, :sysseek, :advise, :ioctl, :fcntl
+			wraps ::IO, :external_encoding, :internal_encoding, :autoclose?, :autoclose=, :pid, :stat, :binmode, :flush, :set_encoding, :to_io, :to_i, :reopen, :fileno, :fsync, :fdatasync, :sync, :sync=, :tell, :seek, :rewind, :pos, :pos=, :eof, :eof?, :close_on_exec?, :close_on_exec=, :closed?, :close_read, :close_write, :isatty, :tty?, :binmode?, :sysseek, :advise, :ioctl, :fcntl, :nread, :ready?, :pread, :pwrite, :pathconf
 			
 			# @example
 			#   data = io.read(512)
 			wrap_blocking_method :read, :read_nonblock
+			alias sysread read
+			alias readpartial read
 			
 			# @example
 			#   io.write("Hello World")
 			wrap_blocking_method :write, :write_nonblock
+			alias syswrite write
+			alias << write
+			
+			def wait(timeout = nil, mode = :read)
+				case mode
+				when :read
+					wait_readable(timeout)
+				when :write
+					wait_writable(timeout)
+				else
+					wait_any(:rw, timeout)
+				end
+			end
+			
+			def nonblock
+				true
+			end
+			alias nonblock= nonblock
+			
+			def nonblock?
+				true
+			end
 			
 			protected
 			

data/lib/async/io/protocol/line.rb

@@ -29,6 +29,10 @@ module Async
 					@eol = eol
 				end
 				
+				def close
+					@stream.close
+				end
+				
 				attr :stream
 				attr :eol
 				

data/lib/async/io/socket.rb

@@ -24,13 +24,11 @@ require_relative 'generic'
 module Async
 	module IO
 		class BasicSocket < Generic
-			wraps ::BasicSocket, :setsockopt, :connect_address, :local_address, :remote_address, :do_not_reverse_lookup, :do_not_reverse_lookup=, :shutdown, :getsockopt, :getsockname, :getpeername, :getpeereid
+			wraps ::BasicSocket, :setsockopt, :connect_address, :close_read, :close_write, :local_address, :remote_address, :do_not_reverse_lookup, :do_not_reverse_lookup=, :shutdown, :getsockopt, :getsockname, :getpeername, :getpeereid
 			
 			wrap_blocking_method :recv, :recv_nonblock
 			wrap_blocking_method :recvmsg, :recvmsg_nonblock
 			
-			wrap_blocking_method :recvfrom, :recvfrom_nonblock
-			
 			wrap_blocking_method :sendmsg, :sendmsg_nonblock
 			wrap_blocking_method :send, :sendmsg_nonblock, invert: false
 			
@@ -39,25 +37,7 @@ module Async
 			end
 		end
 		
-		module ServerSocket
-			def accept(task: Task.current)
-				peer, address = async_send(:accept_nonblock)
-				
-				wrapper = Socket.new(peer, self.reactor)
-				
-				return wrapper, address unless block_given?
-				
-				task.async do |task|
-					task.annotate "incoming connection #{address.inspect}"
-					
-					begin
-						yield wrapper, address
-					ensure
-						wrapper.close
-					end
-				end
-			end
-			
+		module Server
 			def accept_each(task: Task.current)
 				task.annotate "accepting connections #{self.local_address.inspect}"
 				
@@ -72,8 +52,9 @@ module Async
 		class Socket < BasicSocket
 			wraps ::Socket, :bind, :ipv6only!, :listen
 			
+			wrap_blocking_method :recvfrom, :recvfrom_nonblock
+			
 			include ::Socket::Constants
-			include ServerSocket
 			
 			def connect(*args)
 				begin
@@ -83,6 +64,28 @@ module Async
 				end
 			end
 			
+			alias connect_nonblock connect
+			
+			def accept(task: Task.current)
+				peer, address = async_send(:accept_nonblock)
+				wrapper = Socket.new(peer, task.reactor)
+				
+				return wrapper, address unless block_given?
+				
+				task.async do |task|
+					task.annotate "incoming connection #{address.inspect}"
+					
+					begin
+						yield wrapper, address
+					ensure
+						wrapper.close
+					end
+				end
+			end
+			
+			alias accept_nonblock accept
+			alias sysaccept accept
+			
 			def self.build(*args, task: Task.current)
 				socket = wrapped_klass.new(*args)
 				
@@ -101,11 +104,11 @@ module Async
 			# @param remote_address [Addrinfo] The remote address to connect to.
 			# @param local_address [Addrinfo] The local address to bind to before connecting.
 			# @option protcol [Integer] The socket protocol to use.
-			def self.connect(remote_address, local_address = nil, task: Task.current, **options)
+			def self.connect(remote_address, local_address = nil, reuse_port: false, task: Task.current, **options)
 				task.annotate "connecting to #{remote_address.inspect}"
 				
 				wrapper = build(remote_address.afamily, remote_address.socktype, remote_address.protocol, **options) do |socket|
-					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
+					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, reuse_port)
 					
 					if local_address
 						socket.bind(local_address.to_sockaddr)
@@ -138,8 +141,6 @@ module Async
 			# @option protocol [Integer] The socket protocol to use.
 			# @option reuse_port [Boolean] Allow this port to be bound in multiple processes.
 			def self.bind(local_address, protocol: 0, reuse_port: false, task: Task.current, **options, &block)
-				task.annotate "binding to #{local_address.inspect}"
-				
 				wrapper = build(local_address.afamily, local_address.socktype, protocol, **options) do |socket|
 					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
 					socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, true) if reuse_port
@@ -148,10 +149,14 @@ module Async
 				
 				return wrapper unless block_given?
 				
-				begin
-					yield wrapper, task
-				ensure
-					wrapper.close
+				task.async do
+					task.annotate "binding to #{local_address.inspect}"
+					
+					begin
+						yield wrapper, task
+					ensure
+						wrapper.close
+					end
 				end
 			end
 			
@@ -163,10 +168,18 @@ module Async
 					server.accept_each(task: task, &block)
 				end
 			end
+			
+			include Server
+			
+			def self.pair(*args)
+				::Socket.pair(*args).map(&self.method(:new))
+			end
 		end
 		
 		class IPSocket < BasicSocket
 			wraps ::IPSocket, :addr, :peeraddr
+			
+			wrap_blocking_method :recvfrom, :recvfrom_nonblock
 		end
 	end
 end