async-grpc-xds 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba6859fd43ebb2de75d228d4511125d1c7b36f08321fdda99eabf573fea900a
-  data.tar.gz: 2bca6eb3ec749a434703f0296f6a12c14e6d75f5518930618355e3abd8b37d83
+  metadata.gz: 668ae495babdb4aa2afd890a356bf9f7d80f4e1649213af63e5e0804432983ba
+  data.tar.gz: 3634be8ae4e830a673c5706de0c7ed2f08462de1edcee0c7ffc401f9b1d3b2ab
 SHA512:
-  metadata.gz: 78f056024e2e5c0cfbf1e1ca67acf9edd9b6ca357659911cbd733eeb2fde2ff0d73c169724a2caebd1ea1860bfaa09ce07784d950a5e9908c9c1a07c2021e81d
-  data.tar.gz: 4e9a3490cfb4e8918994301ef300a2780929dffd31dec5278bf690f976e37681e9476f58899fc668f9799d3d9398fbc740654d42599a7ee8b01c265a47a70e7b
+  metadata.gz: 4596e7e891e0a716f3cf8126f1801975114090c52c75d7c288550c4ce40109d51f14c6afb6e729a01d1d6f24ead8da17b2f3b74bcff3157b76c443cd60edebb5
+  data.tar.gz: 14f57efc4e56588c8ff1819838ae1894ddd33a54b823c8c577c7addf30e0efed2742a4cd11cceefb559e1615d9198065860534b981b14bd7b0b91aae8eb13391

data/lib/async/grpc/xds/ads_stream.rb

@@ -24,6 +24,10 @@ module Async
 					end
 				end
 				
+				# Initialize an ADS stream.
+				# @parameter client [Async::GRPC::Client] The gRPC client used to open the stream.
+				# @parameter node [Envoy::Config::Core::V3::Node] The xDS node identity.
+				# @parameter delegate [Delegate] The object that receives stream events.
 				def initialize(client, node, delegate:)
 					@client = client
 					@node = node

data/lib/async/grpc/xds/control_plane.rb

@@ -21,6 +21,8 @@ module Async
 				CLUSTER_TYPE = ResourceBuilder::CLUSTER_TYPE
 				ENDPOINT_TYPE = ResourceBuilder::ENDPOINT_TYPE
 				
+				# Initialize an empty control plane.
+				# @parameter identifier [String] The identifier reported in discovery responses.
 				def initialize(identifier: "async-grpc-xds")
 					@identifier = identifier
 					@resources = Hash.new{|hash, type_url| hash[type_url] = {}}
@@ -31,11 +33,18 @@ module Async
 				
 				attr :identifier
 				
+				# Add or replace a cluster resource.
+				# @parameter name [String] The cluster name.
+				# @parameter resource [Envoy::Config::Cluster::V3::Cluster | Nil] An existing cluster resource, or `nil` to build one from `options`.
+				# @parameter options [Hash] Options forwarded to {ResourceBuilder.cluster}.
 				def update_cluster(name, resource = nil, **options)
 					resource ||= ResourceBuilder.cluster(name, **options)
 					update_resource(CLUSTER_TYPE, name.to_s, resource)
 				end
 				
+				# Add or replace the endpoint assignment for a cluster.
+				# @parameter cluster_name [String] The cluster name.
+				# @parameter endpoints [Array(Hash)] The normalized endpoint states.
 				def update_endpoints(cluster_name, endpoints)
 					update_resource(
 						ENDPOINT_TYPE,
@@ -44,14 +53,22 @@ module Async
 					)
 				end
 				
+				# Remove a cluster resource.
+				# @parameter name [String] The cluster name.
 				def remove_cluster(name)
 					remove_resource(CLUSTER_TYPE, name.to_s)
 				end
 				
+				# Remove the endpoint assignment for a cluster.
+				# @parameter cluster_name [String] The cluster name.
 				def remove_endpoints(cluster_name)
 					remove_resource(ENDPOINT_TYPE, cluster_name.to_s)
 				end
 				
+				# Add or replace an xDS resource and notify subscribed streams.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @parameter name [String] The resource name.
+				# @parameter resource [Google::Protobuf::MessageExts] The protobuf resource.
 				def update_resource(type_url, name, resource)
 					notify = false
 					
@@ -64,6 +81,9 @@ module Async
 					notify_streams(type_url) if notify
 				end
 				
+				# Remove an xDS resource and notify subscribed streams.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @parameter name [String] The resource name.
 				def remove_resource(type_url, name)
 					notify = false
 					
@@ -77,12 +97,19 @@ module Async
 					notify_streams(type_url) if notify
 				end
 				
+				# Get the available resource names for a type.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @returns [Array(String)] The resource names.
 				def resource_names(type_url)
 					@mutex.synchronize do
 						@resources[type_url].keys
 					end
 				end
 				
+				# Get resources of a given type.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @parameter names [Array(String) | Nil] The requested resource names, or `nil` for all resources.
+				# @returns [Array(Google::Protobuf::MessageExts)] The matching resources.
 				def resources(type_url, names = nil)
 					@mutex.synchronize do
 						resources = @resources[type_url]
@@ -95,12 +122,19 @@ module Async
 					end
 				end
 				
+				# Get the current version for a resource type.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @returns [String] The monotonically increasing version.
 				def version(type_url)
 					@mutex.synchronize do
 						@versions[type_url].to_s
 					end
 				end
 				
+				# Build a discovery response for a resource type.
+				# @parameter type_url [String] The xDS resource type URL.
+				# @parameter names [Array(String) | Nil] The requested resource names, or `nil` for all resources.
+				# @returns [Envoy::Service::Discovery::V3::DiscoveryResponse] The current discovery response.
 				def response(type_url, names = nil)
 					resources = self.resources(type_url, names)
 					version = self.version(type_url)
@@ -114,12 +148,16 @@ module Async
 					)
 				end
 				
+				# Register a stream to receive resource-change notifications.
+				# @parameter stream [Service::Stream] The stream to register.
 				def register_stream(stream)
 					@mutex.synchronize do
 						@streams.add(stream)
 					end
 				end
 				
+				# Remove a registered stream.
+				# @parameter stream [Service::Stream] The stream to remove.
 				def remove_stream(stream)
 					@mutex.synchronize do
 						@streams.delete(stream)

data/lib/async/grpc/xds/discovery_client.rb

@@ -152,15 +152,22 @@ module Async
 			# ADSStream::Delegate interface - must be public for ADSStream to call
 			public
 				
+				# Record that an ADS stream has opened and unblock pending subscriptions.
+				# @parameter stream [ADSStream] The opened stream.
 				def stream_opened(stream)
 					@mutex.synchronize{@ads_stream = stream}
 					@stream_ready_promise&.resolve(stream)
 				end
 				
+				# Record that an ADS stream has closed.
+				# @parameter stream [ADSStream] The closed stream.
 				def stream_closed(stream)
 					@mutex.synchronize{@ads_stream = nil}
 				end
 				
+				# Process a discovery response received by an ADS stream.
+				# @parameter response [Envoy::Service::Discovery::V3::DiscoveryResponse] The received response.
+				# @parameter stream [ADSStream] The stream that received the response.
 				def discovery_response(response, stream)
 					process_response(response, stream)
 				end

data/lib/async/grpc/xds/resource_builder.rb

@@ -24,6 +24,9 @@ module Async
 				CLUSTER_TYPE = "#{TYPE_URL_PREFIX}/envoy.config.cluster.v3.Cluster"
 				ENDPOINT_TYPE = "#{TYPE_URL_PREFIX}/envoy.config.endpoint.v3.ClusterLoadAssignment"
 				
+				# Pack a protobuf resource into a `google.protobuf.Any` message.
+				# @parameter resource [Google::Protobuf::MessageExts] The protobuf resource to pack.
+				# @returns [Google::Protobuf::Any] The packed resource.
 				def self.pack(resource)
 					Google::Protobuf::Any.new(
 						type_url: "#{TYPE_URL_PREFIX}/#{resource.class.descriptor.name}",
@@ -31,8 +34,16 @@ module Async
 					)
 				end
 				
-				def self.cluster(name, service_name: name, load_balancer_policy: :round_robin, connect_timeout: 5)
-					Envoy::Config::Cluster::V3::Cluster.new(
+				# Build an EDS cluster resource.
+				# @parameter name [String] The cluster name.
+				# @parameter service_name [String] The EDS service name.
+				# @parameter load_balancer_policy [Symbol] The Envoy load-balancing policy.
+				# @parameter connect_timeout [Numeric] The upstream connection timeout in seconds.
+				# @parameter protocol [Symbol] The canonical upstream protocol, either `:http1` or `:http2`.
+				# @returns [Envoy::Config::Cluster::V3::Cluster] The generated cluster resource.
+				# @raises [ArgumentError] If the upstream protocol is unsupported.
+				def self.cluster(name, service_name: name, load_balancer_policy: :round_robin, connect_timeout: 5, protocol: :http2)
+					options = {
 						name: name.to_s,
 						type: Envoy::Config::Cluster::V3::Cluster::DiscoveryType::EDS,
 						eds_cluster_config: Envoy::Config::Cluster::V3::Cluster::EdsClusterConfig.new(
@@ -43,10 +54,24 @@ module Async
 						),
 						connect_timeout: duration(connect_timeout),
 						lb_policy: load_balancer_policy_value(load_balancer_policy),
-						http2_protocol_options: Envoy::Config::Core::V3::Http2ProtocolOptions.new
-					)
+					}
+					
+					case protocol
+					when :http1
+						# Envoy uses HTTP/1 by default.
+					when :http2
+						options[:http2_protocol_options] = Envoy::Config::Core::V3::Http2ProtocolOptions.new
+					else
+						raise ArgumentError, "Unsupported upstream protocol: #{protocol.inspect}"
+					end
+					
+					Envoy::Config::Cluster::V3::Cluster.new(**options)
 				end
 				
+				# Build an EDS cluster load assignment from normalized endpoint state.
+				# @parameter cluster_name [String] The cluster name.
+				# @parameter endpoints [Array(Hash)] The endpoints, each containing `:addresses` and `:healthy`.
+				# @returns [Envoy::Config::Endpoint::V3::ClusterLoadAssignment] The generated load assignment.
 				def self.cluster_load_assignment(cluster_name, endpoints)
 					Envoy::Config::Endpoint::V3::ClusterLoadAssignment.new(
 						cluster_name: cluster_name.to_s,
@@ -57,55 +82,67 @@ module Async
 						]
 					)
 				end
-					
+				
+				# Build an Envoy load-balancer endpoint from normalized endpoint state.
+				# @parameter endpoint [Hash] The endpoint containing `:addresses` and `:healthy`.
+				# @returns [Envoy::Config::Endpoint::V3::LbEndpoint] The generated load-balancer endpoint.
+				# @raises [KeyError] If required endpoint state is missing.
+				# @raises [ArgumentError] If the endpoint has no addresses.
 				def self.load_balancer_endpoint(endpoint)
-					endpoint = normalize_endpoint(endpoint)
-						
+					addresses, healthy = endpoint.fetch_values(:addresses, :healthy)
+					raise ArgumentError, "An endpoint requires at least one address!" if addresses.empty?
+					
+					address, *additional_addresses = addresses
+					
 					Envoy::Config::Endpoint::V3::LbEndpoint.new(
 						endpoint: Envoy::Config::Endpoint::V3::Endpoint.new(
-							address: Envoy::Config::Core::V3::Address.new(
-								socket_address: Envoy::Config::Core::V3::SocketAddress.new(
-									protocol: Envoy::Config::Core::V3::SocketAddress::Protocol::TCP,
-									address: endpoint[:address],
-									port_value: endpoint[:port]
+							address: build_address(address),
+							additional_addresses: additional_addresses.map do |additional_address|
+								Envoy::Config::Endpoint::V3::Endpoint::AdditionalAddress.new(
+									address: build_address(additional_address)
 								)
-							),
-							hostname: endpoint[:hostname].to_s
+							end
 						),
-						health_status: health_status_value(endpoint.fetch(:healthy, true))
+						health_status: health_status_value(healthy)
 					)
 				end
-					
-				def self.normalize_endpoint(endpoint)
-					case endpoint
-					when Hash
-						{
-							address: endpoint.fetch(:address){endpoint.fetch("address")},
-							port: endpoint.fetch(:port){endpoint.fetch("port")}.to_i,
-							hostname: endpoint[:hostname] || endpoint["hostname"],
-							healthy: endpoint.key?(:healthy) ? endpoint[:healthy] : endpoint.fetch("healthy", true)
-						}
+				
+				# Build an Envoy address from a normalized IP or Unix address.
+				# @parameter address [Hash] An IP `:address` and `:port`, or a Unix `:path`.
+				# @returns [Envoy::Config::Core::V3::Address] The generated Envoy address.
+				# @raises [KeyError] If required IP address state is missing.
+				# @private
+				def self.build_address(address)
+					if path = address[:path]
+						Envoy::Config::Core::V3::Address.new(
+							pipe: Envoy::Config::Core::V3::Pipe.new(path: path)
+						)
 					else
-						if endpoint.respond_to?(:address) && endpoint.respond_to?(:port)
-							{
-								address: endpoint.address,
-								port: endpoint.port.to_i,
-								hostname: endpoint.respond_to?(:hostname) ? endpoint.hostname : nil,
-								healthy: endpoint.respond_to?(:healthy?) ? endpoint.healthy? : true
-							}
-						else
-							raise ArgumentError, "Invalid endpoint: #{endpoint.inspect}"
-						end
+						Envoy::Config::Core::V3::Address.new(
+							socket_address: Envoy::Config::Core::V3::SocketAddress.new(
+								protocol: Envoy::Config::Core::V3::SocketAddress::Protocol::TCP,
+								address: address.fetch(:address),
+								port_value: address.fetch(:port)
+							)
+						)
 					end
 				end
-					
+				
+				private_class_method :build_address
+				
+				# Convert seconds to a protobuf duration.
+				# @parameter seconds [Numeric] The duration in seconds.
+				# @returns [Google::Protobuf::Duration] The protobuf duration.
 				def self.duration(seconds)
 					whole_seconds = seconds.to_i
 					nanos = ((seconds.to_f - whole_seconds) * 1_000_000_000).to_i
-						
+					
 					Google::Protobuf::Duration.new(seconds: whole_seconds, nanos: nanos)
 				end
-					
+				
+				# Convert a load-balancer policy name to its Envoy enum value.
+				# @parameter load_balancer_policy [Symbol | String | Integer] The load-balancer policy.
+				# @returns [Integer] The Envoy load-balancer policy enum value.
 				def self.load_balancer_policy_value(load_balancer_policy)
 					case load_balancer_policy
 					when :round_robin, :ROUND_ROBIN, "round_robin", "ROUND_ROBIN"
@@ -118,7 +155,10 @@ module Async
 						load_balancer_policy
 					end
 				end
-					
+				
+				# Convert an endpoint health status to its Envoy enum value.
+				# @parameter healthy [Boolean | Symbol | String] The normalized health status.
+				# @returns [Integer] The Envoy health-status enum value.
 				def self.health_status_value(healthy)
 					case healthy
 					when :healthy, :HEALTHY, "healthy", "HEALTHY", true
@@ -135,4 +175,3 @@ module Async
 		end
 	end
 end
-	

data/lib/async/grpc/xds/resource_cache.rb

@@ -9,6 +9,7 @@ module Async
 			# Caches discovered xDS resources
 			# Thread-safe cache for clusters and endpoints
 			class ResourceCache
+				# Initialize an empty resource cache.
 				def initialize
 					@clusters = {}
 					@endpoints = {}

data/lib/async/grpc/xds/resources.rb

@@ -6,6 +6,7 @@
 module Async
 	module GRPC
 		module XDS
+			# @namespace
 			module Resources
 				# Represents a discovered cluster
 				# Based on envoy.config.cluster.v3.Cluster
@@ -40,6 +41,8 @@ module Async
 						new(proto)
 					end
 					
+					# Determine whether this cluster uses the Endpoint Discovery Service.
+					# @returns [Boolean] `true` if the cluster uses EDS.
 					def eds_cluster?
 						@type == :EDS
 					end
@@ -216,6 +219,8 @@ module Async
 				class Endpoint
 					attr_reader :address, :port, :health_status, :metadata
 					
+					# Initialize an endpoint from a protobuf message or hash.
+					# @parameter load_balancer_endpoint [Envoy::Config::Endpoint::V3::LbEndpoint | Hash] The load-balancer endpoint representation.
 					def initialize(load_balancer_endpoint)
 						if load_balancer_endpoint.is_a?(Hash)
 							endpoint_data = load_balancer_endpoint[:endpoint] || {}
@@ -235,10 +240,14 @@ module Async
 						end
 					end
 					
+					# Determine whether this endpoint is eligible to receive traffic.
+					# @returns [Boolean] `true` if the endpoint is healthy or has unknown health.
 					def healthy?
 						@health_status == :HEALTHY || @health_status == :UNKNOWN
 					end
 					
+					# Build the HTTP URI for this endpoint.
+					# @returns [String] The endpoint URI.
 					def uri
 						# Use http for insecure/docker environments (gRPC h2c)
 						scheme = ENV["XDS_ENDPOINT_SCHEME"] || "http"

data/lib/async/grpc/xds/server.rb

@@ -14,6 +14,9 @@ module Async
 		module XDS
 			# Convenience wrapper for serving an xDS control plane over gRPC.
 			class Server
+				# Initialize an xDS server.
+				# @parameter control_plane [ControlPlane] The control plane to serve.
+				# @parameter options [Hash] Default options forwarded to `Async::HTTP::Server`.
 				def initialize(control_plane = ControlPlane.new, **options)
 					@control_plane = control_plane
 					@dispatcher = Async::GRPC::Dispatcher.new
@@ -24,6 +27,10 @@ module Async
 				attr :control_plane
 				attr :dispatcher
 				
+				# Run the xDS server on an endpoint.
+				# @parameter endpoint [Async::HTTP::Endpoint] The endpoint to bind.
+				# @parameter options [Hash] Options forwarded to `Async::HTTP::Server`.
+				# @asynchronous
 				def run(endpoint, **options)
 					server = Async::HTTP::Server.new(@dispatcher, endpoint, **@options, **options)
 					server.run

data/lib/async/grpc/xds/service.rb

@@ -21,11 +21,18 @@ module Async
 			class Service < Async::GRPC::Service
 				SERVICE_NAME = "envoy.service.discovery.v3.AggregatedDiscoveryService"
 				
+				# Initialize an Aggregated Discovery Service.
+				# @parameter control_plane [ControlPlane] The control plane that provides resources.
 				def initialize(control_plane)
 					super(Envoy::Service::Discovery::V3::AggregatedDiscoveryService, SERVICE_NAME)
 					@control_plane = control_plane
 				end
 				
+				# Serve a state-of-the-world Aggregated Discovery Service stream.
+				# @parameter input [Enumerable] The stream of discovery requests.
+				# @parameter output [Interface(:write)] The discovery response stream.
+				# @parameter call [Object] The gRPC call context.
+				# @asynchronous
 				def stream_aggregated_resources(input, output, call)
 					stream = Stream.new(@control_plane, output)
 					@control_plane.register_stream(stream)
@@ -48,6 +55,11 @@ module Async
 					@control_plane.remove_stream(stream) if stream
 				end
 				
+				# Reject a delta Aggregated Discovery Service stream, which is not supported.
+				# @parameter input [Enumerable] The stream of delta discovery requests.
+				# @parameter output [Interface(:write)] The delta discovery response stream.
+				# @parameter call [Object] The gRPC call context.
+				# @raises [Protocol::GRPC::Error] Always raised because delta xDS is not implemented.
 				def delta_aggregated_resources(input, output, call)
 					raise Protocol::GRPC::Error.new(
 						Protocol::GRPC::Status::UNIMPLEMENTED,
@@ -57,6 +69,9 @@ module Async
 				
 				# Represents one ADS stream and its subscribed resources.
 				class Stream
+					# Initialize an ADS stream.
+					# @parameter control_plane [ControlPlane] The control plane that provides resources.
+					# @parameter output [Interface(:write)] The discovery response stream.
 					def initialize(control_plane, output)
 						@control_plane = control_plane
 						@output = output
@@ -66,6 +81,8 @@ module Async
 						@closed = false
 					end
 					
+					# Process a discovery request and update the stream's subscriptions.
+					# @parameter request [Envoy::Service::Discovery::V3::DiscoveryRequest] The discovery request.
 					def request(request)
 						return if request.type_url.nil? || request.type_url.empty?
 						
@@ -83,10 +100,14 @@ module Async
 						@queue << request.type_url
 					end
 					
+					# Schedule a resource type for delivery after it changes.
+					# @parameter type_url [String] The changed xDS resource type URL.
 					def changed(type_url)
 						@queue << type_url unless @closed
 					end
 					
+					# Deliver scheduled resource updates until the stream closes.
+					# @asynchronous
 					def run
 						until @closed
 							type_url = @queue.dequeue
@@ -94,6 +115,8 @@ module Async
 						end
 					end
 					
+					# Deliver the latest resource version for a subscribed type.
+					# @parameter type_url [String] The xDS resource type URL.
 					def flush(type_url)
 						names = @subscriptions[type_url]
 						return unless names
@@ -106,6 +129,7 @@ module Async
 						@versions[type_url] = version
 					end
 					
+					# Close the stream and stop waiting for changes.
 					def close
 						@closed = true
 						@queue.close

data/lib/async/grpc/xds/version.rb

@@ -3,10 +3,13 @@
 # Released under the MIT License.
 # Copyright, 2026, by Samuel Williams.
 
+# @namespace
 module Async
+	# @namespace
 	module GRPC
+		# @namespace
 		module XDS
-			VERSION = "0.0.1"
+			VERSION = "0.1.0"
 		end
 	end
 end

data/readme.md

@@ -19,7 +19,7 @@ This is an early implementation focused on ADS with CDS and EDS. LDS/RDS, full r
 The `xds/` directory contains a Docker Compose integration environment with a Go xDS control plane and Ruby gRPC backends.
 
 ``` bash
-docker-compose -f xds/docker-compose.yaml up --exit-code-from tests
+docker compose -f xds/docker-compose.yaml up --build --exit-code-from tests
 ```
 
 ## Releases
@@ -28,7 +28,15 @@ Please see the [project releases](https://socketry.github.io/async-grpc-xds/rele
 
 ### v0.1.0
 
-  - Initial extraction from `async-grpc`.
+  - Add complete documentation coverage for the public xDS API.
+  - Support grouped IP and Unix-domain-socket addresses in EDS endpoints.
+  - Support selecting HTTP/1 or HTTP/2 for generated clusters.
+
+### v0.1.0
+
+  - Add complete documentation coverage for the public xDS API.
+  - Support grouped IP and Unix-domain-socket addresses in EDS endpoints.
+  - Support selecting HTTP/1 or HTTP/2 for generated clusters.
 
 ## See Also
 

data/releases.md

@@ -1,5 +1,11 @@
 # Releases
 
+## v0.1.0
+
+  - Add complete documentation coverage for the public xDS API.
+  - Support grouped IP and Unix-domain-socket addresses in EDS endpoints.
+  - Support selecting HTTP/1 or HTTP/2 for generated clusters.
+
 ## v0.1.0
 
   - Initial extraction from `async-grpc`.

data/xds/readme.md

@@ -11,38 +11,11 @@ The Docker Compose setup includes:
 
 ## Running Tests
 
-### Start the environment
+From this directory:
 
 ```bash
 cd xds
-bundle install  # generates gems.locked for Docker build
-docker compose up -d
-```
-
-### Wait for services to be ready
-
-```bash
-docker compose ps
-```
-
-All services should show as "healthy" or "running".
-
-### Run tests
-
-```bash
-# Run tests in docker compose
-docker compose run --rm tests
-
-# Or run tests locally (if services are accessible)
-# Set XDS_SERVER_URI environment variable
-export XDS_SERVER_URI=xds-control-plane:18000
-bundle exec sus xds/test
-```
-
-### Cleanup
-
-```bash
-docker compose down
+docker compose up --build --exit-code-from tests
 ```
 
 ## Test Structure

data/xds/test/async/grpc/xds/control_plane.rb

@@ -33,8 +33,8 @@ describe Async::GRPC::XDS::ControlPlane do
 		control_plane.update_endpoints(
 			"myservice",
 			[
-				{address: "127.0.0.1", port: 50051},
-				{address: "127.0.0.2", port: 50052, healthy: false}
+				{addresses: [{address: "127.0.0.1", port: 50051}], healthy: true},
+				{addresses: [{address: "127.0.0.2", port: 50052}], healthy: false}
 			]
 		)
 		
@@ -49,15 +49,15 @@ describe Async::GRPC::XDS::ControlPlane do
 	end
 	
 	it "increments resource versions" do
-		control_plane.update_endpoints("myservice", [{address: "127.0.0.1", port: 50051}])
-		control_plane.update_endpoints("myservice", [{address: "127.0.0.2", port: 50052}])
+		control_plane.update_endpoints("myservice", [{addresses: [{address: "127.0.0.1", port: 50051}], healthy: true}])
+		control_plane.update_endpoints("myservice", [{addresses: [{address: "127.0.0.2", port: 50052}], healthy: true}])
 		
 		expect(control_plane.version(Async::GRPC::XDS::ControlPlane::ENDPOINT_TYPE)).to be == "2"
 	end
 	
 	it "serves resources over ADS" do
 		control_plane.update_cluster("myservice")
-		control_plane.update_endpoints("myservice", [{address: "127.0.0.1", port: 50051}])
+		control_plane.update_endpoints("myservice", [{addresses: [{address: "127.0.0.1", port: 50051}], healthy: true}])
 		
 		port = available_port
 		endpoint = Async::HTTP::Endpoint.parse(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-grpc-xds
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Samuel Williams