async-grpc-xds 0.0.1

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/grpc/xds/control_plane"
+require "async/grpc/xds/client"
+require "async/grpc/xds/resource_builder"
+require "async/grpc/xds/server"
+require "async/http/endpoint"
+require "sus/fixtures/async"
+require "socket"
+
+describe Async::GRPC::XDS::ControlPlane do
+	include Sus::Fixtures::Async::ReactorContext
+	
+	let(:control_plane) {subject.new}
+	
+	it "publishes cluster resources" do
+		control_plane.update_cluster("myservice")
+		
+		response = control_plane.response(
+			Async::GRPC::XDS::ControlPlane::CLUSTER_TYPE,
+			["myservice"]
+		)
+		
+		expect(response.version_info).to be == "1"
+		expect(response.resources.size).to be == 1
+		expect(response.resources.first.type_url).to be == Async::GRPC::XDS::ControlPlane::CLUSTER_TYPE
+	end
+	
+	it "publishes endpoint resources" do
+		control_plane.update_endpoints(
+			"myservice",
+			[
+				{address: "127.0.0.1", port: 50051},
+				{address: "127.0.0.2", port: 50052, healthy: false}
+			]
+		)
+		
+		response = control_plane.response(
+			Async::GRPC::XDS::ControlPlane::ENDPOINT_TYPE,
+			["myservice"]
+		)
+		
+		expect(response.version_info).to be == "1"
+		expect(response.resources.size).to be == 1
+		expect(response.resources.first.type_url).to be == Async::GRPC::XDS::ControlPlane::ENDPOINT_TYPE
+	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}])
+		
+		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}])
+		
+		port = available_port
+		endpoint = Async::HTTP::Endpoint.parse(
+			"http://127.0.0.1:#{port}",
+			protocol: Async::HTTP::Protocol::HTTP2
+		)
+		server = Async::GRPC::XDS::Server.new(control_plane)
+		server_task = Async{server.run(endpoint)}
+		
+		client = Async::GRPC::XDS::Client.new("myservice", bootstrap: {
+			xds_servers: [
+				{
+					server_uri: "127.0.0.1:#{port}",
+					channel_creds: [{type: "insecure"}]
+				}
+			],
+			node: {id: "test-#{Process.pid}", cluster: "test"}
+		})
+		
+		endpoints = client.resolve_endpoints
+		
+		expect(endpoints.map(&:authority)).to be == ["127.0.0.1:50051"]
+	ensure
+		client&.close
+		server_task&.stop
+	end
+	
+	def available_port
+		server = TCPServer.new("127.0.0.1", 0)
+		server.addr[1]
+	ensure
+		server&.close
+	end
+end

data/xds/test_server.go

@@ -0,0 +1,355 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
+	"github.com/envoyproxy/go-control-plane/pkg/cache/types"
+	"github.com/envoyproxy/go-control-plane/pkg/cache/v3"
+	"github.com/envoyproxy/go-control-plane/pkg/resource/v3"
+	serverv3 "github.com/envoyproxy/go-control-plane/pkg/server/v3"
+
+	clusterv3 "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3"
+	corev3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
+	endpointv3 "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3"
+	discovery "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3"
+)
+
+var (
+	port      = flag.Int("port", 18000, "xDS server port")
+	adminPort = flag.Int("admin-port", 18001, "Admin HTTP server port")
+	upstream  = flag.String("upstream", "backend-1:50051,backend-2:50052,backend-3:50053", "Comma-separated list of upstream endpoints")
+)
+
+// Custom hash function that accepts any node ID for testing
+type anyNodeHash struct{}
+
+func (h *anyNodeHash) ID(node *corev3.Node) string {
+	return "any"
+}
+
+func main() {
+	flag.Parse()
+
+	ctx := context.Background()
+	version := uint64(1)
+
+	// Create snapshot with cluster and endpoints
+	snapshot, err := createSnapshot(*upstream, fmt.Sprintf("%d", version))
+	if err != nil {
+		log.Fatalf("Failed to create snapshot: %v", err)
+	}
+
+	// For testing, accept any node ID by using a custom hash that always returns the same key
+	// This allows any client to connect and get the same snapshot
+	snapshotCache := cache.NewSnapshotCache(false, &anyNodeHash{}, nil)
+	if err := snapshotCache.SetSnapshot(ctx, "any", snapshot); err != nil {
+		log.Fatalf("Failed to set snapshot: %v", err)
+	}
+	log.Printf("Set snapshot for any node ID")
+
+	// Create callbacks for logging
+	callbacks := serverv3.CallbackFuncs{
+		StreamOpenFunc: func(ctx context.Context, streamID int64, typeURL string) error {
+			log.Printf("Stream opened: streamID=%d, typeURL=%s", streamID, typeURL)
+			return nil
+		},
+		StreamRequestFunc: func(streamID int64, request *discovery.DiscoveryRequest) error {
+			log.Printf("Stream request: streamID=%d, typeURL=%s, resource_names=%v", streamID, request.TypeUrl, request.ResourceNames)
+			return nil
+		},
+	}
+
+	// Create xDS server with callbacks
+	srv := serverv3.NewServer(ctx, snapshotCache, callbacks)
+
+	// Start gRPC server
+	baseListener, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
+	if err != nil {
+		log.Fatalf("Failed to listen: %v", err)
+	}
+	lis := newTrackingListener(baseListener)
+
+	// Create gRPC server with insecure credentials (for testing without TLS)
+	grpcServer := grpc.NewServer(grpc.Creds(insecure.NewCredentials()))
+	discovery.RegisterAggregatedDiscoveryServiceServer(grpcServer, srv)
+
+	admin := &adminServer{
+		ctx:           ctx,
+		cache:         snapshotCache,
+		listener:      lis,
+		version:       &version,
+		currentConfig: *upstream,
+	}
+	go admin.serve(*adminPort)
+
+	log.Printf("xDS test server listening on :%d", *port)
+	log.Printf("xDS admin server listening on :%d", *adminPort)
+	log.Printf("Serving cluster 'myservice' with endpoints: %s", *upstream)
+
+	if err := grpcServer.Serve(lis); err != nil {
+		log.Fatalf("Failed to serve: %v", err)
+	}
+}
+
+type adminServer struct {
+	ctx           context.Context
+	cache         cache.SnapshotCache
+	listener      *trackingListener
+	version       *uint64
+	mutex         sync.Mutex
+	currentConfig string
+}
+
+type endpointsRequest struct {
+	Upstream  string   `json:"upstream"`
+	Endpoints []string `json:"endpoints"`
+}
+
+func (server *adminServer) serve(port int) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/endpoints", server.handleEndpoints)
+	mux.HandleFunc("/reset-streams", server.handleResetStreams)
+	mux.HandleFunc("/status", server.handleStatus)
+
+	if err := http.ListenAndServe(fmt.Sprintf(":%d", port), mux); err != nil {
+		log.Fatalf("Failed to serve admin API: %v", err)
+	}
+}
+
+func (server *adminServer) handleEndpoints(response http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var body endpointsRequest
+	if err := json.NewDecoder(request.Body).Decode(&body); err != nil {
+		http.Error(response, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	upstreams := body.Upstream
+	if upstreams == "" {
+		upstreams = strings.Join(body.Endpoints, ",")
+	}
+
+	nextVersion := atomic.AddUint64(server.version, 1)
+	snapshot, err := createSnapshot(upstreams, fmt.Sprintf("%d", nextVersion))
+	if err != nil {
+		http.Error(response, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err := server.cache.SetSnapshot(server.ctx, "any", snapshot); err != nil {
+		http.Error(response, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	server.mutex.Lock()
+	server.currentConfig = upstreams
+	server.mutex.Unlock()
+
+	log.Printf("Updated snapshot version %d with endpoints: %s", nextVersion, upstreams)
+	writeJSON(response, map[string]any{
+		"version":   nextVersion,
+		"endpoints": parseEndpoints(upstreams),
+	})
+}
+
+func (server *adminServer) handleResetStreams(response http.ResponseWriter, request *http.Request) {
+	if request.Method != http.MethodPost {
+		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	closed := server.listener.closeConnections()
+	log.Printf("Reset %d active xDS connections", closed)
+	writeJSON(response, map[string]any{"closed": closed})
+}
+
+func (server *adminServer) handleStatus(response http.ResponseWriter, request *http.Request) {
+	server.mutex.Lock()
+	currentConfig := server.currentConfig
+	server.mutex.Unlock()
+
+	writeJSON(response, map[string]any{
+		"version":   atomic.LoadUint64(server.version),
+		"endpoints": parseEndpoints(currentConfig),
+	})
+}
+
+func writeJSON(response http.ResponseWriter, value any) {
+	response.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(response).Encode(value); err != nil {
+		log.Printf("Failed to write JSON response: %v", err)
+	}
+}
+
+type trackingListener struct {
+	net.Listener
+	mutex       sync.Mutex
+	connections map[net.Conn]struct{}
+}
+
+func newTrackingListener(listener net.Listener) *trackingListener {
+	return &trackingListener{
+		Listener:    listener,
+		connections: make(map[net.Conn]struct{}),
+	}
+}
+
+func (listener *trackingListener) Accept() (net.Conn, error) {
+	connection, err := listener.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+
+	tracked := &trackedConn{Conn: connection, listener: listener}
+	listener.mutex.Lock()
+	listener.connections[tracked] = struct{}{}
+	listener.mutex.Unlock()
+
+	return tracked, nil
+}
+
+func (listener *trackingListener) closeConnections() int {
+	listener.mutex.Lock()
+	connections := make([]net.Conn, 0, len(listener.connections))
+	for connection := range listener.connections {
+		connections = append(connections, connection)
+	}
+	listener.mutex.Unlock()
+
+	for _, connection := range connections {
+		_ = connection.Close()
+	}
+
+	return len(connections)
+}
+
+func (listener *trackingListener) remove(connection net.Conn) {
+	listener.mutex.Lock()
+	delete(listener.connections, connection)
+	listener.mutex.Unlock()
+}
+
+type trackedConn struct {
+	net.Conn
+	listener *trackingListener
+	once     sync.Once
+}
+
+func (connection *trackedConn) Close() error {
+	err := connection.Conn.Close()
+	connection.once.Do(func() {
+		connection.listener.remove(connection)
+	})
+	return err
+}
+
+func createSnapshot(upstreams string, version string) (*cache.Snapshot, error) {
+	// Parse upstream endpoints
+	endpoints := parseEndpoints(upstreams)
+
+	// Create cluster
+	cluster := &clusterv3.Cluster{
+		Name:                 "myservice",
+		ClusterDiscoveryType: &clusterv3.Cluster_Type{Type: clusterv3.Cluster_EDS},
+		LbPolicy:             clusterv3.Cluster_ROUND_ROBIN,
+		EdsClusterConfig: &clusterv3.Cluster_EdsClusterConfig{
+			ServiceName: "myservice",
+			EdsConfig: &corev3.ConfigSource{
+				ConfigSourceSpecifier: &corev3.ConfigSource_Ads{},
+			},
+		},
+	}
+
+	// Create endpoint assignment
+	lbEndpoints := make([]*endpointv3.LbEndpoint, 0, len(endpoints))
+	for _, ep := range endpoints {
+		lbEndpoints = append(lbEndpoints, &endpointv3.LbEndpoint{
+			HostIdentifier: &endpointv3.LbEndpoint_Endpoint{
+				Endpoint: &endpointv3.Endpoint{
+					Address: &corev3.Address{
+						Address: &corev3.Address_SocketAddress{
+							SocketAddress: &corev3.SocketAddress{
+								Protocol: corev3.SocketAddress_TCP,
+								Address:  ep.Host,
+								PortSpecifier: &corev3.SocketAddress_PortValue{
+									PortValue: ep.Port,
+								},
+							},
+						},
+					},
+				},
+			},
+			HealthStatus: corev3.HealthStatus_HEALTHY,
+		})
+	}
+
+	endpointAssignment := &endpointv3.ClusterLoadAssignment{
+		ClusterName: "myservice",
+		Endpoints: []*endpointv3.LocalityLbEndpoints{
+			{
+				LbEndpoints: lbEndpoints,
+			},
+		},
+	}
+
+	// Create snapshot
+	// types.Resource is proto.Message, which Cluster and ClusterLoadAssignment implement
+	return cache.NewSnapshot(
+		version,
+		map[resource.Type][]types.Resource{
+			resource.ClusterType:  {cluster},
+			resource.EndpointType: {endpointAssignment},
+		},
+	)
+}
+
+type endpoint struct {
+	Host string `json:"host"`
+	Port uint32 `json:"port"`
+}
+
+func parseEndpoints(upstreams string) []endpoint {
+	var endpoints []endpoint
+	parts := splitComma(upstreams)
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+
+		host, port := parseHostPort(part)
+		endpoints = append(endpoints, endpoint{Host: host, Port: port})
+	}
+	return endpoints
+}
+
+func splitComma(s string) []string {
+	return strings.Split(s, ",")
+}
+
+func parseHostPort(addr string) (string, uint32) {
+	parts := strings.Split(addr, ":")
+	if len(parts) == 2 {
+		var port uint32
+		fmt.Sscanf(parts[1], "%d", &port)
+		if port > 0 {
+			return parts[0], port
+		}
+	}
+	return addr, 50051
+}

data/xds/update_protos.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# Update Envoy protobuf definitions
+# This script clones the envoy data-plane-api and copies only the needed .proto files
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+PROTO_DIR="$PROJECT_ROOT/proto"
+TEMP_DIR="/tmp/envoy-api-$$"
+
+echo "Cloning envoyproxy/data-plane-api..."
+
+# Clone with sparse checkout to only get what we need
+git clone --depth 1 --filter=blob:none --sparse https://github.com/envoyproxy/data-plane-api.git "$TEMP_DIR"
+
+cd "$TEMP_DIR"
+
+echo "Setting up sparse checkout..."
+
+# First get envoy config files
+git sparse-checkout set \
+  envoy/config/cluster/v3 \
+  envoy/config/endpoint/v3 \
+  envoy/config/listener/v3 \
+  envoy/config/route/v3 \
+  envoy/config/core/v3 \
+  envoy/extensions/transport_sockets/tls/v3
+
+# Copy envoy config files
+cp -r envoy "$PROTO_DIR/"
+
+# Now get discovery service and google protobuf files
+git sparse-checkout set \
+  envoy/service/discovery/v3 \
+  google/protobuf
+
+# Copy discovery service
+cp -r envoy/service "$PROTO_DIR/envoy/"
+
+# Copy google protobuf (if exists in repo)
+if [ -d "google" ]; then
+	cp -r google "$PROTO_DIR/"
+fi
+
+# Get Google protobuf well-known types from protobuf repo
+echo "Fetching Google protobuf well-known types..."
+git clone --depth 1 https://github.com/protocolbuffers/protobuf.git /tmp/protobuf-$$
+mkdir -p "$PROTO_DIR/google/protobuf"
+cp /tmp/protobuf-$$/src/google/protobuf/{any,duration,timestamp,struct,empty,wrappers}.proto "$PROTO_DIR/google/protobuf/" 2>/dev/null || true
+rm -rf /tmp/protobuf-$$
+
+# Get google/rpc/status.proto from api-common-protos
+echo "Fetching google/rpc/status.proto..."
+git clone --depth 1 https://github.com/googleapis/api-common-protos.git /tmp/api-common-$$
+mkdir -p "$PROTO_DIR/google/rpc"
+cp /tmp/api-common-$$/google/rpc/status.proto "$PROTO_DIR/google/rpc/" 2>/dev/null || true
+rm -rf /tmp/api-common-$$
+
+# Get envoy/type/v3 and xds/core/v3 from data-plane-api
+echo "Fetching envoy/type/v3 and xds/core/v3..."
+git clone --depth 1 --filter=blob:none --sparse https://github.com/envoyproxy/data-plane-api.git /tmp/envoy-types-$$
+cd /tmp/envoy-types-$$
+git sparse-checkout set envoy/type/v3 envoy/type/matcher/v3 envoy/type/metadata/v3 xds/core/v3
+mkdir -p "$PROTO_DIR/envoy/type/v3" "$PROTO_DIR/envoy/type/matcher/v3" "$PROTO_DIR/envoy/type/metadata/v3" "$PROTO_DIR/xds/core/v3"
+cp -r envoy/type "$PROTO_DIR/envoy/" 2>/dev/null || true
+cp -r xds/core "$PROTO_DIR/xds/" 2>/dev/null || true
+rm -rf /tmp/envoy-types-$$
+
+# Get xds/type/matcher/v3 and xds/core/v3 from cncf/xds repo
+echo "Fetching xds/type/matcher/v3 and xds/core/v3..."
+git clone --depth 1 https://github.com/cncf/xds.git /tmp/xds-types-$$
+mkdir -p "$PROTO_DIR/xds/type/matcher/v3" "$PROTO_DIR/xds/core/v3"
+find /tmp/xds-types-$$/xds/type/matcher/v3 -name "*.proto" ! -name "*cel*" -exec cp {} "$PROTO_DIR/xds/type/matcher/v3/" \;
+find /tmp/xds-types-$$/xds/core/v3 -name "*.proto" -exec cp {} "$PROTO_DIR/xds/core/v3/" \;
+rm -rf /tmp/xds-types-$$
+
+# Get udpa annotations
+echo "Fetching udpa annotations..."
+git clone --depth 1 https://github.com/cncf/udpa.git /tmp/udpa-$$
+mkdir -p "$PROTO_DIR/udpa/annotations"
+cp /tmp/udpa-$$/udpa/annotations/*.proto "$PROTO_DIR/udpa/annotations/" 2>/dev/null || true
+rm -rf /tmp/udpa-$$
+
+# Get validate annotations
+echo "Fetching validate annotations..."
+git clone --depth 1 https://github.com/envoyproxy/protoc-gen-validate.git /tmp/validate-$$
+mkdir -p "$PROTO_DIR/validate"
+cp /tmp/validate-$$/validate/validate.proto "$PROTO_DIR/validate/" 2>/dev/null || true
+rm -rf /tmp/validate-$$
+
+# Get envoy annotations
+echo "Fetching envoy annotations..."
+git clone --depth 1 --filter=blob:none --sparse https://github.com/envoyproxy/envoy.git /tmp/envoy-annotations-$$
+cd /tmp/envoy-annotations-$$
+git sparse-checkout set api/envoy/annotations
+mkdir -p "$PROTO_DIR/envoy/annotations"
+cp api/envoy/annotations/*.proto "$PROTO_DIR/envoy/annotations/" 2>/dev/null || true
+rm -rf /tmp/envoy-annotations-$$
+
+echo "Copying .proto files to $PROTO_DIR..."
+
+# Create directories
+mkdir -p "$PROTO_DIR/envoy/service/discovery/v3"
+mkdir -p "$PROTO_DIR/envoy/config/cluster/v3"
+mkdir -p "$PROTO_DIR/envoy/config/endpoint/v3"
+mkdir -p "$PROTO_DIR/envoy/config/listener/v3"
+mkdir -p "$PROTO_DIR/envoy/config/route/v3"
+mkdir -p "$PROTO_DIR/envoy/config/core/v3"
+mkdir -p "$PROTO_DIR/envoy/extensions/transport_sockets/tls/v3"
+mkdir -p "$PROTO_DIR/google/protobuf"
+
+# Copy files
+cp -r envoy "$PROTO_DIR/"
+cp -r google "$PROTO_DIR/"
+
+# Cleanup
+rm -rf "$TEMP_DIR"
+
+echo "Done! Proto files updated in $PROTO_DIR"
+echo ""
+echo "To generate Ruby code, run:"
+echo "  bundle exec bake async:grpc:xds:generate_protos"