io-endpoint 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c10e7e5b154e1ad990982315ba03565d5e880f392eb404a696c63eb3c9240cb7
-  data.tar.gz: 37ebf4a7b0c0d7905c0e4b9d23373e1665f595637ab049163dafab7d7c9df535
+  metadata.gz: cbc52bab1fde2330c0b971cf987db15dc5865f9f3ce72a130121db97d00671ba
+  data.tar.gz: a7503b553781fd02e86a082015e82f1c5af24b5fa3a735dbdeb7415498901da8
 SHA512:
-  metadata.gz: f8446d2169e82a34b836edaaf76b4e13409202dc1f0cebf64c80f693728bfe4dcd133dddd2ee7fd932bbc13b45e3d37b8ab2a7b928b3a39629455cd1fd9e62bf
-  data.tar.gz: 0ca66dd6bffc9925e7e782d46234b61777d432df527b8595ed10d26655a2f4d30a0eb74e5cff54ae5ec31b21a3e94af79eb1609c546d9c2b552817937ef47adc
+  metadata.gz: 40343e43190bd695c0152fb5ec45946efe281245eb033eacae1eeda9291c37b4bc975dffac6db9d007b060bf9d375cdf3beed31f70a81f344c65f17b6772bff4
+  data.tar.gz: 40a34915f55409d96fddfaea9925c71c5bcddee36c0f6a6cc001982ec1e884a7694a3f4d89aad534353df3c182eb9b94f618619fdec9a77fc36d723620b5af09

data/lib/io/endpoint/address_endpoint.rb

@@ -17,7 +17,7 @@ module IO::Endpoint
 		end
 		
 		def to_s
-			"\#<#{self.class} #{@address.inspect}>"
+			"\#<#{self.class} address=#{@address.inspect}>"
 		end
 		
 		attr :address

data/lib/io/endpoint/composite_endpoint.rb

@@ -34,9 +34,7 @@ module IO::Endpoint
 		end
 	end
 	
-	class Endpoint
-		def self.composite(*endpoints, **options)
-			CompositeEndpoint.new(endpoints, **options)
-		end
+	def self.composite(*endpoints, **options)
+		CompositeEndpoint.new(endpoints, **options)
 	end
 end

data/lib/io/endpoint/generic.rb

@@ -83,23 +83,6 @@ module IO::Endpoint
 			end
 		end
 		
-		# Map all endpoints by invoking `#bind`.
-		# @yield the bound wrapper.
-		def bound
-			wrappers = []
-			
-			self.each do |endpoint|
-				wrapper = endpoint.bind
-				wrappers << wrapper
-				
-				yield wrapper
-			end
-			
-			return wrappers
-		ensure
-			wrappers.each(&:close) if $!
-		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.
 		#
 		# @param string [String] URI as string. Scheme will decide implementation used.

data/lib/io/endpoint/host_endpoint.rb

@@ -19,9 +19,8 @@ module IO::Endpoint
 			"\#<#{self.class} name=#{nodename.inspect} service=#{service.inspect} family=#{family.inspect} type=#{socktype.inspect} protocol=#{protocol.inspect} flags=#{flags.inspect}>"
 		end
 		
-		def address
-			@specification
-		end
+		
+		attr :specification
 		
 		def hostname
 			@specification.first
@@ -31,13 +30,14 @@ module IO::Endpoint
 		# @yield [Socket] the socket which is being connected, may be invoked more than once
 		# @return [Socket] the connected socket
 		# @raise if no connection could complete successfully
-		def connect
+		def connect(wrapper = Wrapper.default, &block)
 			last_error = nil
 			
 			Addrinfo.foreach(*@specification) do |address|
 				begin
-					socket = Socket.connect(address, **@options)
+					socket = wrapper.connect(@address, **@options)
 				rescue Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::EAGAIN => last_error
+					# Try again unless if possible, otherwise raise...
 				else
 					return socket unless block_given?
 					
@@ -55,9 +55,9 @@ module IO::Endpoint
 		# Invokes the given block for every address which can be bound to.
 		# @yield [Socket] the bound socket
 		# @return [Array<Socket>] an array of bound sockets
-		def bind(&block)
+		def bind(wrapper = Wrapper.default, &block)
 			Addrinfo.foreach(*@specification).map do |address|
-				Socket.bind(address, **@options, &block)
+				wrapper.bind(address, **@options, &block)
 			end
 		end
 		
@@ -71,23 +71,23 @@ module IO::Endpoint
 		end
 	end
 	
-	# @param args nodename, service, family, socktype, protocol, flags. `socktype` will be set to Socket::SOCK_STREAM.
+	# @param arguments nodename, service, family, socktype, protocol, flags. `socktype` will be set to Socket::SOCK_STREAM.
 	# @param options keyword arguments passed on to {HostEndpoint#initialize}
 	#
 	# @return [HostEndpoint]
-	def self.tcp(*args, **options)
-		args[3] = ::Socket::SOCK_STREAM
+	def self.tcp(*arguments, **options)
+		arguments[3] = ::Socket::SOCK_STREAM
 		
-		HostEndpoint.new(args, **options)
+		HostEndpoint.new(arguments, **options)
 	end
 
-	# @param args nodename, service, family, socktype, protocol, flags. `socktype` will be set to Socket::SOCK_DGRAM.
+	# @param arguments nodename, service, family, socktype, protocol, flags. `socktype` will be set to Socket::SOCK_DGRAM.
 	# @param options keyword arguments passed on to {HostEndpoint#initialize}
 	#
 	# @return [HostEndpoint]
-	def self.udp(*args, **options)
-		args[3] = ::Socket::SOCK_DGRAM
+	def self.udp(*arguments, **options)
+		arguments[3] = ::Socket::SOCK_DGRAM
 		
-		HostEndpoint.new(args, **options)
+		HostEndpoint.new(arguments, **options)
 	end
 end

data/lib/io/endpoint/shared_endpoint.rb

@@ -5,13 +5,18 @@
 
 require_relative 'generic'
 require_relative 'composite_endpoint'
+require_relative 'socket_endpoint'
 
 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)
-			wrappers = endpoint.bound do |server|
+		def self.bound(endpoint, backlog: Socket::SOMAXCONN, close_on_exec: false, **options)
+			sockets = []
+			
+			endpoint.each do |server_endpoint|
+				server = server_endpoint.bind(**options)
+				
 				# 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)
@@ -20,9 +25,11 @@ module IO::Endpoint
 				end
 				
 				server.close_on_exec = close_on_exec
+				
+				sockets << server
 			end
 			
-			return self.new(endpoint, wrappers)
+			return self.new(endpoint, sockets)
 		end
 		
 		# Create a new `SharedEndpoint` by connecting to the given endpoint.
@@ -34,18 +41,20 @@ module IO::Endpoint
 			return self.new(endpoint, [wrapper])
 		end
 		
-		def initialize(endpoint, wrappers, **options)
+		def initialize(endpoint, sockets, **options)
 			super(**options)
 			
+			raise TypeError, "sockets must be an Array" unless sockets.is_a?(Array)
+			
 			@endpoint = endpoint
-			@wrappers = wrappers
+			@sockets = sockets
 		end
 		
 		attr :endpoint
-		attr :wrappers
+		attr :sockets
 		
 		def local_address_endpoint(**options)
-			endpoints = @wrappers.map do |wrapper|
+			endpoints = @sockets.map do |wrapper|
 				AddressEndpoint.new(wrapper.to_io.local_address)
 			end
 			
@@ -53,51 +62,77 @@ module IO::Endpoint
 		end
 		
 		def remote_address_endpoint(**options)
-			endpoints = @wrappers.map do |wrapper|
+			endpoints = @sockets.map do |wrapper|
 				AddressEndpoint.new(wrapper.to_io.remote_address)
 			end
 			
 			return CompositeEndpoint.new(endpoints, **options)
 		end
 		
-		# Close all the internal wrappers.
+		# Close all the internal sockets.
 		def close
-			@wrappers.each(&:close)
-			@wrappers.clear
+			@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
-			@wrappers.each do |server|
+		def bind(wrapper = Wrapper.default, &block)
+			@sockets.each.map do |server|
 				server = server.dup
 				
-				begin
-					yield server
-				ensure
-					server.close
+				if block_given?
+					wrapper.async do
+						begin
+							yield server
+						ensure
+							server.close
+						end
+					end
+				else
+					server
 				end
 			end
 		end
 		
-		def connect
-			@wrappers.each do |peer|
-				peer = peer.dup
+		def connect(wrapper = Wrapper.default, &block)
+			@sockets.each do |socket|
+				socket = socket.dup
+				
+				return socket unless block_given?
 				
 				begin
-					yield peer
+					return yield(socket)
 				ensure
-					peer.close
+					socket.close
 				end
 			end
 		end
 		
-		def accept(backlog = nil, &block)
+		def accept(**options, &block)
 			bind do |server|
-				server.accept_each(&block)
+				server.accept(&block)
 			end
 		end
 		
 		def to_s
-			"\#<#{self.class} #{@wrappers.size} descriptors for #{@endpoint}>"
+			"\#<#{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

data/lib/io/endpoint/ssl_endpoint.rb

@@ -111,13 +111,13 @@ module IO::Endpoint
 		end
 	end
 
-	# @param args
+	# @param arguments
 	# @param ssl_context [OpenSSL::SSL::SSLContext, nil]
 	# @param hostname [String, nil]
 	# @param options keyword arguments passed through to {Endpoint.tcp}
 	#
 	# @return [SSLEndpoint]
-	def self.ssl(*args, ssl_context: nil, hostname: nil, **options)
-		SSLEndpoint.new(self.tcp(*args, **options), ssl_context: ssl_context, hostname: hostname)
+	def self.ssl(*arguments, ssl_context: nil, hostname: nil, **options)
+		SSLEndpoint.new(self.tcp(*arguments, **options), ssl_context: ssl_context, hostname: hostname)
 	end
 end

data/lib/io/endpoint/unix_endpoint.rb

@@ -27,14 +27,16 @@ module IO::Endpoint
 			end
 		rescue Errno::ECONNREFUSED
 			return false
+		rescue Errno::ENOENT
+			return false
 		end
 		
 		def bind(&block)
 			super
 		rescue Errno::EADDRINUSE
 			# If you encounter EADDRINUSE from `bind()`, you can check if the socket is actually accepting connections by attempting to `connect()` to it. If the socket is still bound by an active process, the connection will succeed. Otherwise, it should be safe to `unlink()` the path and try again.
-			if !bound? && File.exist?(@path)
-				File.unlink(@path)
+			if !bound?
+				File.unlink(@path) rescue nil
 				retry
 			else
 				raise

data/lib/io/endpoint/version.rb

@@ -5,6 +5,6 @@
 
 class IO
 	module Endpoint
-		VERSION = "0.1.0"
+		VERSION = "0.2.0"
 	end
 end

data/lib/io/endpoint/wrapper.rb

@@ -9,16 +9,32 @@ module IO::Endpoint
 	class Wrapper
 		include ::Socket::Constants
 		
-		if $stdin.respond_to?(:timeout=)
-			def self.set_timeout(io, timeout)
+		if IO.method_defined?(:timeout=)
+			def set_timeout(io, timeout)
 				io.timeout = timeout
 			end
 		else
-			def self.set_timeout(io, timeout)
+			def set_timeout(io, timeout)
 				warn "IO#timeout= not supported on this platform."
 			end
 		end
 		
+		def set_buffered(socket, buffered)
+			case buffered
+			when true
+				socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 0)
+			when false
+				socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+			end
+		rescue Errno::EINVAL
+			# 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
+		
 		def async
 			raise NotImplementedError
 		end
@@ -26,7 +42,9 @@ module IO::Endpoint
 		# 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.
-		def build(*arguments, timeout: nil, reuse_address: true, reuse_port: nil, linger: nil)
+		# @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:
@@ -43,7 +61,11 @@ module IO::Endpoint
 			end
 			
 			if linger
-				socket.setsockopt(SOL_SOCKET, SO_LINGER, linger)
+				socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
+			end
+			
+			if buffered == false
+				set_buffered(socket, buffered)
 			end
 			
 			yield socket if block_given?
@@ -51,6 +73,7 @@ module IO::Endpoint
 			return socket
 		rescue
 			socket&.close
+			raise
 		end
 		
 		# Establish a connection to a given `remote_address`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,7 +37,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-06-15 00:00:00.000000000 Z
+date: 2023-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bake
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Provides a separation of concerns interface for IO endpoints.