io-endpoint 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c519269d1e8459a607159be713100765c2e424f199a08cce97e1ba6c877b5b6a
-  data.tar.gz: ee2e142c5320d9412395c80098e669971b8956b43ad58252d52a85e2a97a5a97
+  metadata.gz: 204ed5172990d0df3a5d02e63b8e75d8caaf161808fea4e99b67f0d422241cc6
+  data.tar.gz: 7ba7e7052949565c4cb327076c493db15d6f3057493f93d4210ec5ac5bc7808b
 SHA512:
-  metadata.gz: 67ce6a415b998cd1d072a1faee146803f30de818666278846cbdf69f8f72fd8c30d0df371ec44747a2ea74a1fdd0d86f100e187ba15d17275ffbb335d29e6df5
-  data.tar.gz: 360a4f1ee5e162e71be467b0090e54eade25f141abde4452f6ba0e389def1398eaabfe5f76aaed4cbf333ba0c40334e014029d7fb76e13d09ff60f428ac63d9f
+  metadata.gz: 12aa8f963bc0787de988e9efcf80fbff38a857e8130e663ed8c329402048ab9e1940dcc2637f17de2f77f43d9222914808b5ec89e91420ed0d07475dbabc9d0e
+  data.tar.gz: ce830974878205da1f7e91378af0bdb05f1a4017cc60715c2dca5607573992f38d97712e6b879d99ab31db95a5b12c40ab3df959da12cc56f4b2189dd37b314e

data/lib/io/connected.rb

@@ -0,0 +1,27 @@
+require 'socket'
+
+class IO
+	def connected?
+		!closed?
+	end
+end
+
+class Socket
+	def connected?
+		# Is it likely that the socket is still connected?
+		# May return false positive, but won't return false negative.
+		return false unless super
+		
+		# 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, MSG_PEEK, exception: false)
+		
+		# No data was available - newer Ruby can return nil instead of empty string:
+		return false if result.nil?
+		
+		# Either there was some data available, or we can wait to see if there is data avaialble.
+		return !result.empty? || result == :wait_readable
+	rescue Errno::ECONNRESET
+		# This might be thrown by recv_nonblock.
+		return false
+	end
+end

data/lib/io/endpoint/bound_endpoint.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+require_relative 'composite_endpoint'
+require_relative 'address_endpoint'
+
+module IO::Endpoint
+	class BoundEndpoint < Generic
+		def self.bound(endpoint, backlog: Socket::SOMAXCONN, close_on_exec: false)
+			sockets = endpoint.bind
+			
+			sockets.each do |server|
+				# This is somewhat optional. We want to have a generic interface as much as possible so that users of this interface can just call it without knowing a lot of internal details. Therefore, we ignore errors here if it's because the underlying socket does not support the operation.
+				begin
+					server.listen(backlog)
+				rescue Errno::EOPNOTSUPP
+					# Ignore.
+				end
+				
+				server.close_on_exec = close_on_exec
+			end
+			
+			return self.new(endpoint, sockets, **endpoint.options)
+		end
+		
+		def initialize(endpoint, sockets, **options)
+			super(**options)
+			
+			@endpoint = endpoint
+			@sockets = sockets
+		end
+		
+		attr :endpoint
+		attr :sockets
+		
+		# A endpoint for the local end of the bound socket.
+		# @returns [CompositeEndpoint] A composite endpoint for the local end of the bound socket.
+		def local_address_endpoint(**options)
+			endpoints = @sockets.map do |socket|
+				AddressEndpoint.new(socket.to_io.local_address, **options)
+			end
+			
+			return CompositeEndpoint.new(endpoints)
+		end
+		
+		# A endpoint for the remote end of the bound socket.
+		# @returns [CompositeEndpoint] A composite endpoint for the remote end of the bound socket.
+		def remote_address_endpoint(**options)
+			endpoints = @sockets.map do |wrapper|
+				AddressEndpoint.new(socket.to_io.remote_address, **options)
+			end
+			
+			return CompositeEndpoint.new(endpoints)
+		end
+		
+		def close
+			@sockets.each(&:close)
+			@sockets.clear
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@sockets.size} bound sockets for #{@endpoint}>"
+		end
+		
+		def bind(wrapper = Wrapper.default, &block)
+			@sockets.map do |server|
+				if block_given?
+					wrapper.async do
+						yield server
+					end
+				else
+					server.dup
+				end
+			end
+		end
+	end
+	
+	class Generic
+		def bound(**options)
+			BoundEndpoint.bound(self, **options)
+		end
+	end
+end

data/lib/io/endpoint/composite_endpoint.rb

@@ -6,6 +6,7 @@
 require_relative 'generic'
 
 module IO::Endpoint
+	# A composite endpoint is a collection of endpoints that are used in order.
 	class CompositeEndpoint < Generic
 		def initialize(endpoints, **options)
 			super(**options)
@@ -18,12 +19,12 @@ module IO::Endpoint
 			end
 		end
 		
-		def connect(&block)
+		def connect(wrapper = Wrapper.default, &block)
 			last_error = nil
 			
 			@endpoints.each do |endpoint|
 				begin
-					return endpoint.connect(&block)
+					return endpoint.connect(wrapper, &block)
 				rescue => last_error
 				end
 			end
@@ -31,7 +32,7 @@ module IO::Endpoint
 			raise last_error
 		end
 		
-		def bind(&block)
+		def bind(wrapper = Wrapper.default, &block)
 			if block_given?
 				@endpoints.each do |endpoint|
 					endpoint.bind(&block)

data/lib/io/endpoint/connected_endpoint.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+require_relative 'composite_endpoint'
+require_relative 'socket_endpoint'
+
+require 'openssl'
+
+module IO::Endpoint
+	class ConnectedEndpoint < Generic
+		def self.connected(endpoint, close_on_exec: false)
+			socket = endpoint.connect
+			
+			socket.close_on_exec = close_on_exec
+			
+			return self.new(endpoint, socket, **endpoint.options)
+		end
+		
+		def initialize(endpoint, socket, **options)
+			super(**options)
+			
+			@endpoint = endpoint
+			@socket = socket
+		end
+		
+		attr :endpoint
+		attr :socket
+		
+		# A endpoint for the local end of the bound socket.
+		# @returns [AddressEndpoint] A endpoint for the local end of the connected socket.
+		def local_address_endpoint(**options)
+			AddressEndpoint.new(socket.to_io.local_address, **options)
+		end
+		
+		# A endpoint for the remote end of the bound socket.
+		# @returns [AddressEndpoint] A endpoint for the remote end of the connected socket.
+		def remote_address_endpoint(**options)
+			AddressEndpoint.new(socket.to_io.remote_address, **options)
+		end
+		
+		def connect(wrapper = Wrapper.default, &block)
+			if block_given?
+				yield @socket
+			else
+				return @socket.dup
+			end
+		end
+		
+		def close
+			if @socket
+				@socket.close
+				@socket = nil
+			end
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@socket} connected for #{@endpoint}>"
+		end
+	end
+		
+	class Generic
+		def connected(**options)
+			ConnectedEndpoint.connected(self, **options)
+		end
+	end
+end

data/lib/io/endpoint/generic.rb

@@ -59,31 +59,41 @@ module IO::Endpoint
 			@options[:local_address]
 		end
 		
-		# Endpoints sometimes have multiple paths.
-		# @yield [Endpoint] Enumerate all discrete paths as endpoints.
+		# Bind a socket to the given address. If a block is given, the socket will be automatically closed when the block exits.
+		# @parameter wrapper [Wrapper] The wrapper to use for binding.
+		# @yields {|socket| ...}	An optional block which will be passed the socket.
+		#   @parameter socket [Socket] The socket which has been bound.
+		# @returns [Array(Socket)] the bound socket
+		def bind(wrapper = Wrapper.default, &block)
+			raise NotImplementedError
+		end
+		
+		# Connects a socket to the given address. If a block is given, the socket will be automatically closed when the block exits.
+		# @parameter wrapper [Wrapper] The wrapper to use for connecting.
+		# @return [Socket] the connected socket
+		def connect(wrapper = Wrapper.default, &block)
+			raise NotImplementedError
+		end
+		
+		# Bind and accept connections on the given address.
+		# @parameter wrapper [Wrapper] The wrapper to use for accepting connections.
+		# @yields [Socket] The accepted socket.
+		def accept(wrapper = Wrapper.default, &block)
+			bind(wrapper) do |server|
+				wrapper.accept(server, **@options, &block)
+			end
+		end
+		
+		# Enumerate all discrete paths as endpoints.
+		# @yields {|endpoint| ...} A block which will be passed each endpoint.
+		# 	@parameter endpoint [Endpoint] The endpoint.
 		def each
 			return to_enum unless block_given?
 			
 			yield self
 		end
 		
-		# Accept connections from the specified endpoint.
-		# @param backlog [Integer] the number of connections to listen for.
-		def accept(backlog: Socket::SOMAXCONN, &block)
-			bind do |server|
-				server.listen(backlog) if backlog
-				
-				while true
-					socket, address = server.accept
-					
-					Fiber.schedule do
-						yield socket, address
-					end
-				end
-			end
-		end
-		
-		# Create an Endpoint instance by URI scheme. The host and port of the URI will be passed to the Endpoint factory method, along with any options.\
+		# Create an Endpoint instance by URI scheme. The host and port of the URI will be passed to the Endpoint factory method, along with any options.
 		#
 		# You should not use untrusted input as it may execute arbitrary code.
 		#

data/lib/io/endpoint/shared_endpoint.rb

@@ -1,136 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2023, by Samuel Williams.
+# Copyright, 2024, by Samuel Williams.
 
-require_relative 'generic'
-require_relative 'composite_endpoint'
-require_relative 'socket_endpoint'
-
-require 'openssl'
-
-module IO::Endpoint
-	# Pre-connect and pre-bind sockets so that it can be used between processes.
-	class SharedEndpoint < Generic
-		# Create a new `SharedEndpoint` by binding to the given endpoint.
-		def self.bound(endpoint, backlog: Socket::SOMAXCONN, close_on_exec: false, **options)
-			sockets = endpoint.bind(**options)
-			
-			sockets.each do |server|
-				# This is somewhat optional. We want to have a generic interface as much as possible so that users of this interface can just call it without knowing a lot of internal details. Therefore, we ignore errors here if it's because the underlying socket does not support the operation.
-				begin
-					server.listen(backlog)
-				rescue Errno::EOPNOTSUPP
-					# Ignore.
-				end
-				
-				server.close_on_exec = close_on_exec
-			end
-			
-			return self.new(endpoint, sockets)
-		end
-		
-		# Create a new `SharedEndpoint` by connecting to the given endpoint.
-		def self.connected(endpoint, close_on_exec: false)
-			wrapper = endpoint.connect
-			
-			wrapper.close_on_exec = close_on_exec
-			
-			return self.new(endpoint, [wrapper])
-		end
-		
-		def initialize(endpoint, sockets, **options)
-			super(**options)
-			
-			raise TypeError, "sockets must be an Array" unless sockets.is_a?(Array)
-			
-			@endpoint = endpoint
-			@sockets = sockets
-		end
-		
-		attr :endpoint
-		attr :sockets
-		
-		def local_address_endpoint(**options)
-			endpoints = @sockets.map do |wrapper|
-				AddressEndpoint.new(wrapper.to_io.local_address)
-			end
-			
-			return CompositeEndpoint.new(endpoints, **options)
-		end
-		
-		def remote_address_endpoint(**options)
-			endpoints = @sockets.map do |wrapper|
-				AddressEndpoint.new(wrapper.to_io.remote_address)
-			end
-			
-			return CompositeEndpoint.new(endpoints, **options)
-		end
-		
-		# Close all the internal sockets.
-		def close
-			@sockets.each(&:close)
-			@sockets.clear
-		end
-		
-		def each(&block)
-			return to_enum unless block_given?
-			
-			@sockets.each do |socket|
-				yield SocketEndpoint.new(socket.dup)
-			end
-		end
-		
-		def bind(wrapper = Wrapper.default, &block)
-			@sockets.each.map do |server|
-				server = server.dup
-				
-				if block_given?
-					wrapper.async do
-						begin
-							yield server
-						ensure
-							server.close
-						end
-					end
-				else
-					server
-				end
-			end
-		end
-		
-		def connect(wrapper = Wrapper.default, &block)
-			@sockets.each do |socket|
-				socket = socket.dup
-				
-				return socket unless block_given?
-				
-				begin
-					return yield(socket)
-				ensure
-					socket.close
-				end
-			end
-		end
-		
-		def accept(**options, &block)
-			bind do |server|
-				server.accept(&block)
-			end
-		end
-		
-		def to_s
-			"\#<#{self.class} #{@sockets.size} descriptors for #{@endpoint}>"
-		end
-	end
-	
-	class Generic
-		def bound(**options)
-			SharedEndpoint.bound(self, **options)
-		end
-		
-		def connected(**options)
-			SharedEndpoint.connected(self, **options)
-		end
-	end
-end
+require_relative 'bound_endpoint'
+require_relative 'connected_endpoint'

data/lib/io/endpoint/ssl_endpoint.rb

@@ -8,34 +8,52 @@ require_relative 'generic'
 
 require 'openssl'
 
-module OpenSSL::SSL::SocketForwarder
-	unless method_defined?(:close_on_exec=)
-		def close_on_exec=(value)
-			to_io.close_on_exec = value
-		end
-	end
-	
-	unless method_defined?(:close_on_exec)
-		def local_address
-			to_io.local_address
-		end
-	end
-	
-	unless method_defined?(:wait)
-		def wait(*arguments)
-			to_io.wait(*arguments)
-		end
-	end
-	
-	unless method_defined?(:wait_readable)
-		def wait_readable(*arguments)
-			to_io.wait_readable(*arguments)
-		end
-	end
-	
-	unless method_defined?(:wait_writable)
-		def wait_writable(*arguments)
-			to_io.wait_writable(*arguments)
+module OpenSSL
+	module SSL
+		module SocketForwarder
+			unless method_defined?(:close_on_exec=)
+				def close_on_exec=(value)
+					to_io.close_on_exec = value
+				end
+			end
+			
+			unless method_defined?(:close_on_exec)
+				def local_address
+					to_io.local_address
+				end
+			end
+			
+			unless method_defined?(:wait)
+				def wait(*arguments)
+					to_io.wait(*arguments)
+				end
+			end
+			
+			unless method_defined?(:wait_readable)
+				def wait_readable(*arguments)
+					to_io.wait_readable(*arguments)
+				end
+			end
+			
+			unless method_defined?(:wait_writable)
+				def wait_writable(*arguments)
+					to_io.wait_writable(*arguments)
+				end
+			end
+			
+			if IO.method_defined?(:timeout)
+				unless method_defined?(:timeout)
+					def timeout
+						to_io.timeout
+					end
+				end
+				
+				unless method_defined?(:timeout=)
+					def timeout=(value)
+						to_io.timeout = value
+					end
+				end
+			end
 		end
 	end
 end
@@ -91,14 +109,14 @@ module IO::Endpoint
 		# Connect to the underlying endpoint and establish a SSL connection.
 		# @yield [Socket] the socket which is being connected
 		# @return [Socket] the connected socket
-		def bind
+		def bind(*arguments, **options, &block)
 			if block_given?
-				@endpoint.bind do |server|
-					yield ::OpenSSL::SSL::SSLServer.new(server, context)
+				@endpoint.bind(*arguments, **options) do |server|
+					yield ::OpenSSL::SSL::SSLServer.new(server, self.context)
 				end
 			else
-				@endpoint.bind.map do |server|
-					::OpenSSL::SSL::SSLServer.new(server, context)
+				@endpoint.bind(*arguments, **options).map do |server|
+					::OpenSSL::SSL::SSLServer.new(server, self.context)
 				end
 			end
 		end
@@ -107,7 +125,7 @@ module IO::Endpoint
 		# @yield [Socket] the socket which is being connected
 		# @return [Socket] the connected socket
 		def connect(&block)
-			socket = ::OpenSSL::SSL::SSLSocket.new(@endpoint.connect, context)
+			socket = ::OpenSSL::SSL::SSLSocket.new(@endpoint.connect, self.context)
 			
 			if hostname = self.hostname
 				socket.hostname = hostname

data/lib/io/endpoint/version.rb

@@ -5,6 +5,6 @@
 
 class IO
 	module Endpoint
-		VERSION = "0.3.0"
+		VERSION = "0.5.0"
 	end
 end

data/lib/io/endpoint/wrapper.rb

@@ -30,7 +30,6 @@ module IO::Endpoint
 			# On Darwin, sometimes occurs when the connection is not yet fully formed. Empirically, TCP_NODELAY is enabled despite this result.
 		rescue Errno::EOPNOTSUPP
 			# Some platforms may simply not support the operation.
-			# Console.logger.warn(self) {"Unable to set sync=#{value}!"}
 		rescue Errno::ENOPROTOOPT
 			# It may not be supported by the protocol (e.g. UDP). ¯\_(ツ)_/¯
 		end
@@ -39,50 +38,30 @@ module IO::Endpoint
 			raise NotImplementedError
 		end
 		
-		# Build and wrap the underlying io.
-		# @option reuse_port [Boolean] Allow this port to be bound in multiple processes.
-		# @option reuse_address [Boolean] Allow this port to be bound in multiple processes.
-		# @option linger [Boolean] Wait for data to be sent before closing the socket.
-		# @option buffered [Boolean] Enable or disable Nagle's algorithm for TCP sockets.
-		def build(*arguments, timeout: nil, reuse_address: true, reuse_port: nil, linger: nil, buffered: false)
-			socket = ::Socket.new(*arguments)
-			
-			# Set the timeout:
-			if timeout
-				set_timeout(socket, timeout)
-			end
-			
-			if reuse_address
-				socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
-			end
-			
-			if reuse_port
-				socket.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
-			end
-			
-			if linger
-				socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
-			end
-			
-			if buffered == false
-				set_buffered(socket, buffered)
-			end
-			
-			yield socket if block_given?
-			
-			return socket
-		rescue
-			socket&.close
-			raise
-		end
-		
 		# Establish a connection to a given `remote_address`.
 		# @example
 		#  socket = Async::IO::Socket.connect(Async::IO::Address.tcp("8.8.8.8", 53))
-		# @param remote_address [Address] The remote address to connect to.
-		# @option local_address [Address] The local address to bind to before connecting.
-		def connect(remote_address, local_address: nil, **options)
-			socket = build(remote_address.afamily, remote_address.socktype, remote_address.protocol, **options) do |socket|
+		# @parameter remote_address [Address] The remote address to connect to.
+		# @parameter linger [Boolean] Wait for data to be sent before closing the socket.
+		# @parameter local_address [Address] The local address to bind to before connecting.
+		def connect(remote_address, local_address: nil, linger: nil, timeout: nil, buffered: false, **options)
+			socket = nil
+			
+			begin
+				socket = ::Socket.new(remote_address.afamily, remote_address.socktype, remote_address.protocol)
+				
+				if linger
+					socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
+				end
+				
+				if buffered == false
+					set_buffered(socket, buffered)
+				end
+				
+				if timeout
+					set_timeout(socket, timeout)
+				end
+				
 				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.
@@ -91,6 +70,9 @@ module IO::Endpoint
 					
 					socket.bind(local_address.to_sockaddr)
 				end
+			rescue
+				socket&.close
+				raise
 			end
 			
 			begin
@@ -109,14 +91,48 @@ module IO::Endpoint
 			end
 		end
 		
+		# JRuby requires ServerSocket
+		if defined?(::ServerSocket)
+			ServerSocket = ::ServerSocket
+		else
+			ServerSocket = ::Socket
+		end
+		
 		# Bind to a local address.
 		# @example
 		#  socket = Async::IO::Socket.bind(Async::IO::Address.tcp("0.0.0.0", 9090))
-		# @param local_address [Address] The local address to bind to.
-		# @option protocol [Integer] The socket protocol to use.
-		def bind(local_address, protocol: 0, **options, &block)
-			socket = build(local_address.afamily, local_address.socktype, protocol, **options) do |socket|
+		# @parameter local_address [Address] The local address to bind to.
+		# @parameter reuse_port [Boolean] Allow this port to be bound in multiple processes.
+		# @parameter reuse_address [Boolean] Allow this port to be bound in multiple processes.
+		# @parameter linger [Boolean] Wait for data to be sent before closing the socket.
+		# @parameter protocol [Integer] The socket protocol to use.
+		def bind(local_address, protocol: 0, reuse_address: true, reuse_port: nil, linger: nil, bound_timeout: nil, **options, &block)
+			socket = nil
+			
+			begin
+				socket = ServerSocket.new(local_address.afamily, local_address.socktype, protocol)
+				
+				if reuse_address
+					socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+				end
+				
+				if reuse_port
+					socket.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
+				end
+				
+				if linger
+					socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
+				end
+				
+				# Set the timeout:
+				if bound_timeout
+					set_timeout(socket, bound_timeout)
+				end
+				
 				socket.bind(local_address.to_sockaddr)
+			rescue
+				socket&.close
+				raise
 			end
 			
 			return socket unless block_given?
@@ -131,14 +147,14 @@ module IO::Endpoint
 		end
 		
 		# Bind to a local address and accept connections in a loop.
-		def accept(*arguments, backlog: SOMAXCONN, **options, &block)
-			bind(*arguments, **options) do |server|
-				server.listen(backlog) if backlog
+		def accept(server, timeout: nil, &block)
+			while true
+				socket, address = server.accept
+				
+				set_timeout(socket, timeout) if timeout != false
 				
 				async do
-					while true
-						server.accept(&block)
-					end
+					yield socket, address
 				end
 			end
 		end
@@ -146,20 +162,26 @@ module IO::Endpoint
 	
 	class ThreadWrapper < Wrapper
 		def async(&block)
-			Thread.new(&block)
+			::Thread.new(&block)
 		end
 	end
 	
 	class FiberWrapper < Wrapper
 		def async(&block)
-			Fiber.schedule(&block)
+			::Fiber.schedule(&block)
 		end
 	end
 	
-	def Wrapper.default
-		if Fiber.scheduler
-			FiberWrapper.new
-		else
+	if Fiber.respond_to?(:scheduler)
+		def Wrapper.default
+			if Fiber.scheduler
+				FiberWrapper.new
+			else
+				ThreadWrapper.new
+			end
+		end
+	else
+		def Wrapper.default
 			ThreadWrapper.new
 		end
 	end

data/lib/io/endpoint.rb

@@ -5,6 +5,7 @@
 
 require_relative "endpoint/version"
 require_relative "endpoint/generic"
+require_relative "endpoint/shared_endpoint"
 
 module IO::Endpoint
 	def self.file_descriptor_limit

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,7 +37,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-12-28 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -45,9 +45,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/io/connected.rb
 - lib/io/endpoint.rb
 - lib/io/endpoint/address_endpoint.rb
+- lib/io/endpoint/bound_endpoint.rb
 - lib/io/endpoint/composite_endpoint.rb
+- lib/io/endpoint/connected_endpoint.rb
 - lib/io/endpoint/generic.rb
 - lib/io/endpoint/host_endpoint.rb
 - lib/io/endpoint/shared_endpoint.rb