io-endpoint 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10203d535af830bf9ff71034262b5851ec323024a9de4db527f061cb1cd76102
-  data.tar.gz: b150061a0414c379afb7fb5f2c142767afc5ed1822e5b106b78ece023d1cf459
+  metadata.gz: 5bcb63287c1be90c51846285208bb0ddb82d3e1da5ccf53c698a8b75af180bf7
+  data.tar.gz: 2ef636802b1a1d76183f661857a75805efc98b78bc1d396b2e27658ceb49c9dc
 SHA512:
-  metadata.gz: 82930d72359dee91627b19c771f79c9f2c6cc43dc93b9514a372a4568d1fb92c653ff2da1403c8519eddc4470dc14ef2356abe41cd202fba80bc35ba10e2d053
-  data.tar.gz: 556e87a95eb514e643a3e6bb40468ac851cceea5da6fb6f72db37767dca18882bb9b63e61e05d2e69629a1e4eef1859c3a2b3e0797b36e0e4eb1202684f8d44c
+  metadata.gz: 95a1be9bd523f623bd07a6d0c8c9cfb46f10d2224697488ecbbafce04cadbca50a4ae9ce8437c2efe4c990161e68efa3110cb05f29bef4bf652f68a0ca606a53
+  data.tar.gz: e05ec8d424c92d0f7edbffd8f6ec6faef93a82b086e6fd8447eeed0b9a22b9ea7eb92a8359785d888556906cdd02076b5ca161c3a7b0bec597fe0167102c7c6e

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)

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,22 +59,40 @@ 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(wrapper = Wrapper.default, *arguments, **options, &block)
-			bind(wrapper, *arguments, **options) do |server|
-				wrapper.accept(server, &block)
-			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.
 		#
 		# 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)
-			socket = endpoint.connect
-			
-			socket.close_on_exec = close_on_exec
-			
-			return self.new(endpoint, [socket])
-		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, **options)
-			end
-			
-			return CompositeEndpoint.new(endpoints)
-		end
-		
-		def remote_address_endpoint(**options)
-			endpoints = @sockets.map do |wrapper|
-				AddressEndpoint.new(wrapper.to_io.remote_address, **options)
-			end
-			
-			return CompositeEndpoint.new(endpoints)
-		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(wrapper = Wrapper.default, &block)
-			bind(wrapper) do |server|
-				wrapper.accept(server, &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

data/lib/io/endpoint/version.rb

@@ -5,6 +5,6 @@
 
 class IO
 	module Endpoint
-		VERSION = "0.4.0"
+		VERSION = "0.6.0"
 	end
 end

data/lib/io/endpoint/wrapper.rb

@@ -38,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.
@@ -90,6 +70,9 @@ module IO::Endpoint
 					
 					socket.bind(local_address.to_sockaddr)
 				end
+			rescue
+				socket&.close
+				raise
 			end
 			
 			begin
@@ -108,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?
@@ -130,11 +147,17 @@ module IO::Endpoint
 		end
 		
 		# Bind to a local address and accept connections in a loop.
-		def accept(server, timeout: server.timeout, &block)
+		def accept(server, timeout: nil, linger: nil, **options, &block)
 			while true
 				socket, address = server.accept
 				
-				socket.timeout = timeout if timeout != false
+				if linger
+					socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
+				end
+				
+				if timeout
+					set_timeout(socket, timeout)
+				end
 				
 				async do
 					yield socket, address
@@ -145,20 +168,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.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,7 +37,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-01-26 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -48,7 +48,9 @@ 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
@@ -79,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.5
 signing_key:
 specification_version: 4
 summary: Provides a separation of concerns interface for IO endpoints.