diff --git a/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
new file mode 100644
index 000000000000..a2698b43853e
--- /dev/null
+++ b/xds/src/generated/main/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
@@ -0,0 +1,376 @@
+package io.envoyproxy.envoy.service.discovery.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ClientCalls.asyncUnaryCall;
+import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
+import static io.grpc.stub.ClientCalls.blockingUnaryCall;
+import static io.grpc.stub.ClientCalls.futureUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnaryCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
+import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
+
+/**
+ *
+ * See https://github.com/lyft/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ *
+ */
+@javax.annotation.Generated(
+ value = "by gRPC proto compiler",
+ comments = "Source: envoy/service/discovery/v3/ads.proto")
+public final class AggregatedDiscoveryServiceGrpc {
+
+ private AggregatedDiscoveryServiceGrpc() {}
+
+ public static final String SERVICE_NAME = "envoy.service.discovery.v3.AggregatedDiscoveryService";
+
+ // Static method descriptors that strictly reflect the proto.
+ private static volatile io.grpc.MethodDescriptor getStreamAggregatedResourcesMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "StreamAggregatedResources",
+ requestType = io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest.class,
+ responseType = io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+ public static io.grpc.MethodDescriptor getStreamAggregatedResourcesMethod() {
+ io.grpc.MethodDescriptor getStreamAggregatedResourcesMethod;
+ if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
+ synchronized (AggregatedDiscoveryServiceGrpc.class) {
+ if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
+ AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod = getStreamAggregatedResourcesMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamAggregatedResources"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse.getDefaultInstance()))
+ .setSchemaDescriptor(new AggregatedDiscoveryServiceMethodDescriptorSupplier("StreamAggregatedResources"))
+ .build();
+ }
+ }
+ }
+ return getStreamAggregatedResourcesMethod;
+ }
+
+ private static volatile io.grpc.MethodDescriptor getDeltaAggregatedResourcesMethod;
+
+ @io.grpc.stub.annotations.RpcMethod(
+ fullMethodName = SERVICE_NAME + '/' + "DeltaAggregatedResources",
+ requestType = io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest.class,
+ responseType = io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse.class,
+ methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+ public static io.grpc.MethodDescriptor getDeltaAggregatedResourcesMethod() {
+ io.grpc.MethodDescriptor getDeltaAggregatedResourcesMethod;
+ if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
+ synchronized (AggregatedDiscoveryServiceGrpc.class) {
+ if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
+ AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod = getDeltaAggregatedResourcesMethod =
+ io.grpc.MethodDescriptor.newBuilder()
+ .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+ .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaAggregatedResources"))
+ .setSampledToLocalTracing(true)
+ .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest.getDefaultInstance()))
+ .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+ io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse.getDefaultInstance()))
+ .setSchemaDescriptor(new AggregatedDiscoveryServiceMethodDescriptorSupplier("DeltaAggregatedResources"))
+ .build();
+ }
+ }
+ }
+ return getDeltaAggregatedResourcesMethod;
+ }
+
+ /**
+ * Creates a new async stub that supports all call types for the service
+ */
+ public static AggregatedDiscoveryServiceStub newStub(io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public AggregatedDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceStub(channel, callOptions);
+ }
+ };
+ return AggregatedDiscoveryServiceStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+ */
+ public static AggregatedDiscoveryServiceBlockingStub newBlockingStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public AggregatedDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceBlockingStub(channel, callOptions);
+ }
+ };
+ return AggregatedDiscoveryServiceBlockingStub.newStub(factory, channel);
+ }
+
+ /**
+ * Creates a new ListenableFuture-style stub that supports unary calls on the service
+ */
+ public static AggregatedDiscoveryServiceFutureStub newFutureStub(
+ io.grpc.Channel channel) {
+ io.grpc.stub.AbstractStub.StubFactory factory =
+ new io.grpc.stub.AbstractStub.StubFactory() {
+ @java.lang.Override
+ public AggregatedDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceFutureStub(channel, callOptions);
+ }
+ };
+ return AggregatedDiscoveryServiceFutureStub.newStub(factory, channel);
+ }
+
+ /**
+ *
+ * See https://github.com/lyft/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ *
+ */
+ public static abstract class AggregatedDiscoveryServiceImplBase implements io.grpc.BindableService {
+
+ /**
+ *
+ * This is a gRPC-only API.
+ *
+ */
+ public io.grpc.stub.StreamObserver streamAggregatedResources(
+ io.grpc.stub.StreamObserver responseObserver) {
+ return asyncUnimplementedStreamingCall(getStreamAggregatedResourcesMethod(), responseObserver);
+ }
+
+ /**
+ */
+ public io.grpc.stub.StreamObserver deltaAggregatedResources(
+ io.grpc.stub.StreamObserver responseObserver) {
+ return asyncUnimplementedStreamingCall(getDeltaAggregatedResourcesMethod(), responseObserver);
+ }
+
+ @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+ return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+ .addMethod(
+ getStreamAggregatedResourcesMethod(),
+ asyncBidiStreamingCall(
+ new MethodHandlers<
+ io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest,
+ io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse>(
+ this, METHODID_STREAM_AGGREGATED_RESOURCES)))
+ .addMethod(
+ getDeltaAggregatedResourcesMethod(),
+ asyncBidiStreamingCall(
+ new MethodHandlers<
+ io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest,
+ io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse>(
+ this, METHODID_DELTA_AGGREGATED_RESOURCES)))
+ .build();
+ }
+ }
+
+ /**
+ *
+ * See https://github.com/lyft/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ *
+ */
+ public static final class AggregatedDiscoveryServiceStub extends io.grpc.stub.AbstractAsyncStub {
+ private AggregatedDiscoveryServiceStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected AggregatedDiscoveryServiceStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceStub(channel, callOptions);
+ }
+
+ /**
+ *
+ * This is a gRPC-only API.
+ *
+ */
+ public io.grpc.stub.StreamObserver streamAggregatedResources(
+ io.grpc.stub.StreamObserver responseObserver) {
+ return asyncBidiStreamingCall(
+ getChannel().newCall(getStreamAggregatedResourcesMethod(), getCallOptions()), responseObserver);
+ }
+
+ /**
+ */
+ public io.grpc.stub.StreamObserver deltaAggregatedResources(
+ io.grpc.stub.StreamObserver responseObserver) {
+ return asyncBidiStreamingCall(
+ getChannel().newCall(getDeltaAggregatedResourcesMethod(), getCallOptions()), responseObserver);
+ }
+ }
+
+ /**
+ *
+ * See https://github.com/lyft/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ *
+ */
+ public static final class AggregatedDiscoveryServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
+ private AggregatedDiscoveryServiceBlockingStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected AggregatedDiscoveryServiceBlockingStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceBlockingStub(channel, callOptions);
+ }
+ }
+
+ /**
+ *
+ * See https://github.com/lyft/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ *
+ */
+ public static final class AggregatedDiscoveryServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
+ private AggregatedDiscoveryServiceFutureStub(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ super(channel, callOptions);
+ }
+
+ @java.lang.Override
+ protected AggregatedDiscoveryServiceFutureStub build(
+ io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+ return new AggregatedDiscoveryServiceFutureStub(channel, callOptions);
+ }
+ }
+
+ private static final int METHODID_STREAM_AGGREGATED_RESOURCES = 0;
+ private static final int METHODID_DELTA_AGGREGATED_RESOURCES = 1;
+
+ private static final class MethodHandlers implements
+ io.grpc.stub.ServerCalls.UnaryMethod,
+ io.grpc.stub.ServerCalls.ServerStreamingMethod,
+ io.grpc.stub.ServerCalls.ClientStreamingMethod,
+ io.grpc.stub.ServerCalls.BidiStreamingMethod {
+ private final AggregatedDiscoveryServiceImplBase serviceImpl;
+ private final int methodId;
+
+ MethodHandlers(AggregatedDiscoveryServiceImplBase serviceImpl, int methodId) {
+ this.serviceImpl = serviceImpl;
+ this.methodId = methodId;
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @java.lang.Override
+ @java.lang.SuppressWarnings("unchecked")
+ public io.grpc.stub.StreamObserver invoke(
+ io.grpc.stub.StreamObserver responseObserver) {
+ switch (methodId) {
+ case METHODID_STREAM_AGGREGATED_RESOURCES:
+ return (io.grpc.stub.StreamObserver) serviceImpl.streamAggregatedResources(
+ (io.grpc.stub.StreamObserver) responseObserver);
+ case METHODID_DELTA_AGGREGATED_RESOURCES:
+ return (io.grpc.stub.StreamObserver) serviceImpl.deltaAggregatedResources(
+ (io.grpc.stub.StreamObserver) responseObserver);
+ default:
+ throw new AssertionError();
+ }
+ }
+ }
+
+ private static abstract class AggregatedDiscoveryServiceBaseDescriptorSupplier
+ implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+ AggregatedDiscoveryServiceBaseDescriptorSupplier() {}
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+ return io.envoyproxy.envoy.service.discovery.v3.AdsProto.getDescriptor();
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+ return getFileDescriptor().findServiceByName("AggregatedDiscoveryService");
+ }
+ }
+
+ private static final class AggregatedDiscoveryServiceFileDescriptorSupplier
+ extends AggregatedDiscoveryServiceBaseDescriptorSupplier {
+ AggregatedDiscoveryServiceFileDescriptorSupplier() {}
+ }
+
+ private static final class AggregatedDiscoveryServiceMethodDescriptorSupplier
+ extends AggregatedDiscoveryServiceBaseDescriptorSupplier
+ implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+ private final String methodName;
+
+ AggregatedDiscoveryServiceMethodDescriptorSupplier(String methodName) {
+ this.methodName = methodName;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+ return getServiceDescriptor().findMethodByName(methodName);
+ }
+ }
+
+ private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+ io.grpc.ServiceDescriptor result = serviceDescriptor;
+ if (result == null) {
+ synchronized (AggregatedDiscoveryServiceGrpc.class) {
+ result = serviceDescriptor;
+ if (result == null) {
+ serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+ .setSchemaDescriptor(new AggregatedDiscoveryServiceFileDescriptorSupplier())
+ .addMethod(getStreamAggregatedResourcesMethod())
+ .addMethod(getDeltaAggregatedResourcesMethod())
+ .build();
+ }
+ }
+ }
+ return result;
+ }
+}
diff --git a/xds/third_party/envoy/import.sh b/xds/third_party/envoy/import.sh
index e528611d1716..cd16468c50b9 100755
--- a/xds/third_party/envoy/import.sh
+++ b/xds/third_party/envoy/import.sh
@@ -117,6 +117,8 @@ envoy/extensions/transport_sockets/tls/v3/secret.proto
envoy/extensions/transport_sockets/tls/v3/tls.proto
envoy/service/discovery/v2/ads.proto
envoy/service/discovery/v2/sds.proto
+envoy/service/discovery/v3/ads.proto
+envoy/service/discovery/v3/discovery.proto
envoy/service/load_stats/v2/lrs.proto
envoy/type/http.proto
envoy/type/matcher/regex.proto
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto
new file mode 100644
index 000000000000..03021559ab66
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto
@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+package envoy.service.discovery.v3;
+
+import "envoy/service/discovery/v3/discovery.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.discovery.v3";
+option java_outer_classname = "AdsProto";
+option java_multiple_files = true;
+option java_generic_services = true;
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Aggregated Discovery Service (ADS)]
+
+// [#not-implemented-hide:] Discovery services for endpoints, clusters, routes,
+// and listeners are retained in the package `envoy.api.v2` for backwards
+// compatibility with existing management servers. New development in discovery
+// services should proceed in the package `envoy.service.discovery.v2`.
+
+// See https://github.com/lyft/envoy-api#apis for a description of the role of
+// ADS and how it is intended to be used by a management server. ADS requests
+// have the same structure as their singleton xDS counterparts, but can
+// multiplex many resource types on a single stream. The type_url in the
+// DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+// the multiplexed singleton APIs at the Envoy instance and management server.
+service AggregatedDiscoveryService {
+ // This is a gRPC-only API.
+ rpc StreamAggregatedResources(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
+ }
+
+ rpc DeltaAggregatedResources(stream DeltaDiscoveryRequest)
+ returns (stream DeltaDiscoveryResponse) {
+ }
+}
+
+// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
+// services: https://github.com/google/protobuf/issues/4221
+message AdsDummy {
+ option (udpa.annotations.versioning).previous_message_type =
+ "envoy.service.discovery.v2.AdsDummy";
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto
new file mode 100644
index 000000000000..b8e31160a88b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto
@@ -0,0 +1,244 @@
+syntax = "proto3";
+
+package envoy.service.discovery.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/any.proto";
+import "google/rpc/status.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.discovery.v3";
+option java_outer_classname = "DiscoveryProto";
+option java_multiple_files = true;
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common discovery API components]
+
+// A DiscoveryRequest requests a set of versioned resources of the same type for
+// a given Envoy node on some API.
+// [#next-free-field: 7]
+message DiscoveryRequest {
+ option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DiscoveryRequest";
+
+ // The version_info provided in the request messages will be the version_info
+ // received with the most recent successfully processed response or empty on
+ // the first request. It is expected that no new request is sent after a
+ // response is received until the Envoy instance is ready to ACK/NACK the new
+ // configuration. ACK/NACK takes place by returning the new API config version
+ // as applied or the previous API config version respectively. Each type_url
+ // (see below) has an independent version associated with it.
+ string version_info = 1;
+
+ // The node making the request.
+ config.core.v3.Node node = 2;
+
+ // List of resources to subscribe to, e.g. list of cluster names or a route
+ // configuration name. If this is empty, all resources for the API are
+ // returned. LDS/CDS may have empty resource_names, which will cause all
+ // resources for the Envoy instance to be returned. The LDS and CDS responses
+ // will then imply a number of resources that need to be fetched via EDS/RDS,
+ // which will be explicitly enumerated in resource_names.
+ repeated string resource_names = 3;
+
+ // Type of the resource that is being requested, e.g.
+ // "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment". This is implicit
+ // in requests made via singleton xDS APIs such as CDS, LDS, etc. but is
+ // required for ADS.
+ string type_url = 4;
+
+ // nonce corresponding to DiscoveryResponse being ACK/NACKed. See above
+ // discussion on version_info and the DiscoveryResponse nonce comment. This
+ // may be empty only if 1) this is a non-persistent-stream xDS such as HTTP,
+ // or 2) the client has not yet accepted an update in this xDS stream (unlike
+ // delta, where it is populated only for new explicit ACKs).
+ string response_nonce = 5;
+
+ // This is populated when the previous :ref:`DiscoveryResponse `
+ // failed to update configuration. The *message* field in *error_details* provides the Envoy
+ // internal exception related to the failure. It is only intended for consumption during manual
+ // debugging, the string provided is not guaranteed to be stable across Envoy versions.
+ google.rpc.Status error_detail = 6;
+}
+
+// [#next-free-field: 7]
+message DiscoveryResponse {
+ option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DiscoveryResponse";
+
+ // The version of the response data.
+ string version_info = 1;
+
+ // The response resources. These resources are typed and depend on the API being called.
+ repeated google.protobuf.Any resources = 2;
+
+ // [#not-implemented-hide:]
+ // Canary is used to support two Envoy command line flags:
+ //
+ // * --terminate-on-canary-transition-failure. When set, Envoy is able to
+ // terminate if it detects that configuration is stuck at canary. Consider
+ // this example sequence of updates:
+ // - Management server applies a canary config successfully.
+ // - Management server rolls back to a production config.
+ // - Envoy rejects the new production config.
+ // Since there is no sensible way to continue receiving configuration
+ // updates, Envoy will then terminate and apply production config from a
+ // clean slate.
+ // * --dry-run-canary. When set, a canary response will never be applied, only
+ // validated via a dry run.
+ bool canary = 3;
+
+ // Type URL for resources. Identifies the xDS API when muxing over ADS.
+ // Must be consistent with the type_url in the 'resources' repeated Any (if non-empty).
+ string type_url = 4;
+
+ // For gRPC based subscriptions, the nonce provides a way to explicitly ack a
+ // specific DiscoveryResponse in a following DiscoveryRequest. Additional
+ // messages may have been sent by Envoy to the management server for the
+ // previous version on the stream prior to this DiscoveryResponse, that were
+ // unprocessed at response send time. The nonce allows the management server
+ // to ignore any further DiscoveryRequests for the previous version until a
+ // DiscoveryRequest bearing the nonce. The nonce is optional and is not
+ // required for non-stream based xDS implementations.
+ string nonce = 5;
+
+ // [#not-implemented-hide:]
+ // The control plane instance that sent the response.
+ config.core.v3.ControlPlane control_plane = 6;
+}
+
+// DeltaDiscoveryRequest and DeltaDiscoveryResponse are used in a new gRPC
+// endpoint for Delta xDS.
+//
+// With Delta xDS, the DeltaDiscoveryResponses do not need to include a full
+// snapshot of the tracked resources. Instead, DeltaDiscoveryResponses are a
+// diff to the state of a xDS client.
+// In Delta XDS there are per-resource versions, which allow tracking state at
+// the resource granularity.
+// An xDS Delta session is always in the context of a gRPC bidirectional
+// stream. This allows the xDS server to keep track of the state of xDS clients
+// connected to it.
+//
+// In Delta xDS the nonce field is required and used to pair
+// DeltaDiscoveryResponse to a DeltaDiscoveryRequest ACK or NACK.
+// Optionally, a response message level system_version_info is present for
+// debugging purposes only.
+//
+// DeltaDiscoveryRequest plays two independent roles. Any DeltaDiscoveryRequest
+// can be either or both of: [1] informing the server of what resources the
+// client has gained/lost interest in (using resource_names_subscribe and
+// resource_names_unsubscribe), or [2] (N)ACKing an earlier resource update from
+// the server (using response_nonce, with presence of error_detail making it a NACK).
+// Additionally, the first message (for a given type_url) of a reconnected gRPC stream
+// has a third role: informing the server of the resources (and their versions)
+// that the client already possesses, using the initial_resource_versions field.
+//
+// As with state-of-the-world, when multiple resource types are multiplexed (ADS),
+// all requests/acknowledgments/updates are logically walled off by type_url:
+// a Cluster ACK exists in a completely separate world from a prior Route NACK.
+// In particular, initial_resource_versions being sent at the "start" of every
+// gRPC stream actually entails a message for each type_url, each with its own
+// initial_resource_versions.
+// [#next-free-field: 8]
+message DeltaDiscoveryRequest {
+ option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DeltaDiscoveryRequest";
+
+ // The node making the request.
+ config.core.v3.Node node = 1;
+
+ // Type of the resource that is being requested, e.g.
+ // "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment".
+ string type_url = 2;
+
+ // DeltaDiscoveryRequests allow the client to add or remove individual
+ // resources to the set of tracked resources in the context of a stream.
+ // All resource names in the resource_names_subscribe list are added to the
+ // set of tracked resources and all resource names in the resource_names_unsubscribe
+ // list are removed from the set of tracked resources.
+ //
+ // *Unlike* state-of-the-world xDS, an empty resource_names_subscribe or
+ // resource_names_unsubscribe list simply means that no resources are to be
+ // added or removed to the resource list.
+ // *Like* state-of-the-world xDS, the server must send updates for all tracked
+ // resources, but can also send updates for resources the client has not subscribed to.
+ //
+ // NOTE: the server must respond with all resources listed in resource_names_subscribe,
+ // even if it believes the client has the most recent version of them. The reason:
+ // the client may have dropped them, but then regained interest before it had a chance
+ // to send the unsubscribe message. See DeltaSubscriptionStateTest.RemoveThenAdd.
+ //
+ // These two fields can be set in any DeltaDiscoveryRequest, including ACKs
+ // and initial_resource_versions.
+ //
+ // A list of Resource names to add to the list of tracked resources.
+ repeated string resource_names_subscribe = 3;
+
+ // A list of Resource names to remove from the list of tracked resources.
+ repeated string resource_names_unsubscribe = 4;
+
+ // Informs the server of the versions of the resources the xDS client knows of, to enable the
+ // client to continue the same logical xDS session even in the face of gRPC stream reconnection.
+ // It will not be populated: [1] in the very first stream of a session, since the client will
+ // not yet have any resources, [2] in any message after the first in a stream (for a given
+ // type_url), since the server will already be correctly tracking the client's state.
+ // (In ADS, the first message *of each type_url* of a reconnected stream populates this map.)
+ // The map's keys are names of xDS resources known to the xDS client.
+ // The map's values are opaque resource versions.
+ map initial_resource_versions = 5;
+
+ // When the DeltaDiscoveryRequest is a ACK or NACK message in response
+ // to a previous DeltaDiscoveryResponse, the response_nonce must be the
+ // nonce in the DeltaDiscoveryResponse.
+ // Otherwise (unlike in DiscoveryRequest) response_nonce must be omitted.
+ string response_nonce = 6;
+
+ // This is populated when the previous :ref:`DiscoveryResponse `
+ // failed to update configuration. The *message* field in *error_details*
+ // provides the Envoy internal exception related to the failure.
+ google.rpc.Status error_detail = 7;
+}
+
+// [#next-free-field: 7]
+message DeltaDiscoveryResponse {
+ option (udpa.annotations.versioning).previous_message_type =
+ "envoy.api.v2.DeltaDiscoveryResponse";
+
+ // The version of the response data (used for debugging).
+ string system_version_info = 1;
+
+ // The response resources. These are typed resources, whose types must match
+ // the type_url field.
+ repeated Resource resources = 2;
+
+ // field id 3 IS available!
+
+ // Type URL for resources. Identifies the xDS API when muxing over ADS.
+ // Must be consistent with the type_url in the Any within 'resources' if 'resources' is non-empty.
+ string type_url = 4;
+
+ // Resources names of resources that have be deleted and to be removed from the xDS Client.
+ // Removed resources for missing resources can be ignored.
+ repeated string removed_resources = 6;
+
+ // The nonce provides a way for DeltaDiscoveryRequests to uniquely
+ // reference a DeltaDiscoveryResponse when (N)ACKing. The nonce is required.
+ string nonce = 5;
+}
+
+message Resource {
+ option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Resource";
+
+ // The resource's name, to distinguish it from others of the same type of resource.
+ string name = 3;
+
+ // The aliases are a list of other names that this resource can go by.
+ repeated string aliases = 4;
+
+ // The resource level version. It allows xDS to track the state of individual
+ // resources.
+ string version = 1;
+
+ // The resource being tracked.
+ google.protobuf.Any resource = 2;
+}