io.envoyproxy.controlplane.server.V3DiscoveryServer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of server Show documentation
The newest version!
package io.envoyproxy.controlplane.server;

import static io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase;
import static io.envoyproxy.envoy.service.endpoint.v3.EndpointDiscoveryServiceGrpc.EndpointDiscoveryServiceImplBase;
import static io.envoyproxy.envoy.service.listener.v3.ListenerDiscoveryServiceGrpc.ListenerDiscoveryServiceImplBase;
import static io.envoyproxy.envoy.service.route.v3.RouteDiscoveryServiceGrpc.RouteDiscoveryServiceImplBase;
import static io.envoyproxy.envoy.service.secret.v3.SecretDiscoveryServiceGrpc.SecretDiscoveryServiceImplBase;

import com.google.common.base.Preconditions;
import com.google.protobuf.Any;
import io.envoyproxy.controlplane.cache.ConfigWatcher;
import io.envoyproxy.controlplane.cache.DeltaXdsRequest;
import io.envoyproxy.controlplane.cache.Resources;
import io.envoyproxy.controlplane.cache.XdsRequest;
import io.envoyproxy.controlplane.server.exception.RequestException;
import io.envoyproxy.controlplane.server.serializer.DefaultProtoResourcesSerializer;
import io.envoyproxy.controlplane.server.serializer.ProtoResourcesSerializer;
import io.envoyproxy.envoy.service.cluster.v3.ClusterDiscoveryServiceGrpc.ClusterDiscoveryServiceImplBase;
import io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest;
import io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse;
import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
import io.envoyproxy.envoy.service.discovery.v3.Resource;
import io.grpc.stub.StreamObserver;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class V3DiscoveryServer extends DiscoveryServer {
  public V3DiscoveryServer(ConfigWatcher configWatcher) {
    this(Collections.emptyList(), configWatcher);
  }

  public V3DiscoveryServer(DiscoveryServerCallbacks callbacks,
                           ConfigWatcher configWatcher) {
    this(Collections.singletonList(callbacks), configWatcher);
  }

  public V3DiscoveryServer(
      List callbacks,
      ConfigWatcher configWatcher) {
    this(callbacks, configWatcher, new DefaultExecutorGroup(),
        new DefaultProtoResourcesSerializer());
  }

  public V3DiscoveryServer(List callbacks,
      ConfigWatcher configWatcher,
      ExecutorGroup executorGroup,
      ProtoResourcesSerializer protoResourcesSerializer) {
    this(callbacks, configWatcher, executorGroup, protoResourcesSerializer, new DefaultStartupConfigs());
  }

  public V3DiscoveryServer(List callbacks,
                           ConfigWatcher configWatcher,
                           ExecutorGroup executorGroup,
                           ProtoResourcesSerializer protoResourcesSerializer,
                           StartupConfigs startupConfigs) {
    super(callbacks, configWatcher, executorGroup, protoResourcesSerializer, startupConfigs);
  }

  /**
   * Returns an ADS implementation that uses this server's {@link ConfigWatcher}.
   */
  public AggregatedDiscoveryServiceImplBase getAggregatedDiscoveryServiceImpl() {
    return new AggregatedDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamAggregatedResources(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, true, ANY_TYPE_URL);
      }

      @Override
      public StreamObserver deltaAggregatedResources(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, true, ANY_TYPE_URL);
      }
    };
  }

  /**
   * Returns a CDS implementation that uses this server's {@link ConfigWatcher}.
   */
  public ClusterDiscoveryServiceImplBase getClusterDiscoveryServiceImpl() {
    return new ClusterDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamClusters(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, false, Resources.V3.CLUSTER_TYPE_URL);
      }

      @Override
      public StreamObserver deltaClusters(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, false, Resources.V3.CLUSTER_TYPE_URL);
      }
    };
  }

  /**
   * Returns an EDS implementation that uses this server's {@link ConfigWatcher}.
   */
  public EndpointDiscoveryServiceImplBase getEndpointDiscoveryServiceImpl() {
    return new EndpointDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamEndpoints(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, false, Resources.V3.ENDPOINT_TYPE_URL);
      }

      @Override
      public StreamObserver deltaEndpoints(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, false, Resources.V3.ENDPOINT_TYPE_URL);
      }
    };
  }

  /**
   * Returns a LDS implementation that uses this server's {@link ConfigWatcher}.
   */
  public ListenerDiscoveryServiceImplBase getListenerDiscoveryServiceImpl() {
    return new ListenerDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamListeners(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, false, Resources.V3.LISTENER_TYPE_URL);
      }

      @Override
      public StreamObserver deltaListeners(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, false, Resources.V3.LISTENER_TYPE_URL);
      }
    };
  }

  /**
   * Returns a RDS implementation that uses this server's {@link ConfigWatcher}.
   */
  public RouteDiscoveryServiceImplBase getRouteDiscoveryServiceImpl() {
    return new RouteDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamRoutes(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, false, Resources.V3.ROUTE_TYPE_URL);
      }

      @Override
      public StreamObserver deltaRoutes(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, false, Resources.V3.ROUTE_TYPE_URL);
      }
    };
  }

  /**
   * Returns a SDS implementation that uses this server's {@link ConfigWatcher}.
   */
  public SecretDiscoveryServiceImplBase getSecretDiscoveryServiceImpl() {
    return new SecretDiscoveryServiceImplBase() {
      @Override
      public StreamObserver streamSecrets(
          StreamObserver responseObserver) {

        return createRequestHandler(responseObserver, false, Resources.V3.SECRET_TYPE_URL);
      }

      @Override
      public StreamObserver deltaSecrets(
          StreamObserver responseObserver) {

        return createDeltaRequestHandler(responseObserver, false, Resources.V3.SECRET_TYPE_URL);
      }
    };
  }

  @Override
  protected XdsRequest wrapXdsRequest(DiscoveryRequest request) {
    return XdsRequest.create(request);
  }

  @Override
  protected DeltaXdsRequest wrapDeltaXdsRequest(DeltaDiscoveryRequest request) {
    return DeltaXdsRequest.create(request);
  }

  @Override
  protected void runStreamRequestCallbacks(long streamId, DiscoveryRequest discoveryRequest) throws RequestException {
    for (DiscoveryServerCallbacks cb : callbacks) {
      cb.onV3StreamRequest(streamId, discoveryRequest);
    }
  }

  @Override
  protected void runStreamDeltaRequestCallbacks(long streamId, DeltaDiscoveryRequest request) throws RequestException {
    for (DiscoveryServerCallbacks cb : callbacks) {
      cb.onV3StreamDeltaRequest(streamId, request);
    }
  }

  @Override
  protected void runStreamResponseCallbacks(long streamId, XdsRequest request,
                                            DiscoveryResponse discoveryResponse) {
    Preconditions.checkArgument(request.v3Request() != null);
    callbacks.forEach(
        cb -> cb.onV3StreamResponse(streamId,
            request.v3Request(),
            discoveryResponse));
  }

  @Override
  protected void runStreamDeltaResponseCallbacks(long streamId, DeltaXdsRequest request,
                                                 DeltaDiscoveryResponse response) {
    Preconditions.checkArgument(request.v3Request() != null);
    callbacks.forEach(
        cb -> cb.onV3StreamDeltaResponse(streamId,
            request.v3Request(),
            response));
  }

  @Override
  protected DiscoveryResponse makeResponse(String version, Collection resources,
                                           String typeUrl,
                                           String nonce) {
    return DiscoveryResponse.newBuilder()
        .setNonce(nonce)
        .setVersionInfo(version)
        .addAllResources(resources)
        .setTypeUrl(typeUrl)
        .build();
  }

  @Override
  public DeltaDiscoveryResponse makeDeltaResponse(String typeUrl, String version, String nonce,
                                                  List resources,
                                                  List removedResources) {
    return DeltaDiscoveryResponse.newBuilder()
        .setTypeUrl(typeUrl)
        .setSystemVersionInfo(version)
        .setNonce(nonce)
        .addAllResources(resources)
        .addAllRemovedResources(removedResources)
        .build();
  }

  @Override
  protected Resource makeResource(String name, String version, Any resource) {
    return Resource.newBuilder()
        .setName(name)
        .setVersion(version)
        .setResource(resource)
        .build();
  }
}