io-endpoint 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c10e7e5b154e1ad990982315ba03565d5e880f392eb404a696c63eb3c9240cb7
-  data.tar.gz: 37ebf4a7b0c0d7905c0e4b9d23373e1665f595637ab049163dafab7d7c9df535
+  metadata.gz: c519269d1e8459a607159be713100765c2e424f199a08cce97e1ba6c877b5b6a
+  data.tar.gz: ee2e142c5320d9412395c80098e669971b8956b43ad58252d52a85e2a97a5a97
 SHA512:
-  metadata.gz: f8446d2169e82a34b836edaaf76b4e13409202dc1f0cebf64c80f693728bfe4dcd133dddd2ee7fd932bbc13b45e3d37b8ab2a7b928b3a39629455cd1fd9e62bf
-  data.tar.gz: 0ca66dd6bffc9925e7e782d46234b61777d432df527b8595ed10d26655a2f4d30a0eb74e5cff54ae5ec31b21a3e94af79eb1609c546d9c2b552817937ef47adc
+  metadata.gz: 67ce6a415b998cd1d072a1faee146803f30de818666278846cbdf69f8f72fd8c30d0df371ec44747a2ea74a1fdd0d86f100e187ba15d17275ffbb335d29e6df5
+  data.tar.gz: 360a4f1ee5e162e71be467b0090e54eade25f141abde4452f6ba0e389def1398eaabfe5f76aaed4cbf333ba0c40334e014029d7fb76e13d09ff60f428ac63d9f

data/lib/io/endpoint/address_endpoint.rb

@@ -17,16 +17,17 @@ module IO::Endpoint
 		end
 		
 		def to_s
-			"\#<#{self.class} #{@address.inspect}>"
+			"\#<#{self.class} address=#{@address.inspect}>"
 		end
 		
 		attr :address
 		
 		# Bind a socket to the given address. If a block is given, the socket will be automatically closed when the block exits.
-		# @yield [Socket] the bound socket
-		# @return [Socket] the bound socket
+		# @yield {|socket| ...}	An optional block which will be passed the socket.
+		#   @parameter socket [Socket] The socket which has been bound.
+		# @return [Array(Socket)] the bound socket
 		def bind(wrapper = Wrapper.default, &block)
-			wrapper.bind(@address, **@options, &block)
+			[wrapper.bind(@address, **@options, &block)]
 		end
 		
 		# Connects a socket to the given address. If a block is given, the socket will be automatically closed when the block exits.

data/lib/io/endpoint/composite_endpoint.rb

@@ -13,7 +13,9 @@ module IO::Endpoint
 		end
 		
 		def each(&block)
-			@endpoints.each(&block)
+			@endpoints.each do |endpoint|
+				endpoint.each(&block)
+			end
 		end
 		
 		def connect(&block)
@@ -30,13 +32,17 @@ module IO::Endpoint
 		end
 		
 		def bind(&block)
-			@endpoints.map(&:bind)
+			if block_given?
+				@endpoints.each do |endpoint|
+					endpoint.bind(&block)
+				end
+			else
+				@endpoints.map(&:bind).flatten.compact
+			end
 		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

@@ -77,30 +77,15 @@ module IO::Endpoint
 					socket, address = server.accept
 					
 					Fiber.schedule do
-						yield accepted(socket), address
+						yield socket, address
 					end
 				end
 			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.
+		# 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.
 		#
 		# @param string [String] URI as string. Scheme will decide implementation used.
 		# @param options keyword arguments passed through to {#initialize}
@@ -112,13 +97,7 @@ module IO::Endpoint
 		def self.parse(string, **options)
 			uri = URI.parse(string)
 			
-			self.public_send(uri.scheme, uri.host, uri.port, **options)
-		end
-		
-		protected
-		
-		def accepted(socket)
-			socket
+			IO::Endpoint.public_send(uri.scheme, uri.host, uri.port, **options)
 		end
 	end
 end

data/lib/io/endpoint/host_endpoint.rb

@@ -19,25 +19,29 @@ 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
+			@specification[0]
+		end
+		
+		def service
+			@specification[1]
 		end
 		
 		# Try to connect to the given host by connecting to each address in sequence until a connection is made.
 		# @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 +59,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 +75,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'
+
+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)
-			wrappers = endpoint.bound do |server|
+		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)
@@ -22,7 +27,7 @@ module IO::Endpoint
 				server.close_on_exec = close_on_exec
 			end
 			
-			return self.new(endpoint, wrappers)
+			return self.new(endpoint, sockets)
 		end
 		
 		# Create a new `SharedEndpoint` by connecting to the given endpoint.
@@ -34,18 +39,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 +60,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

@@ -8,6 +8,38 @@ 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)
+		end
+	end
+end
+
 module IO::Endpoint
 	class SSLEndpoint < Generic
 		def initialize(endpoint, **options)
@@ -41,13 +73,13 @@ module IO::Endpoint
 			@options[:ssl_params]
 		end
 		
-		def build_context(context = OpenSSL::SSL::SSLContext.new)
+		def build_context(context = ::OpenSSL::SSL::SSLContext.new)
 			if params = self.params
 				context.set_params(params)
 			end
 			
-			context.setup
-			context.freeze
+			# context.setup
+			# context.freeze
 			
 			return context
 		end
@@ -62,10 +94,12 @@ module IO::Endpoint
 		def bind
 			if block_given?
 				@endpoint.bind do |server|
-					yield OpenSSL::SSL::SSLServer.new(server, context)
+					yield ::OpenSSL::SSL::SSLServer.new(server, context)
 				end
 			else
-				return OpenSSL::SSL::SSLServer.new(@endpoint.bind, context)
+				@endpoint.bind.map do |server|
+					::OpenSSL::SSL::SSLServer.new(server, context)
+				end
 			end
 		end
 		
@@ -73,7 +107,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, context)
 			
 			if hostname = self.hostname
 				socket.hostname = hostname
@@ -102,22 +136,15 @@ module IO::Endpoint
 				yield self.class.new(endpoint, **@options)
 			end
 		end
-		
-		protected
-		
-		def accepted(socket)
-			socket.accept
-			socket
-		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.3.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`.

data/readme.md

@@ -18,6 +18,14 @@ We welcome contributions to this project.
 4.  Push to the branch (`git push origin my-new-feature`).
 5.  Create new Pull Request.
 
+### Developer Certificate of Origin
+
+This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
+
+### Contributor Covenant
+
+This project is governed by the [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.
+
 ## See Also
 
   - [async-io](https://github.com/socketry/async-io) — Asynchronous IO primitives.

data.tar.gz.sig

@@ -1 +1,3 @@
-���m,�ԡ,��!FWp�$2@�A>���(�����d:y��h�7D��?�Wm�F'���}.uQ�}�ٛ����P��+[�o�1�ˏh2Z�Ճj�;*���,�X�$|�]�T6b�q����VC�m	�u����h�u�KeL����yi��\�O����p$,��
+(Z\��Q���^�;^Ȍ$���+��X� �t�e*9��rKg3�7�c$=]���z+��a�lt��X��^bM�G3���ma�ew����d��(#���v+e��B��͸K6�+��>|9��~��*^o[GM�1UT5Sv|"0
+�>���$i3���R�\��ziބg��-"�5,��E%�3n�p��3�;�a�	���9��|G��K֥ܺ�/���8@)]������9
+���^5Am��I����.	͈B�$^.�/8bH�r`�sYe@�&Xj���ku���M�.=��^�B
ڗ=Ʋ�)�������4�֑
f��eﶔ��c33r��~�|�W

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,50 +37,8 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-06-15 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: covered
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2023-12-28 00:00:00.000000000 Z
+dependencies: []
 description:
 email:
 executables: []
@@ -120,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Provides a separation of concerns interface for IO endpoints.