fantail 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1f870f878fe0737149ef9b28549ceeba613a51fc39c70a243a84667713b73d4
+  data.tar.gz: 114fd5d72a6f53af337967440fdabd26c8f726a0654edaf80835a2b96faa4666
+SHA512:
+  metadata.gz: 734e0a70510bfdd3ee9e9bf602d0ecb557f8202cde970c7b4aeb4e4900f23ff7fc6bc8f2a3c8a675b1366bb3d99ad6772618b6043ca737edf50ef37e7482e3e4
+  data.tar.gz: 9e5cff59c2dd10739f677a102c12ef83cb3e007b175be6158e239e59abdf7ffe0b3460258149862564ebf6c09575467aaa92b2168581cdcba2cdf28bc77ba942

data/lib/fantail/backend.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Fantail
+	# Represents a live backend client and its admission state.
+	class Backend
+		# Initialize a backend.
+		# @parameter endpoint [Endpoint] The endpoint served by this backend.
+		# @parameter client [Interface(:call, :close)] The HTTP client for the endpoint.
+		# @parameter exchange_limit [Integer] The maximum number of outstanding response exchanges.
+		# @yields {|backend| ...} Invoked when the backend can accept another request.
+		def initialize(endpoint, client, exchange_limit:, &available)
+			raise ArgumentError, "Exchange limit must be positive!" unless exchange_limit.positive?
+			
+			@endpoint = endpoint
+			@client = client
+			@exchange_limit = exchange_limit
+			@available = available
+			
+			@guard = Thread::Mutex.new
+			@active = true
+			@processing = false
+			@exchanges = 0
+			@queued = false
+			@closed = false
+		end
+		
+		# @attribute [Endpoint] The endpoint served by this backend.
+		attr :endpoint
+		
+		# @attribute [String] The stable backend name.
+		def name
+			@endpoint.name
+		end
+		
+		# @attribute [Integer] The maximum number of outstanding response exchanges.
+		attr :exchange_limit
+		
+		# Start advertising this backend as available.
+		def start
+			notify_available
+		end
+		
+		# Reserve the processing slot and one response exchange.
+		# @returns [Boolean] Whether the backend was successfully reserved.
+		def reserve
+			@guard.synchronize do
+				@queued = false
+				
+				if @active && !@processing && @exchanges < @exchange_limit
+					@processing = true
+					@exchanges += 1
+					return true
+				end
+			end
+			
+			return false
+		end
+		
+		# Send a request to the backend.
+		# @parameter request [Protocol::HTTP::Request] The upstream request.
+		# @returns [Protocol::HTTP::Response] The upstream response.
+		def call(request)
+			@client.call(request)
+		end
+		
+		# Release the request-processing slot after response headers arrive.
+		def processed
+			@guard.synchronize do
+				raise RuntimeError, "Backend is not processing a request!" unless @processing
+				@processing = false
+			end
+			
+			notify_available
+		end
+		
+		# Release both reservations when a request fails before response headers.
+		def failed
+			close = @guard.synchronize do
+				raise RuntimeError, "Backend is not processing a request!" unless @processing
+				@processing = false
+				@exchanges -= 1
+				should_close?
+			end
+			
+			notify_available
+			close_client if close
+		end
+		
+		# Release an outstanding response exchange.
+		def release
+			close = @guard.synchronize do
+				raise RuntimeError, "Backend has no outstanding exchange!" unless @exchanges.positive?
+				@exchanges -= 1
+				should_close?
+			end
+			
+			notify_available
+			close_client if close
+		end
+		
+		# Retire this backend without interrupting outstanding responses.
+		def retire
+			close = @guard.synchronize do
+				@active = false
+				should_close?
+			end
+			
+			close_client if close
+		end
+		
+		# @returns [Boolean] Whether this backend still accepts new requests.
+		def active?
+			@guard.synchronize{@active}
+		end
+		
+		# @returns [Integer] The number of outstanding response exchanges.
+		def exchanges
+			@guard.synchronize{@exchanges}
+		end
+		
+		# @returns [Boolean] Whether a request is waiting for response headers.
+		def processing?
+			@guard.synchronize{@processing}
+		end
+		
+		protected
+		
+		def notify_available
+			notify = @guard.synchronize do
+				if @active && !@processing && @exchanges < @exchange_limit && !@queued
+					@queued = true
+					true
+				else
+					false
+				end
+			end
+			
+			@available.call(self) if notify
+		end
+		
+		def should_close?
+			!@active && !@processing && @exchanges.zero? && !@closed
+		end
+		
+		def close_client
+			close = @guard.synchronize do
+				unless @closed
+					@closed = true
+					true
+				end
+			end
+			
+			@client.close if close
+		end
+	end
+end

data/lib/fantail/control.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/bus/server"
+
+module Fantail
+	# Exposes a registry over async-bus for endpoint publication.
+	class Control < Async::Bus::Server
+		# Initialize a control server.
+		# @parameter endpoint [IO::Endpoint] The endpoint used for registry updates.
+		# @parameter registry [Registry] The registry to expose.
+		def initialize(endpoint, registry)
+			super(endpoint)
+			@registry = registry
+		end
+		
+		protected def connected!(connection)
+			connection.bind(:registry, @registry)
+		end
+	end
+end

data/lib/fantail/endpoint.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http/client"
+require "async/http/endpoint"
+require "async/http/protocol/http1"
+require "async/http/protocol/http2"
+
+module Fantail
+	# Represents a named HTTP backend endpoint.
+	class Endpoint
+		# Coerce an endpoint or endpoint description into an endpoint.
+		# @parameter description [Endpoint | Hash] The endpoint or serialized endpoint description.
+		# @returns [Endpoint] The coerced endpoint.
+		def self.coerce(description)
+			return description if description.is_a?(self)
+			
+			name = description[:name] || description["name"]
+			url = description[:url] || description["url"]
+			protocol = description[:protocol] || description["protocol"]
+			
+			self.new(name, url, protocol: protocol)
+		end
+		
+		# Initialize a named backend endpoint.
+		# @parameter name [String] The stable endpoint identity.
+		# @parameter url [String] The absolute backend URL.
+		# @parameter protocol [String | Nil] The upstream HTTP protocol name.
+		def initialize(name, url, protocol: nil)
+			raise ArgumentError, "Endpoint name is required!" unless name
+			raise ArgumentError, "Endpoint URL is required!" unless url
+			
+			@name = name.to_s
+			@url = url.to_s
+			@protocol = protocol&.to_s
+			
+			freeze
+		end
+		
+		# @attribute [String] The stable endpoint identity.
+		attr :name
+		
+		# @attribute [String] The absolute backend URL.
+		attr :url
+		
+		# @attribute [String | Nil] The upstream HTTP protocol name.
+		attr :protocol
+		
+		# Build an HTTP client for this endpoint.
+		# @parameter exchange_limit [Integer] The maximum number of outstanding response exchanges.
+		# @returns [Async::HTTP::Client] A client connected to this endpoint.
+		def make_client(exchange_limit:)
+			endpoint = Async::HTTP::Endpoint.parse(@url, protocol: protocol_module)
+			
+			Async::HTTP::Client.new(endpoint, limit: exchange_limit, retries: 0)
+		end
+		
+		# Convert this endpoint into a transport-safe description.
+		# @returns [Hash] A serialized endpoint description.
+		def to_h
+			{
+				"name" => @name,
+				"url" => @url,
+				"protocol" => @protocol,
+			}.compact
+		end
+		
+		# Compare endpoints by their serialized configuration.
+		def ==(other)
+			other.is_a?(Endpoint) && other.to_h == self.to_h
+		end
+		
+		protected
+		
+		def protocol_module
+			case @protocol
+			when nil, "http/1.0", "http/1.1"
+				Async::HTTP::Protocol::HTTP1
+			when "h2", "http/2"
+				Async::HTTP::Protocol::HTTP2
+			else
+				raise ArgumentError, "Unsupported HTTP protocol: #{@protocol.inspect}"
+			end
+		end
+	end
+end

data/lib/fantail/monitor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/bus/client"
+require "async/queue"
+
+require_relative "endpoint"
+
+module Fantail
+	# Publishes a desired endpoint set and subsequent deltas to a Fantail registry.
+	class Monitor < Async::Bus::Client
+		# Initialize an endpoint monitor.
+		# @parameter endpoint [IO::Endpoint] The Fantail control endpoint.
+		def initialize(endpoint)
+			super(endpoint)
+			
+			@guard = Thread::Mutex.new
+			@endpoints = {}
+			@revision = 0
+			@changes = Async::Queue.new
+		end
+		
+		# Replace the desired endpoint set without blocking on the control connection.
+		# @parameter descriptions [Array(Endpoint | Hash)] The complete desired endpoint set.
+		# @returns [Integer] The local revision number.
+		def replace(descriptions)
+			endpoints = descriptions.map{|description| Endpoint.coerce(description).to_h}
+			
+			revision = @guard.synchronize do
+				@endpoints = endpoints.to_h{|description| [description.fetch("name"), description]}
+				@revision += 1
+			end
+			
+			@changes.enqueue([revision, :replace, endpoints])
+			return revision
+		end
+		
+		# Add or replace a desired endpoint without blocking on the control connection.
+		# @parameter description [Endpoint | Hash] The endpoint to publish.
+		# @returns [Integer] The local revision number.
+		def upsert(description)
+			endpoint = Endpoint.coerce(description).to_h
+			
+			revision = @guard.synchronize do
+				@endpoints[endpoint.fetch("name")] = endpoint
+				@revision += 1
+			end
+			
+			@changes.enqueue([revision, :update, [endpoint], []])
+			return revision
+		end
+		
+		# Remove a desired endpoint without blocking on the control connection.
+		# @parameter name [String] The endpoint identity to remove.
+		# @returns [Integer] The local revision number.
+		def remove(name)
+			name = name.to_s
+			
+			revision = @guard.synchronize do
+				@endpoints.delete(name)
+				@revision += 1
+			end
+			
+			@changes.enqueue([revision, :update, [], [name]])
+			return revision
+		end
+		
+		# @returns [Array(Hash)] A snapshot of the desired endpoints.
+		def endpoints
+			@guard.synchronize{@endpoints.values.map(&:dup)}
+		end
+		
+		# Run the persistent publisher, resynchronizing completely after each reconnect.
+		# @parameter options [Hash] Options forwarded to Async::Bus::Client#run.
+		# @returns [Async::Task] The publisher task.
+		def run(**options)
+			super(**options) do |connection|
+				synchronize(connection[:registry])
+			end
+		end
+		
+		protected
+		
+		def synchronize(registry)
+			revision, endpoints = snapshot
+			registry.replace(endpoints)
+			
+			publish_changes(registry, revision)
+		end
+		
+		def snapshot
+			@guard.synchronize{[@revision, @endpoints.values.map(&:dup)]}
+		end
+		
+		def publish_changes(registry, revision)
+			while change = @changes.dequeue
+				change_revision, operation, *arguments = change
+				next if change_revision <= revision
+				
+				registry.public_send(operation, *arguments)
+				revision = change_revision
+			end
+		end
+	end
+end

data/lib/fantail/proxy.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "protocol/http/request"
+require "protocol/http/response"
+
+require_relative "response_body"
+
+module Fantail
+	# Routes HTTP requests through the registry's global admission queue.
+	class Proxy
+		# Initialize an HTTP proxy.
+		# @parameter registry [Registry] The backend registry.
+		def initialize(registry)
+			@registry = registry
+		end
+		
+		# Route a request to the next available backend.
+		# @parameter request [Protocol::HTTP::Request] The downstream request.
+		# @returns [Protocol::HTTP::Response] The upstream or generated response.
+		def call(request)
+			unless backend = @registry.acquire
+				return Protocol::HTTP::Response[503, {"content-type" => "text/plain"}, ["No backends available.\n"]]
+			end
+			
+			reservation = :processing
+			upstream_request = build_request(request)
+			response = backend.call(upstream_request)
+			backend.processed
+			reservation = :exchange
+			
+			if body = response.body
+				response.body = ResponseBody.new(body){backend.release}
+			else
+				backend.release
+			end
+			reservation = nil
+			
+			return response
+		rescue => error
+			case reservation
+			when :processing
+				backend.failed
+			when :exchange
+				backend.release
+			end
+			
+			return Protocol::HTTP::Response[502, {"content-type" => "text/plain"}, ["Bad Gateway: #{error.class}\n"]]
+		end
+		
+		protected
+		
+		def build_request(request)
+			upstream_request = Protocol::HTTP::Request.new(
+				nil,
+				nil,
+				request.method,
+				request.path,
+				nil,
+				request.headers,
+				request.body,
+				request.protocol,
+				request.interim_response,
+			)
+			
+			# Transfer ownership of the request body to the upstream request:
+			request.body = nil
+			
+			return upstream_request
+		end
+	end
+end

data/lib/fantail/registry.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/bus/controller"
+require "async/queue"
+
+require_relative "endpoint"
+require_relative "backend"
+
+module Fantail
+	# Maintains live backends and a global queue of available processing slots.
+	class Registry < Async::Bus::Controller
+		WAKE = Object.new.freeze
+		
+		# Initialize an endpoint registry.
+		# @parameter exchange_limit [Integer] The maximum outstanding responses per backend.
+		# @parameter backend_factory [Proc | Nil] An optional backend construction strategy.
+		def initialize(exchange_limit: 8, backend_factory: nil)
+			@exchange_limit = exchange_limit
+			@backend_factory = backend_factory || self.method(:make_backend)
+			
+			@guard = Thread::Mutex.new
+			@backends = {}
+			@available = Async::Queue.new
+			@closed = false
+		end
+		
+		# Replace the complete endpoint set.
+		# @parameter descriptions [Array(Endpoint | Hash)] The desired endpoints.
+		# @returns [Integer] The resulting endpoint count.
+		def replace(descriptions)
+			endpoints = descriptions.map{|description| Endpoint.coerce(description)}
+			names = endpoints.map(&:name)
+			
+			current_names = @guard.synchronize{@backends.keys}
+			self.update(endpoints, current_names - names)
+		end
+		
+		# Apply endpoint additions, replacements, and removals.
+		# @parameter upserted [Array(Endpoint | Hash)] Endpoints to add or replace.
+		# @parameter removed [Array(String)] Endpoint names to remove.
+		# @returns [Integer] The resulting endpoint count.
+		def update(upserted, removed)
+			retired = []
+			started = []
+			
+			@guard.synchronize do
+				raise IOError, "Registry is closed!" if @closed
+				
+				removed.each do |name|
+					if backend = @backends.delete(name.to_s)
+						retired << backend
+					end
+				end
+				
+				upserted.each do |description|
+					endpoint = Endpoint.coerce(description)
+					current = @backends[endpoint.name]
+					
+					next if current&.endpoint == endpoint
+					
+					retired << current if current
+					backend = @backend_factory.call(endpoint, @exchange_limit, self.method(:offer))
+					@backends[endpoint.name] = backend
+					started << backend
+				end
+			end
+			
+			retired.each(&:retire)
+			started.each(&:start)
+			@available.enqueue(WAKE) unless retired.empty?
+			
+			self.size
+		end
+		
+		# Acquire the next backend with processing capacity.
+		# @returns [Backend | Nil] An admitted backend, or nil if no endpoints exist.
+		def acquire
+			loop do
+				return nil if self.empty?
+				
+				candidate = @available.dequeue
+				return nil unless candidate
+				next if candidate.equal?(WAKE)
+				
+				return candidate if candidate.reserve
+			end
+		end
+		
+		# @returns [Integer] The number of active endpoints.
+		def size
+			@guard.synchronize{@backends.size}
+		end
+		
+		# @returns [Boolean] Whether no active endpoints are registered.
+		def empty?
+			self.size.zero?
+		end
+		
+		# @returns [Array(String)] The active endpoint names.
+		def names
+			@guard.synchronize{@backends.keys.sort}
+		end
+		
+		# Find an active backend by name.
+		# @parameter name [String] The endpoint name.
+		# @returns [Backend | Nil] The active backend.
+		def [](name)
+			@guard.synchronize{@backends[name.to_s]}
+		end
+		
+		# Close the registry and retire all backends.
+		def close
+			backends = @guard.synchronize do
+				next [] if @closed
+				
+				@closed = true
+				@backends.values.tap{@backends = {}}
+			end
+			
+			@available.close
+			backends.each(&:retire)
+		end
+		
+		protected
+		
+		def offer(backend)
+			@available.enqueue(backend)
+		rescue Async::Queue::ClosedError
+			# The registry is already shutting down:
+		end
+		
+		def make_backend(endpoint, exchange_limit, available)
+			client = endpoint.make_client(exchange_limit: exchange_limit)
+			Backend.new(endpoint, client, exchange_limit: exchange_limit, &available)
+		end
+	end
+end

data/lib/fantail/response_body.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "protocol/http/body/wrapper"
+
+module Fantail
+	# Wraps an upstream response body and releases its backend exchange when closed.
+	class ResponseBody < Protocol::HTTP::Body::Wrapper
+		# Initialize a response body wrapper.
+		# @parameter body [Protocol::HTTP::Body::Readable] The upstream response body.
+		# @yields Invoked exactly once when the response body closes.
+		def initialize(body, &release)
+			super(body)
+			@release = release
+		end
+		
+		# Close the upstream body and release its backend exchange.
+		# @parameter error [Exception | Nil] The error which caused the body to close.
+		def close(error = nil)
+			super
+		ensure
+			if release = @release
+				@release = nil
+				release.call
+			end
+		end
+	end
+end

data/lib/fantail/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http/server"
+
+require_relative "registry"
+require_relative "proxy"
+require_relative "control"
+
+module Fantail
+	# Runs the HTTP load balancer and endpoint-control server together.
+	class Server
+		# Initialize a Fantail server.
+		# @parameter endpoint [Async::HTTP::Endpoint] The downstream HTTP endpoint.
+		# @parameter control_endpoint [IO::Endpoint] The async-bus control endpoint.
+		# @parameter exchange_limit [Integer] The maximum outstanding responses per backend.
+		def initialize(endpoint, control_endpoint, exchange_limit: 8)
+			@registry = Registry.new(exchange_limit: exchange_limit)
+			@proxy = Proxy.new(@registry)
+			@http_server = Async::HTTP::Server.new(@proxy, endpoint)
+			@control_server = Control.new(control_endpoint, @registry)
+		end
+		
+		# @attribute [Registry] The server's endpoint registry.
+		attr :registry
+		
+		# Run the HTTP and control servers.
+		# @parameter parent [Interface(:async)] The parent task.
+		# @returns [Async::Task] The server task.
+		def run(parent: Async::Task.current)
+			parent.async do |task|
+				task.async do
+					@control_server.accept
+				end
+				
+				@http_server.run.wait
+			end
+		end
+		
+		# Close the endpoint registry.
+		def close
+			@registry.close
+		end
+	end
+end

data/lib/fantail/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Fantail
+	VERSION = "0.0.1"
+end

data/lib/fantail.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "fantail/version"
+require_relative "fantail/endpoint"
+require_relative "fantail/backend"
+require_relative "fantail/response_body"
+require_relative "fantail/registry"
+require_relative "fantail/proxy"
+require_relative "fantail/control"
+require_relative "fantail/monitor"
+require_relative "fantail/server"
+
+# Provides worker-aware HTTP load balancing with a global admission queue.
+module Fantail
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, 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,55 @@
+# Fantail
+
+Worker-aware HTTP load balancing with a global admission queue.
+
+[![Development Status](https://github.com/socketry/fantail/workflows/Test/badge.svg)](https://github.com/socketry/fantail/actions?workflow=Test)
+
+Fantail routes each request to a worker which is ready to process it. It separates the short-lived request-processing reservation from the potentially longer response exchange, so another request can begin after response headers arrive while the previous response body is still streaming.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/fantail/) for more details.
+
+  - [Getting Started](https://socketry.github.io/fantail/guides/getting-started/index) - This guide explains how to run Fantail and publish HTTP worker endpoints.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/fantail/releases/index) for all releases.
+
+### v0.0.1
+
+  - Initial implementation.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork the repository.
+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 a new pull request.
+
+### Running Tests
+
+To run the test suite:
+
+``` bash
+$ bundle exec sus
+```
+
+### Making Releases
+
+To make a new release:
+
+``` bash
+$ bundle exec bake gem:release:patch # or minor or major
+```
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,5 @@
+# Releases
+
+## v0.0.1
+
+  - Initial implementation.

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: fantail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Samuel Williams
+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: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-bus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fantail.rb
+- lib/fantail/backend.rb
+- lib/fantail/control.rb
+- lib/fantail/endpoint.rb
+- lib/fantail/monitor.rb
+- lib/fantail/proxy.rb
+- lib/fantail/registry.rb
+- lib/fantail/response_body.rb
+- lib/fantail/server.rb
+- lib/fantail/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/fantail
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/socketry/fantail/issues
+  changelog_uri: https://github.com/socketry/fantail/blob/main/releases.md
+  documentation_uri: https://socketry.github.io/fantail/
+  funding_uri: https://github.com/sponsors/ioquatix/
+  source_code_uri: https://github.com/socketry/fantail.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Worker-aware HTTP load balancing with a global admission queue.
+test_files: []

metadata.gz.sig

@@ -0,0 +1,5 @@
+8�Nċ����*�Pb��\��y,����<���_��I�g8<4v7rz˅z�dX@\kK�4��$��P��NBi�J�^ľ������*lD���|8fI��g��83�؉o�5a�f���9�3�9p���[ĜP	?<�g2])��m��Ă�����ϫj$�!e6/|Gq�C��d���K��{
C�����]Z������{�[�n�T
++k/�3z[
+
���/��P��
+I�y������1-�a�oo�UC�l�������A���C���T�O\FhL���VP����xo��{��׆�
�K�ie����D��L� �%�;���6\
+���Ku�'�A��w�Y�k[�����Pʻl�n�3�X����41�p����l