async-service-supervisor-envoy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 554c82adfbbf77fc5fe7e0ee5a0bbe9a67de5161cc7699eab8b98cf4c0cb5847
+  data.tar.gz: 44a9f2a1488f5108dc18b859b43f0ad3ec2709490784e0500587c240790d9749
+SHA512:
+  metadata.gz: 7752e3f6af3a6795a5f294867cb4cf11523cb4192d464ea29834278f4d7f799969c18c4a9cc9bbd70ddd035b34dc532378333be2aad12488b7822af761284954
+  data.tar.gz: a9abeeb77d2eb1ca67d219fdb9ef75820c841d7bf9c15b86ee012e4296702524ecacdd2780d9b21b1d2e3520873048741b960b1d92c5a0a0b91761bc8845ef97

data/code.md

@@ -0,0 +1 @@
+

data/context/getting-started.md

@@ -0,0 +1,94 @@
+# Getting Started
+
+This guide explains how to use `async-service-supervisor-envoy` to publish supervised worker endpoints to Envoy using xDS.
+
+## Installation
+
+Add the gem to your project:
+
+~~~ bash
+$ bundle add async-service-supervisor-envoy
+~~~
+
+The gem depends on `async-service-supervisor` and `async-grpc-xds`.
+
+## Core Concepts
+
+`async-service-supervisor-envoy` provides:
+
+  - {ruby Async::Service::Supervisor::Envoy::Monitor} - A supervisor monitor that publishes worker endpoints through xDS.
+  - {ruby Async::Service::Supervisor::Envoy::Endpoint} - A small value object for endpoint state.
+
+The monitor runs an xDS control plane endpoint. Envoy connects to it using ADS and receives CDS/EDS updates derived from supervisor worker state.
+
+## Endpoint State
+
+Workers are published when they register concrete endpoint state:
+
+``` ruby
+state = {
+	endpoint: {
+		name: "myservice",
+		scheme: :http,
+		protocols: ["http/1.1"],
+		addresses: [
+			{address: "127.0.0.1", port: 50051},
+			{path: "/run/myservice/worker.ipc"}
+		]
+	}
+}
+```
+
+Workers without endpoint state are ignored by the Envoy monitor.
+
+Falcon cluster workers can register their concrete post-bind listener automatically:
+
+``` ruby
+service "application" do
+	include Falcon::Environment::Cluster
+	include Async::Service::Supervisor::Envoy::Supervised
+end
+```
+
+Falcon describes its bound server resource as a listener. The integration converts that listener into Envoy upstream endpoint state, including its name, scheme, supported protocols, and every concrete IP or Unix socket address. Addresses belonging to one listener remain grouped as one Envoy load-balancer endpoint.
+
+## Monitor Usage
+
+Add the monitor to your supervisor environment:
+
+``` ruby
+require "async/service/supervisor/envoy"
+
+Async::Service::Supervisor::Envoy::Monitor.new(
+	bind: "http://127.0.0.1:18000"
+)
+```
+
+By default, workers are grouped into clusters by `state[:name]`.
+
+## Custom Mapping
+
+You can customize cluster grouping, endpoint selection, and health with a delegate:
+
+``` ruby
+class EnvoyDelegate < Async::Service::Supervisor::Envoy::Delegate
+	def endpoint_list(supervisor_controller)
+		super
+	end
+	
+	def cluster(supervisor_controller, endpoint)
+		super
+	end
+	
+	def healthy?(supervisor_controller, endpoint)
+		true
+	end
+end
+
+Async::Service::Supervisor::Envoy::Monitor.new(
+	bind: "http://127.0.0.1:18000",
+	delegate: EnvoyDelegate.new
+)
+```
+
+Disconnected workers are removed from EDS. Registered workers that fail the delegate health check remain in EDS with an unhealthy endpoint status.

data/context/index.yaml

@@ -0,0 +1,12 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: Envoy xDS monitor for async-service-supervisor.
+metadata:
+  documentation_uri: https://socketry.github.io/async-service-supervisor-envoy/
+  source_code_uri: https://github.com/socketry/async-service-supervisor-envoy.git
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide explains how to use `async-service-supervisor-envoy` to
+    publish supervised worker endpoints to Envoy using xDS.

data/lib/async/service/supervisor/envoy/delegate.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "endpoint"
+
+module Async
+	module Service
+		module Supervisor
+			module Envoy
+				# Maps supervisor state into Envoy upstream endpoints.
+				class Delegate
+					# Extract serialized endpoints from a supervisor controller.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @returns [Hash | Array(Hash) | Nil] The serialized endpoint state.
+					def endpoints(supervisor_controller)
+						state = supervisor_controller.state
+						
+						state[:endpoints] || state[:endpoint]
+					end
+					
+					# Convert serialized state into Envoy endpoint values.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @returns [Array(Endpoint)] The upstream endpoints to publish.
+					def endpoint_list(supervisor_controller)
+						case endpoints = self.endpoints(supervisor_controller)
+						when nil
+							[]
+						when Array
+							endpoints.map{|endpoint| Endpoint.wrap(endpoint)}
+						else
+							[Endpoint.wrap(endpoints)]
+						end
+					end
+					
+					# Select the Envoy cluster name for an endpoint.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @parameter endpoint [Endpoint] The endpoint being published.
+					# @returns [String | Nil] The cluster name, or nil to skip the endpoint.
+					def cluster(supervisor_controller, endpoint)
+						endpoint.name
+					end
+					
+					# Determine whether an endpoint should be published as healthy.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @parameter endpoint [Endpoint] The endpoint being published.
+					# @returns [Boolean] Whether the endpoint is healthy.
+					def healthy?(supervisor_controller, endpoint)
+						true
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/service/supervisor/envoy/endpoint.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Async
+	module Service
+		module Supervisor
+			module Envoy
+				# Represents one upstream endpoint published to Envoy EDS.
+				class Endpoint
+					# Wrap serialized endpoint state.
+					# @parameter value [Endpoint | Hash] The value to wrap.
+					# @returns [Endpoint] The endpoint value.
+					def self.wrap(value)
+						case value
+						when self
+							value
+						when Hash
+							new(**value)
+						else
+							raise ArgumentError, "Invalid Envoy endpoint: #{value.inspect}"
+						end
+					end
+					
+					# Normalize a concrete endpoint address.
+					# @parameter value [Hash] The address value.
+					# @returns [Hash] A normalized IP or Unix address.
+					def self.normalize_address(value)
+						if path = value[:path]
+							raise ArgumentError, "A Unix endpoint cannot specify an IP address or port!" if value[:address] || value[:port]
+							
+							{path: path.to_s}.freeze
+						elsif value[:address] && value[:port]
+							{address: value[:address].to_s, port: Integer(value[:port])}.freeze
+						else
+							raise ArgumentError, "An endpoint address requires either path, or address and port: #{value.inspect}"
+						end
+					end
+					
+					# Initialize an endpoint.
+					# @parameter name [String] The upstream cluster name.
+					# @parameter scheme [String | Symbol] The upstream application scheme.
+					# @parameter protocols [Array(String)] The supported upstream HTTP protocol names.
+					# @parameter addresses [Array(Hash)] The grouped concrete addresses.
+					def initialize(name:, scheme:, protocols:, addresses:)
+						@name = name.to_s
+						@scheme = scheme.to_sym
+						@protocols = protocols.map(&:to_s).uniq.freeze
+						raise ArgumentError, "An endpoint requires at least one protocol!" if @protocols.empty?
+						@addresses = addresses.map{|value| self.class.normalize_address(value)}.freeze
+						raise ArgumentError, "An endpoint requires at least one address!" if @addresses.empty?
+					end
+					
+					# @attribute [String] The upstream cluster name.
+					attr :name
+					
+					# @attribute [Symbol] The upstream application scheme.
+					attr :scheme
+					
+					# @attribute [Array(String)] The supported upstream HTTP protocol names.
+					attr :protocols
+					
+					# @attribute [Array(Hash)] The grouped concrete addresses.
+					attr :addresses
+					
+				end
+			end
+		end
+	end
+end

data/lib/async/service/supervisor/envoy/monitor.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http/endpoint"
+require "async/service/supervisor/monitor"
+require "async/grpc/xds/control_plane"
+require "async/grpc/xds/server"
+
+require_relative "delegate"
+require_relative "endpoint"
+
+module Async
+	module Service
+		module Supervisor
+			# Provides Envoy integration for supervisor-managed services.
+			module Envoy
+				# Represents a supervisor monitor that publishes worker endpoints to Envoy using xDS.
+				class Monitor < Async::Service::Supervisor::Monitor
+					# Initialize the monitor.
+					# @parameter bind [String | Nil] The optional address for the xDS control plane server.
+					# @parameter delegate [Delegate] The delegate used to map supervisor state into Envoy endpoints.
+					# @parameter control_plane [Async::GRPC::XDS::ControlPlane] The xDS control plane to update.
+					def initialize(
+						bind: nil,
+						delegate: Delegate.new,
+						control_plane: Async::GRPC::XDS::ControlPlane.new,
+						**options
+					)
+						super(**options)
+						
+						@bind = bind
+						@delegate = delegate
+						@control_plane = control_plane
+						@controllers = {}
+						@published_clusters = {}
+						@server_task = nil
+						@mutex = Mutex.new
+					end
+					
+					# @attribute [Async::GRPC::XDS::ControlPlane] The xDS control plane receiving cluster and endpoint updates.
+					attr :control_plane
+					
+					# @attribute [Delegate] The delegate used to map supervisor state into Envoy endpoints.
+					attr :delegate
+					
+					# Register a supervisor worker with Envoy.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @returns [void]
+					def register(supervisor_controller)
+						@mutex.synchronize do
+							@controllers[supervisor_controller.id] = supervisor_controller
+							reconcile
+						end
+					end
+					
+					# Remove a supervisor worker from Envoy.
+					# @parameter supervisor_controller [Object] The supervisor controller describing the worker.
+					# @returns [void]
+					def remove(supervisor_controller)
+						@mutex.synchronize do
+							@controllers.delete(supervisor_controller.id)
+							reconcile
+						end
+					end
+					
+					# Run the monitor and optional xDS server task.
+					# @parameter parent [Async::Task] The parent task used for the xDS server.
+					# @returns [Async::Task] The monitor task.
+					def run(parent: Async::Task.current)
+						task = super(parent: parent)
+						
+						if @bind
+							@server_task = parent.async do
+								endpoint = Async::HTTP::Endpoint.parse(@bind, protocol: Async::HTTP::Protocol::HTTP2)
+								Async::GRPC::XDS::Server.new(@control_plane).run(endpoint)
+							end
+						end
+						
+						task
+					end
+					
+					# Convert the currently published endpoints to JSON-compatible data.
+					# @returns [Hash] The clusters and endpoint hashes.
+					def as_json
+						@mutex.synchronize do
+							{
+								clusters: build_clusters
+							}
+						end
+					end
+					
+					# Refresh endpoint health and publish updated EDS state.
+					# @returns [void]
+					def run_once
+						@mutex.synchronize do
+							reconcile
+						end
+					end
+					
+					private
+					
+					def build_record(supervisor_controller, endpoint)
+						cluster = @delegate.cluster(supervisor_controller, endpoint)
+						return unless cluster
+						
+						{
+							cluster: cluster.to_s,
+							endpoint: endpoint,
+							healthy: @delegate.healthy?(supervisor_controller, endpoint),
+						}
+					end
+					
+					def build_records(supervisor_controller)
+						@delegate.endpoint_list(supervisor_controller).filter_map do |endpoint|
+							build_record(supervisor_controller, endpoint)
+						end
+					end
+					
+					def reconcile
+						records_by_cluster = build_records_by_cluster
+						clusters = build_clusters(records_by_cluster)
+						
+						records_by_cluster.each do |cluster, records|
+							configuration = cluster_configuration(records)
+							
+							unless @published_clusters[cluster] == configuration
+								@control_plane.update_cluster(cluster, **configuration)
+								@published_clusters[cluster] = configuration
+							end
+						end
+						
+						(@published_clusters.keys | clusters.keys).each do |cluster|
+							@control_plane.update_endpoints(cluster, clusters.fetch(cluster, []))
+						end
+					end
+					
+					def build_records_by_cluster
+						@controllers.each_value.flat_map do |controller|
+							build_records(controller)
+						end.group_by do |record|
+							record[:cluster]
+						end
+					end
+					
+					def build_clusters(records_by_cluster = build_records_by_cluster)
+						records_by_cluster.transform_values do |records|
+							records.map do |record|
+								{addresses: record[:endpoint].addresses, healthy: record[:healthy]}
+							end
+						end
+					end
+					
+					def cluster_configuration(records)
+						schemes = records.map{|record| record[:endpoint].scheme}.uniq
+						protocols = records.map{|record| record[:endpoint].protocols}
+						common_protocols = protocols.reduce{|common, names| common & names}
+						
+						raise ArgumentError, "Envoy cluster contains incompatible schemes: #{schemes.inspect}" if schemes.size > 1
+						raise ArgumentError, "Envoy cluster contains no common protocols: #{protocols.inspect}" if common_protocols.empty?
+						raise ArgumentError, "HTTPS upstream endpoints are not yet supported!" if schemes.first == :https
+						
+						{protocol: envoy_protocol(common_protocols)}
+					end
+					
+					def envoy_protocol(protocols)
+						protocols.each do |protocol|
+							case protocol
+							when "h2"
+								return :http2
+							when "http/1.1", "http/1.0"
+								return :http1
+							end
+						end
+						
+						raise ArgumentError, "Envoy cluster contains no supported protocols: #{protocols.inspect}"
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/service/supervisor/envoy/supervised.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/service/supervisor/supervised"
+
+module Async
+	module Service
+		module Supervisor
+			module Envoy
+				# Registers post-bind cluster listeners with the supervisor.
+				module Supervised
+					include Async::Service::Supervisor::Supervised
+					
+					# Prepare and register a worker after its listener has been bound.
+					# @parameter instance [Async::Container::Instance] The container instance.
+					# @parameter listener [Object] The bound listener descriptor.
+					def prepare_worker!(instance, listener:)
+						prepare!(instance, state: {endpoint: envoy_endpoint(listener)})
+					end
+					
+					# Convert a bound listener into serialized Envoy endpoint state.
+					# @parameter listener [Object] The bound listener descriptor.
+					# @returns [Hash] The serialized endpoint.
+					def envoy_endpoint(listener)
+						{
+							name: listener.name,
+							scheme: listener.scheme,
+							protocols: listener.protocols,
+							addresses: listener.addresses.map{|address| envoy_address(address)},
+						}
+					end
+					
+					# Convert a concrete bound address to serializable supervisor state.
+					# @parameter address [Addrinfo] The bound address.
+					# @returns [Hash] The serialized address.
+					# @raises [ArgumentError] If the address family is unsupported.
+					def envoy_address(address)
+						if address.ip?
+							{address: address.ip_address, port: address.ip_port}
+						elsif address.unix?
+							{path: address.unix_path}
+						else
+							raise ArgumentError, "Unsupported listener address: #{address.inspect}"
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/service/supervisor/envoy/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+# @namespace
+module Async
+	# @namespace
+	module Service
+		# @namespace
+		module Supervisor
+			# @namespace
+			module Envoy
+				VERSION = "0.0.1"
+			end
+		end
+	end
+end

data/lib/async/service/supervisor/envoy.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "envoy/version"
+require_relative "envoy/delegate"
+require_relative "envoy/endpoint"
+require_relative "envoy/monitor"
+require_relative "envoy/supervised"

data/license.md

@@ -0,0 +1,3 @@
+# License
+
+Released under the MIT license.

data/readme.md

@@ -0,0 +1,75 @@
+# Async::Service::Supervisor::Envoy
+
+Provides an Envoy xDS monitor for `async-service-supervisor`.
+
+[![Development Status](https://github.com/socketry/async-service-supervisor-envoy/workflows/Test/badge.svg)](https://github.com/socketry/async-service-supervisor-envoy/actions?workflow=Test)
+
+## Features
+
+`async-service-supervisor-envoy` publishes supervised worker endpoints to Envoy:
+
+  - **xDS control plane** - Runs an ADS server backed by `async-grpc-xds`.
+  - **Supervisor integration** - Registers and removes endpoints from supervisor worker lifecycle events.
+  - **Multiple clusters** - Groups workers by `state[:name]` by default.
+  - **Endpoint contract** - Converts concrete post-bind worker listeners into Envoy upstream endpoints, including grouped IP or Unix socket addresses.
+  - **Delegate mapping** - Uses a delegate object for endpoint selection, cluster grouping, and health without active probing.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/async-service-supervisor-envoy/) for more details.
+
+  - [Getting Started](https://socketry.github.io/async-service-supervisor-envoy/guides/getting-started/index) - This guide explains how to use `async-service-supervisor-envoy` to publish supervised worker endpoints to Envoy using xDS.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/async-service-supervisor-envoy/releases/index) for all releases.
+
+### v0.0.1
+
+  - Register concrete Falcon cluster listeners as Envoy upstream endpoint state after binding.
+  - Publish grouped IP and Unix-domain-socket endpoint addresses to Envoy.
+  - Configure generated clusters from each endpoint's supported HTTP protocol names.
+
+### v0.1.0
+
+  - Initial release.
+
+## See Also
+
+  - [async-service-supervisor](https://github.com/socketry/async-service-supervisor) - Supervisor for managed Async service workers.
+  - [async-grpc-xds](https://github.com/socketry/async-grpc-xds) - xDS support for Async::GRPC.
+  - [Envoy xDS](https://www.envoyproxy.io/docs/envoy/latest/api-docs/xds_protocol) - Envoy dynamic configuration protocol.
+
+## 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.
+
+### Running Tests
+
+To run the test suite:
+
+``` shell
+bundle exec sus
+```
+
+### Making Releases
+
+To make a new release:
+
+``` shell
+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,11 @@
+# Releases
+
+## v0.0.1
+
+  - Register concrete Falcon cluster listeners as Envoy upstream endpoint state after binding.
+  - Publish grouped IP and Unix-domain-socket endpoint addresses to Envoy.
+  - Configure generated clusters from each endpoint's supported HTTP protocol names.
+
+## v0.1.0
+
+  - Initial release.

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: async-service-supervisor-envoy
+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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.38'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.38'
+- !ruby/object:Gem::Dependency
+  name: async-grpc-xds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: async-service-supervisor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- code.md
+- context/getting-started.md
+- context/index.yaml
+- lib/async/service/supervisor/envoy.rb
+- lib/async/service/supervisor/envoy/delegate.rb
+- lib/async/service/supervisor/envoy/endpoint.rb
+- lib/async/service/supervisor/envoy/monitor.rb
+- lib/async/service/supervisor/envoy/supervised.rb
+- lib/async/service/supervisor/envoy/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/async-service-supervisor-envoy
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/async-service-supervisor-envoy/
+  source_code_uri: https://github.com/socketry/async-service-supervisor-envoy.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: Envoy xDS monitor for async-service-supervisor.
+test_files: []

metadata.gz.sig

@@ -0,0 +1,5 @@
+S��&
�v�59�u���cW�!b9j�1<��]��F�<:��6
+iB<A8�Wm*]������W
+`f�T춐n����@�?o������*��,͔�Qv����
+/��0�h��x�YMsxdv��#����R|?^&�<z��0�[y����Lۭn%ף�4��M͸3�Gp��٨�J)�3�_|^󏞤!Q)�vK��ߵ}ծa=��L��goA�Mt�
+߉�TV�C�욶����v*Ӏ��]LP.J�