Add validation to discovery features.

When registering a service, using an old runtime, with journal retention set, the discovery will fail.

Author: slinkydeveloper

sdk-core/src/main/java/dev/restate/sdk/core/EndpointManifest.java

@@ -13,12 +13,15 @@
 import static dev.restate.sdk.core.statemachine.ServiceProtocol.MIN_SERVICE_PROTOCOL_VERSION;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import dev.restate.sdk.core.generated.discovery.Discovery;
 import dev.restate.sdk.core.generated.manifest.*;
 import dev.restate.sdk.endpoint.definition.HandlerDefinition;
 import dev.restate.sdk.endpoint.definition.HandlerType;
 import dev.restate.sdk.endpoint.definition.ServiceDefinition;
 import dev.restate.sdk.endpoint.definition.ServiceType;
 import dev.restate.serde.Serde;
+import java.util.Objects;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -83,7 +86,41 @@ final class EndpointManifest {
                     .collect(Collectors.toList()));
   }
 
-  EndpointManifestSchema manifest() {
+  EndpointManifestSchema manifest(Discovery.ServiceDiscoveryProtocolVersion version) {
+    // Verify that the user didn't set fields that we don't support in the discovery version we set
+    for (var service : this.manifest.getServices()) {
+      if (version.getNumber() < Discovery.ServiceDiscoveryProtocolVersion.V2.getNumber()) {
+        verifyFieldNotSet(
+            "metadata",
+            service,
+            s -> s.getMetadata() != null && !s.getMetadata().getAdditionalProperties().isEmpty());
+      }
+      if (version.getNumber() < Discovery.ServiceDiscoveryProtocolVersion.V3.getNumber()) {
+        verifyFieldNull("idempotency retention", service.getIdempotencyRetention());
+        verifyFieldNull("journal retention", service.getJournalRetention());
+        verifyFieldNull("inactivity timeout", service.getInactivityTimeout());
+        verifyFieldNull("abort timeout", service.getAbortTimeout());
+        verifyFieldNull("enable lazy state", service.getEnableLazyState());
+        verifyFieldNull("ingress private", service.getIngressPrivate());
+      }
+      for (var handler : service.getHandlers()) {
+        if (version.getNumber() < Discovery.ServiceDiscoveryProtocolVersion.V2.getNumber()) {
+          verifyFieldNotSet(
+              "metadata",
+              handler,
+              h -> h.getMetadata() != null && !h.getMetadata().getAdditionalProperties().isEmpty());
+        }
+        if (version.getNumber() < Discovery.ServiceDiscoveryProtocolVersion.V3.getNumber()) {
+          verifyFieldNull("idempotency retention", handler.getIdempotencyRetention());
+          verifyFieldNull("journal retention", handler.getJournalRetention());
+          verifyFieldNull("inactivity timeout", handler.getInactivityTimeout());
+          verifyFieldNull("abort timeout", handler.getAbortTimeout());
+          verifyFieldNull("enable lazy state", handler.getEnableLazyState());
+          verifyFieldNull("ingress private", handler.getIngressPrivate());
+        }
+      }
+    }
+
     return this.manifest;
   }
 
@@ -187,4 +224,19 @@ private static Handler.Ty convertHandlerType(HandlerType handlerType) {
       case SHARED -> Handler.Ty.SHARED;
     };
   }
+
+  private static <T> void verifyFieldNotSet(
+      String featureName, T value, Predicate<T> isSetPredicate) {
+    if (isSetPredicate.test(value)) {
+      throw new ProtocolException(
+          "The code uses the new discovery feature '"
+              + featureName
+              + "' but the runtime doesn't support it yet. Either remove the usage of this feature, or upgrade the runtime.",
+          500);
+    }
+  }
+
+  private static <T> void verifyFieldNull(String featureName, T value) {
+    verifyFieldNotSet(featureName, value, Objects::nonNull);
+  }
 }

sdk-core/src/main/java/dev/restate/sdk/core/EndpointRequestHandler.java

@@ -195,7 +195,7 @@ StaticResponseRequestProcessor handleDiscoveryRequest(HeadersAccessor headersAcc
           ProtocolException.UNSUPPORTED_MEDIA_TYPE_CODE);
     }
 
-    EndpointManifestSchema response = this.deploymentManifest.manifest();
+    EndpointManifestSchema response = this.deploymentManifest.manifest(version);
     LOG.info(
         "Replying to discovery request with services [{}]",
         response.getServices().stream().map(Service::getName).collect(Collectors.joining(",")));

sdk-core/src/test/java/dev/restate/sdk/core/AssertUtils.java

@@ -96,7 +96,7 @@ public static EndpointManifestSchemaAssert assertThatDiscovery(Endpoint endpoint
                 EndpointManifestSchema.ProtocolMode.BIDI_STREAM,
                 endpoint.getServiceDefinitions(),
                 true)
-            .manifest(),
+            .manifest(DiscoveryProtocol.MAX_SERVICE_DISCOVERY_PROTOCOL_VERSION),
         EndpointManifestSchemaAssert.class);
   }
 

sdk-core/src/test/java/dev/restate/sdk/core/ComponentDiscoveryHandlerTest.java

@@ -37,7 +37,8 @@ void handleWithMultipleServices() {
                             "greet", HandlerType.EXCLUSIVE, Serde.VOID, Serde.VOID, null)))),
             false);
 
-    EndpointManifestSchema manifest = deploymentManifest.manifest();
+    EndpointManifestSchema manifest =
+        deploymentManifest.manifest(DiscoveryProtocol.MAX_SERVICE_DISCOVERY_PROTOCOL_VERSION);
 
     assertThat(manifest.getServices()).extracting(Service::getName).containsOnly("MyGreeter");
     assertThat(manifest.getProtocolMode())