io-endpoint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c10e7e5b154e1ad990982315ba03565d5e880f392eb404a696c63eb3c9240cb7
+  data.tar.gz: 37ebf4a7b0c0d7905c0e4b9d23373e1665f595637ab049163dafab7d7c9df535
+SHA512:
+  metadata.gz: f8446d2169e82a34b836edaaf76b4e13409202dc1f0cebf64c80f693728bfe4dcd133dddd2ee7fd932bbc13b45e3d37b8ab2a7b928b3a39629455cd1fd9e62bf
+  data.tar.gz: 0ca66dd6bffc9925e7e782d46234b61777d432df527b8595ed10d26655a2f4d30a0eb74e5cff54ae5ec31b21a3e94af79eb1609c546d9c2b552817937ef47adc

checksums.yaml.gz.sig

@@ -0,0 +1,3 @@
+lй��\�YAuQV[�tW��?]���k�J�bW%�O� ����dv]�����ɹD�
+$�,��5(E��i&jB��2:B�T>B,Pd���`4���UZs
�ؽ�|.�O?�]�< g��?1�|�@�
+̓��i�L�������iS�Rk�4����G��o��r'�

data/lib/io/endpoint/address_endpoint.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require 'socket'
+
+require_relative 'generic'
+require_relative 'wrapper'
+
+module IO::Endpoint
+	class AddressEndpoint < Generic
+		def initialize(address, **options)
+			super(**options)
+			
+			@address = address
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@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
+		def bind(wrapper = Wrapper.default, &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.
+		# @return [Socket] the connected socket
+		def connect(wrapper = Wrapper.default, &block)
+			wrapper.connect(@address, **@options, &block)
+		end
+	end
+end

data/lib/io/endpoint/composite_endpoint.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+
+module IO::Endpoint
+	class CompositeEndpoint < Generic
+		def initialize(endpoints, **options)
+			super(**options)
+			@endpoints = endpoints
+		end
+		
+		def each(&block)
+			@endpoints.each(&block)
+		end
+		
+		def connect(&block)
+			last_error = nil
+			
+			@endpoints.each do |endpoint|
+				begin
+					return endpoint.connect(&block)
+				rescue => last_error
+				end
+			end
+			
+			raise last_error
+		end
+		
+		def bind(&block)
+			@endpoints.map(&:bind)
+		end
+	end
+	
+	class Endpoint
+		def self.composite(*endpoints, **options)
+			CompositeEndpoint.new(endpoints, **options)
+		end
+	end
+end

data/lib/io/endpoint/generic.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+# require_relative 'address'
+require 'uri'
+require 'socket'
+
+module IO::Endpoint
+	Address = Addrinfo
+	
+	# Endpoints represent a way of connecting or binding to an address.
+	class Generic
+		def initialize(**options)
+			@options = options.freeze
+		end
+		
+		def with(**options)
+			dup = self.dup
+			
+			dup.options = @options.merge(options)
+			
+			return dup
+		end
+		
+		attr_accessor :options
+		
+		# @return [String] The hostname of the bound socket.
+		def hostname
+			@options[:hostname]
+		end
+		
+		# If `SO_REUSEPORT` is enabled on a socket, the socket can be successfully bound even if there are existing sockets bound to the same address, as long as all prior bound sockets also had `SO_REUSEPORT` set before they were bound.
+		# @return [Boolean, nil] The value for `SO_REUSEPORT`.
+		def reuse_port?
+			@options[:reuse_port]
+		end
+		
+		# If `SO_REUSEADDR` is enabled on a socket prior to binding it, the socket can be successfully bound unless there is a conflict with another socket bound to exactly the same combination of source address and port. Additionally, when set, binding a socket to the address of an existing socket in `TIME_WAIT` is not an error.
+		# @return [Boolean] The value for `SO_REUSEADDR`.
+		def reuse_address?
+			@options[:reuse_address]
+		end
+		
+		# Controls SO_LINGER. The amount of time the socket will stay in the `TIME_WAIT` state after being closed.
+		# @return [Integer, nil] The value for SO_LINGER.
+		def linger
+			@options[:linger]
+		end
+		
+		# @return [Numeric] The default timeout for socket operations.
+		def timeout
+			@options[:timeout]
+		end
+		
+		# @return [Address] the address to bind to before connecting.
+		def local_address
+			@options[:local_address]
+		end
+		
+		# Endpoints sometimes have multiple paths.
+		# @yield [Endpoint] Enumerate all discrete paths as endpoints.
+		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 accepted(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.
+		#
+		# @param string [String] URI as string. Scheme will decide implementation used.
+		# @param options keyword arguments passed through to {#initialize}
+		#
+		# @see Endpoint.ssl ssl - invoked when parsing a URL with the ssl scheme "ssl://127.0.0.1"
+		# @see Endpoint.tcp tcp - invoked when parsing a URL with the tcp scheme: "tcp://127.0.0.1"
+		# @see Endpoint.udp udp - invoked when parsing a URL with the udp scheme: "udp://127.0.0.1"
+		# @see Endpoint.unix unix - invoked when parsing a URL with the unix scheme: "unix://127.0.0.1"
+		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
+		end
+	end
+end

data/lib/io/endpoint/host_endpoint.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'address_endpoint'
+
+module IO::Endpoint
+	class HostEndpoint < Generic
+		def initialize(specification, **options)
+			super(**options)
+			
+			@specification = specification
+		end
+		
+		def to_s
+			nodename, service, family, socktype, protocol, flags = @specification
+			
+			"\#<#{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
+		
+		def hostname
+			@specification.first
+		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
+			last_error = nil
+			
+			Addrinfo.foreach(*@specification) do |address|
+				begin
+					socket = Socket.connect(address, **@options)
+				rescue Errno::ECONNREFUSED, Errno::ENETUNREACH, Errno::EAGAIN => last_error
+				else
+					return socket unless block_given?
+					
+					begin
+						return yield(socket)
+					ensure
+						socket.close
+					end
+				end
+			end
+			
+			raise last_error
+		end
+		
+		# 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)
+			Addrinfo.foreach(*@specification).map do |address|
+				Socket.bind(address, **@options, &block)
+			end
+		end
+		
+		# @yield [AddressEndpoint] address endpoints by resolving the given host specification
+		def each
+			return to_enum unless block_given?
+			
+			Addrinfo.foreach(*@specification) do |address|
+				yield AddressEndpoint.new(address, **@options)
+			end
+		end
+	end
+	
+	# @param args 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
+		
+		HostEndpoint.new(args, **options)
+	end
+
+	# @param args 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
+		
+		HostEndpoint.new(args, **options)
+	end
+end

data/lib/io/endpoint/shared_endpoint.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+require_relative 'composite_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|
+				# 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, wrappers)
+		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, wrappers, **options)
+			super(**options)
+			
+			@endpoint = endpoint
+			@wrappers = wrappers
+		end
+		
+		attr :endpoint
+		attr :wrappers
+		
+		def local_address_endpoint(**options)
+			endpoints = @wrappers.map do |wrapper|
+				AddressEndpoint.new(wrapper.to_io.local_address)
+			end
+			
+			return CompositeEndpoint.new(endpoints, **options)
+		end
+		
+		def remote_address_endpoint(**options)
+			endpoints = @wrappers.map do |wrapper|
+				AddressEndpoint.new(wrapper.to_io.remote_address)
+			end
+			
+			return CompositeEndpoint.new(endpoints, **options)
+		end
+		
+		# Close all the internal wrappers.
+		def close
+			@wrappers.each(&:close)
+			@wrappers.clear
+		end
+		
+		def bind
+			@wrappers.each do |server|
+				server = server.dup
+				
+				begin
+					yield server
+				ensure
+					server.close
+				end
+			end
+		end
+		
+		def connect
+			@wrappers.each do |peer|
+				peer = peer.dup
+				
+				begin
+					yield peer
+				ensure
+					peer.close
+				end
+			end
+		end
+		
+		def accept(backlog = nil, &block)
+			bind do |server|
+				server.accept_each(&block)
+			end
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@wrappers.size} descriptors for #{@endpoint}>"
+		end
+	end
+end

data/lib/io/endpoint/socket_endpoint.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+
+module IO::Endpoint
+	# This class doesn't exert ownership over the specified socket, wraps a native ::IO.
+	class SocketEndpoint < Generic
+		def initialize(socket, **options)
+			super(**options)
+			
+			@socket = socket
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@socket.inspect}>"
+		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
+	
+	def self.socket(socket, **options)
+		SocketEndpoint.new(socket, **options)
+	end
+end

data/lib/io/endpoint/ssl_endpoint.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'host_endpoint'
+require_relative 'generic'
+
+require 'openssl'
+
+module IO::Endpoint
+	class SSLEndpoint < Generic
+		def initialize(endpoint, **options)
+			super(**options)
+			
+			@endpoint = endpoint
+			
+			if ssl_context = options[:ssl_context]
+				@context = build_context(ssl_context)
+			else
+				@context = nil
+			end
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@endpoint}>"
+		end
+		
+		def address
+			@endpoint.address
+		end
+		
+		def hostname
+			@options[:hostname] || @endpoint.hostname
+		end
+		
+		attr :endpoint
+		attr :options
+		
+		def params
+			@options[:ssl_params]
+		end
+		
+		def build_context(context = OpenSSL::SSL::SSLContext.new)
+			if params = self.params
+				context.set_params(params)
+			end
+			
+			context.setup
+			context.freeze
+			
+			return context
+		end
+		
+		def context
+			@context ||= build_context
+		end
+		
+		# 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
+			if block_given?
+				@endpoint.bind do |server|
+					yield OpenSSL::SSL::SSLServer.new(server, context)
+				end
+			else
+				return OpenSSL::SSL::SSLServer.new(@endpoint.bind, context)
+			end
+		end
+		
+		# Connect to the underlying endpoint and establish a SSL connection.
+		# @yield [Socket] the socket which is being connected
+		# @return [Socket] the connected socket
+		def connect(&block)
+			socket = OpenSSL::SSL::SSLSocket.new(@endpoint.connect, context)
+			
+			if hostname = self.hostname
+				socket.hostname = hostname
+			end
+			
+			begin
+				socket.connect
+			rescue
+				socket.close
+				raise
+			end
+			
+			return socket unless block_given?
+				
+			begin
+				yield socket
+			ensure
+				socket.close
+			end
+		end
+		
+		def each
+			return to_enum unless block_given?
+			
+			@endpoint.each do |endpoint|
+				yield self.class.new(endpoint, **@options)
+			end
+		end
+		
+		protected
+		
+		def accepted(socket)
+			socket.accept
+			socket
+		end
+	end
+
+	# @param args
+	# @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)
+	end
+end

data/lib/io/endpoint/unix_endpoint.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'address_endpoint'
+
+module IO::Endpoint
+	# This class doesn't exert ownership over the specified unix socket and ensures exclusive access by using `flock` where possible.
+	class UNIXEndpoint < AddressEndpoint
+		def initialize(path, type = Socket::SOCK_STREAM, **options)
+			# I wonder if we should implement chdir behaviour in here if path is longer than 104 characters.
+			super(Address.unix(path, type), **options)
+			
+			@path = path
+		end
+		
+		def to_s
+			"\#<#{self.class} #{@path.inspect}>"
+		end
+		
+		attr :path
+		
+		def bound?
+			self.connect do
+				return true
+			end
+		rescue Errno::ECONNREFUSED
+			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)
+				retry
+			else
+				raise
+			end
+		end
+	end
+	
+	# @param path [String]
+	# @param type Socket type
+	# @param options keyword arguments passed through to {UNIXEndpoint#initialize}
+	#
+	# @return [UNIXEndpoint]
+	def self.unix(path = "", type = ::Socket::SOCK_STREAM, **options)
+		UNIXEndpoint.new(path, type, **options)
+	end
+end

data/lib/io/endpoint/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+class IO
+	module Endpoint
+		VERSION = "0.1.0"
+	end
+end

data/lib/io/endpoint/wrapper.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require 'socket'
+
+module IO::Endpoint
+	class Wrapper
+		include ::Socket::Constants
+		
+		if $stdin.respond_to?(:timeout=)
+			def self.set_timeout(io, timeout)
+				io.timeout = timeout
+			end
+		else
+			def self.set_timeout(io, timeout)
+				warn "IO#timeout= not supported on this platform."
+			end
+		end
+		
+		def async
+			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.
+		def build(*arguments, timeout: nil, reuse_address: true, reuse_port: nil, linger: nil)
+			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, linger)
+			end
+			
+			yield socket if block_given?
+			
+			return socket
+		rescue
+			socket&.close
+		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|
+				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.
+						socket.setsockopt(SOL_IP, IP_BIND_ADDRESS_NO_PORT, 1)
+					end
+					
+					socket.bind(local_address.to_sockaddr)
+				end
+			end
+			
+			begin
+				socket.connect(remote_address.to_sockaddr)
+			rescue Exception
+				socket.close
+				raise
+			end
+			
+			return socket unless block_given?
+			
+			begin
+				yield socket
+			ensure
+				socket.close
+			end
+		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|
+				socket.bind(local_address.to_sockaddr)
+			end
+			
+			return socket unless block_given?
+			
+			async do
+				begin
+					yield socket
+				ensure
+					socket.close
+				end
+			end
+		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
+				
+				async do
+					while true
+						server.accept(&block)
+					end
+				end
+			end
+		end
+	end
+	
+	class ThreadWrapper < Wrapper
+		def async(&block)
+			Thread.new(&block)
+		end
+	end
+	
+	class FiberWrapper < Wrapper
+		def async(&block)
+			Fiber.schedule(&block)
+		end
+	end
+	
+	def Wrapper.default
+		if Fiber.scheduler
+			FiberWrapper.new
+		else
+			ThreadWrapper.new
+		end
+	end
+end

data/lib/io/endpoint.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative "endpoint/version"
+require_relative "endpoint/generic"
+
+module IO::Endpoint
+	def self.file_descriptor_limit
+		Process.getrlimit(Process::RLIMIT_NOFILE).first
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2023, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,23 @@
+# IO::Endpoint
+
+Provides a separation of concerns interface for IO endpoints. This allows you to write code which is agnostic to the underlying IO implementation.
+
+[![Development Status](https://github.com/socketry/io-endpoint/workflows/Test/badge.svg)](https://github.com/socketry/io-endpoint/actions?workflow=Test)
+
+## Usage
+
+Please see the [documentation](https://socketry.github.io/io-endpoint) for more information.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+## See Also
+
+  - [async-io](https://github.com/socketry/async-io) — Asynchronous IO primitives.

data.tar.gz.sig

@@ -0,0 +1 @@
+���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$,��

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: io-endpoint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  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'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/io/endpoint.rb
+- lib/io/endpoint/address_endpoint.rb
+- lib/io/endpoint/composite_endpoint.rb
+- lib/io/endpoint/generic.rb
+- lib/io/endpoint/host_endpoint.rb
+- lib/io/endpoint/shared_endpoint.rb
+- lib/io/endpoint/socket_endpoint.rb
+- lib/io/endpoint/ssl_endpoint.rb
+- lib/io/endpoint/unix_endpoint.rb
+- lib/io/endpoint/version.rb
+- lib/io/endpoint/wrapper.rb
+- license.md
+- readme.md
+homepage: https://github.com/socketry/io-endpoint
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/io-endpoint
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.7
+signing_key:
+specification_version: 4
+summary: Provides a separation of concerns interface for IO endpoints.
+test_files: []