add xds metadata registry

add copyright

remove trailing whitespaces

fix linter

correct imports

use netip

add comments

fix linter

keep fixing

add back test

check linter

move out of xdsmetadataregistry

fix linter

fix comment

Author: cjqzhao

internal/xds/xdsclient/xdsresource/metadata.go

@@ -0,0 +1,105 @@
+/*
+ *
+ * Copyright 2025 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xdsresource
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/netip"
+
+	v3corepb "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
+	"google.golang.org/protobuf/proto"
+)
+
+func init() {
+	Register("envoy.http11_proxy_transport_socket.proxy_address", ProxyAddressConvertor{})
+}
+
+var (
+	// metadataregistry is a map from proto type to Converter.
+	metadataregistry = make(map[string]Converter)
+)
+
+// MetadataValue is the interface for a converted metadata value. It is
+// implemented by concrete types that hold the converted metadata.
+type MetadataValue interface {
+	Type() string
+}
+
+// Converter is the interface for a metadata converter. It is implemented by
+// concrete types that convert raw bytes into a MetadataValue.
+type Converter interface {
+	// Convert parses the raw bytes of an Any proto into a MetadataValue.
+	Convert([]byte) (MetadataValue, error)
+}
+
+// Register registers the converter to the map keyed on a proto type. Must be
+// called at init time. Not thread safe.
+func Register(protoType string, c Converter) {
+	metadataregistry[protoType] = c
+}
+
+// ConverterForType retrieves a converter based on key given.
+func ConverterForType(typeURL string) Converter {
+	return metadataregistry[typeURL]
+}
+
+// JSONMetadata stores the values in a google.protobufStruct from
+// FilterMetadata.
+type JSONMetadata struct {
+	MetadataValue
+	Data json.RawMessage
+}
+
+// ProxyAddressMetadataValue holds the address parsed from A.86 metadata.
+type ProxyAddressMetadataValue struct {
+	MetadataValue
+	Address string
+}
+
+// Type returns a string representing this metadata type.
+func (ProxyAddressMetadataValue) Type() string {
+	return "envoy.config.core.v3.Address"
+}
+
+// ProxyAddressConvertor implements the converter for A86 (Proxy Address) metadata.
+type ProxyAddressConvertor struct{}
+
+// Convert parses the raw bytes of an Any proto containing an Address proto into
+// a ProxyAddressMetadataValue.
+func (ProxyAddressConvertor) Convert(anyBytes []byte) (MetadataValue, error) {
+	addressProto := &v3corepb.Address{}
+	if err := proto.Unmarshal(anyBytes, addressProto); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal resource: %v", err)
+	}
+	socketaddress := addressProto.GetSocketAddress()
+	if socketaddress == nil {
+		return nil, fmt.Errorf("no socket_address field in metadata")
+	}
+	portvalue := socketaddress.GetPortValue()
+	if portvalue == 0 {
+		return nil, fmt.Errorf("port value not set in socket_address")
+	}
+	if _, err := netip.ParseAddr(socketaddress.GetAddress()); err != nil {
+		return nil, fmt.Errorf("address field is not a valid IPv4 or IPv6 address: %q", socketaddress.GetAddress())
+	}
+	metadata := ProxyAddressMetadataValue{
+		Address: socketaddress.Address,
+	}
+	return metadata, nil
+}

internal/xds/xdsclient/xdsresource/metadata_test.go

@@ -0,0 +1,162 @@
+/*
+ *
+ * Copyright 2025 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package xdsresource
+
+import (
+	"testing"
+
+	v3corepb "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/proto"
+)
+
+const proxyAddressFilterName = "envoy.http11_proxy_transport_socket.proxy_address"
+
+func (s) TestProxyAddressConverterSuccess(t *testing.T) {
+	converter := ConverterForType(proxyAddressFilterName)
+	if converter == nil {
+		t.Fatalf("Converter for %q not found in registry", proxyAddressFilterName)
+	}
+	tests := []struct {
+		name string
+		addr *v3corepb.Address
+		want ProxyAddressMetadataValue
+	}{
+		{
+			name: "valid IPv4 address and port",
+			addr: &v3corepb.Address{
+				Address: &v3corepb.Address_SocketAddress{
+					SocketAddress: &v3corepb.SocketAddress{
+						Address: "192.168.1.1",
+						PortSpecifier: &v3corepb.SocketAddress_PortValue{
+							PortValue: 8080,
+						},
+					},
+				},
+			},
+			want: ProxyAddressMetadataValue{
+				Address: "192.168.1.1",
+			},
+		},
+		{
+			name: "valid IPv6 address and port",
+			addr: &v3corepb.Address{
+				Address: &v3corepb.Address_SocketAddress{
+					SocketAddress: &v3corepb.SocketAddress{
+						Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+						PortSpecifier: &v3corepb.SocketAddress_PortValue{
+							PortValue: 9090,
+						},
+					},
+				},
+			},
+			want: ProxyAddressMetadataValue{
+				Address: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			anyBytes, err := proto.Marshal(tt.addr)
+			if err != nil {
+				t.Fatalf("Failed to marshal address proto: %v", err)
+			}
+			got, err := converter.Convert(anyBytes)
+			if err != nil {
+				t.Fatalf("convert() failed with error: %v", err)
+			}
+			if diff := cmp.Diff(tt.want, got, cmp.AllowUnexported(ProxyAddressMetadataValue{})); diff != "" {
+				t.Errorf("convert() returned unexpected value:\n%s", diff)
+			}
+		})
+	}
+}
+
+func (s) TestProxyAddressConverterFailure(t *testing.T) {
+	converter := ConverterForType(proxyAddressFilterName)
+	if converter == nil {
+		t.Fatalf("Converter for %q not found in registry", proxyAddressFilterName)
+	}
+	tests := []struct {
+		name    string
+		addr    *v3corepb.Address
+		wantErr string
+	}{
+		{
+			name: "invalid address",
+			addr: &v3corepb.Address{
+				Address: &v3corepb.Address_SocketAddress{
+					SocketAddress: &v3corepb.SocketAddress{
+						Address: "invalid-ip",
+						PortSpecifier: &v3corepb.SocketAddress_PortValue{
+							PortValue: 8080,
+						},
+					},
+				},
+			},
+			wantErr: "address field is not a valid IPv4 or IPv6 address: \"invalid-ip\"",
+		},
+		{
+			name: "missing socket_address",
+			addr: &v3corepb.Address{
+				// No SocketAddress field set.
+			},
+			wantErr: "no socket_address field in metadata",
+		},
+		{
+			name: "address is not a socket address",
+			addr: &v3corepb.Address{
+				Address: &v3corepb.Address_EnvoyInternalAddress{
+					EnvoyInternalAddress: &v3corepb.EnvoyInternalAddress{
+						AddressNameSpecifier: &v3corepb.EnvoyInternalAddress_ServerListenerName{
+							ServerListenerName: "some-internal-listener",
+						},
+					},
+				},
+			},
+			wantErr: "no socket_address field in metadata",
+		},
+		{
+			name: "port value not set",
+			addr: &v3corepb.Address{
+				Address: &v3corepb.Address_SocketAddress{
+					SocketAddress: &v3corepb.SocketAddress{
+						Address:       "127.0.0.1",
+						PortSpecifier: nil,
+					},
+				},
+			},
+			wantErr: "port value not set in socket_address",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			anyBytes, err := proto.Marshal(tt.addr)
+			if err != nil {
+				t.Fatalf("Failed to marshal address proto: %v", err)
+			}
+
+			// Call the convert function and check the returned error.
+			_, gotErr := converter.Convert(anyBytes)
+			if gotErr == nil || gotErr.Error() != tt.wantErr {
+				t.Errorf("convert() got error = %v, wantErr = %q", gotErr, tt.wantErr)
+			}
+		})
+	}
+}

internal/xds/xdsclient/xdsresource/type_eds.go

@@ -74,3 +74,9 @@ type EndpointsUpdate struct {
 	// Raw is the resource from the xds response.
 	Raw *anypb.Any
 }
+
+// Metadata stores a map from keys to internal representations of metadata
+// proto.
+type Metadata struct {
+	Metadata map[string]MetadataValue
+}

internal/xds/xdsclient/xdsresource/unmarshal_eds.go

@@ -18,6 +18,7 @@
 package xdsresource
 
 import (
+	"encoding/json"
 	"fmt"
 	"math"
 	"net"
@@ -30,6 +31,7 @@ import (
 	"google.golang.org/grpc/internal/pretty"
 	xdsinternal "google.golang.org/grpc/internal/xds"
 	"google.golang.org/grpc/internal/xds/clients"
+	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
@@ -204,3 +206,40 @@ func parseEDSRespProto(m *v3endpointpb.ClusterLoadAssignment) (EndpointsUpdate,
 	}
 	return ret, nil
 }
+
+func validateAndConstructMetadata(metadataProto *v3corepb.Metadata) (Metadata, error) {
+	metadata := make(map[string]MetadataValue)
+	if metadataProto == nil {
+		return Metadata{Metadata: metadata}, nil
+	}
+	// First go through TypedFilterMetadata.
+	for key, anyProto := range metadataProto.GetTypedFilterMetadata() {
+		converter := ConverterForType(anyProto.GetTypeUrl())
+		// Ignore types we don't have a converter for.
+		if converter == nil {
+			continue
+		}
+
+		val, err := converter.Convert(anyProto.GetValue())
+		if err != nil {
+			// If the converter fails, nack the whole resource.
+			return Metadata{}, fmt.Errorf("metadata parser for key %q and type %q failed: %v", key, anyProto.GetTypeUrl(), err)
+		}
+		metadata[key] = val
+	}
+
+	// Process FilterMetadata for any keys not already handled.
+	for key, structProto := range metadataProto.GetFilterMetadata() {
+		_, exists := metadata[key]
+		// Skip keys already added from TyperFilterMetadata.
+		if exists {
+			continue
+		}
+		b, err := protojson.Marshal(structProto)
+		if err != nil {
+			return Metadata{}, fmt.Errorf("failed to marshal filter metadata for key %q: %v", key, err)
+		}
+		metadata[key] = JSONMetadata{Data: json.RawMessage(b)}
+	}
+	return Metadata{Metadata: metadata}, nil
+}