Add additional validations to hosted service

legend-engine-xts-bigqueryFunction/legend-engine-xt-bigqueryFunction-api/src/main/java/org/finos/legend/engine/language/bigqueryFunction/api/BigQueryFunctionService.java

@@ -19,6 +19,7 @@
 import org.eclipse.collections.api.list.MutableList;
 import org.eclipse.collections.impl.factory.Lists;
 import org.finos.legend.engine.functionActivator.api.output.FunctionActivatorInfo;
+import org.finos.legend.engine.functionActivator.validation.FunctionActivatorResult;
 import org.finos.legend.engine.protocol.bigqueryFunction.deployment.BigQueryFunctionArtifact;
 import org.finos.legend.engine.protocol.bigqueryFunction.deployment.BigQueryFunctionContent;
 import org.finos.legend.engine.protocol.bigqueryFunction.deployment.BigQueryFunctionDeploymentConfiguration;
@@ -68,7 +69,7 @@ public boolean supports(Root_meta_external_function_activator_FunctionActivator
     }
 
     @Override
-    public MutableList<? extends FunctionActivatorError> validate(Identity identity, PureModel pureModel, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction activator, PureModelContext inputModel, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions)
+    public FunctionActivatorResult validate(Identity identity, PureModel pureModel, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction activator, PureModelContext inputModel, List<BigQueryFunctionDeploymentConfiguration> runtimeConfigurations, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions)
     {
         BigQueryFunctionArtifact artifact = BigQueryFunctionGenerator.generateArtifact(pureModel, activator, inputModel, routerExtensions);
         return this.validateArtifact(artifact);
@@ -78,7 +79,7 @@ public MutableList<? extends FunctionActivatorError> validate(Identity identity,
     public BigQueryFunctionDeploymentResult publishToSandbox(Identity identity, PureModel pureModel, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction activator, PureModelContext inputModel, List<BigQueryFunctionDeploymentConfiguration> runtimeConfigurations, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions)
     {
         BigQueryFunctionArtifact artifact = BigQueryFunctionGenerator.generateArtifact(pureModel, activator, inputModel, routerExtensions);
-        MutableList<? extends FunctionActivatorError> validationErrors = this.validateArtifact(artifact);
+        MutableList<? extends FunctionActivatorError> validationErrors = this.validateArtifact(artifact).getErrors();
 
         Root_meta_external_function_activator_bigQueryFunction_BigQueryFunctionDeploymentConfiguration deploymentConfiguration = ((Root_meta_external_function_activator_bigQueryFunction_BigQueryFunctionDeploymentConfiguration) activator._activationConfiguration());
         return validationErrors.notEmpty() ?
@@ -104,11 +105,11 @@ public List<BigQueryFunctionDeploymentConfiguration> selectConfig(List<FunctionA
         return Lists.mutable.withAll(configurations).select(e -> e instanceof BigQueryFunctionDeploymentConfiguration).collect(e -> (BigQueryFunctionDeploymentConfiguration) e);
     }
 
-    private MutableList<? extends FunctionActivatorError> validateArtifact(BigQueryFunctionArtifact artifact)
+    private FunctionActivatorResult validateArtifact(BigQueryFunctionArtifact artifact)
     {
         int size = ((BigQueryFunctionContent)artifact.content).sqlExpressions.size();
         return size == 1 ?
-                Lists.fixedSize.empty() :
-                Lists.fixedSize.with(new BigQueryFunctionError("BigQuery Function can't be used with a plan containing '" + size + "' SQL expressions", ((BigQueryFunctionContent)artifact.content).sqlExpressions));
+                new FunctionActivatorResult() :
+                new FunctionActivatorResult(Lists.fixedSize.with(new BigQueryFunctionError("BigQuery Function can't be used with a plan containing '" + size + "' SQL expressions", ((BigQueryFunctionContent)artifact.content).sqlExpressions)));
     }
 }

legend-engine-xts-bigqueryFunction/legend-engine-xt-bigqueryFunction-api/src/main/java/org/finos/legend/engine/language/bigqueryFunction/deployment/BigQueryFunctionDeploymentManager.java

@@ -27,7 +27,9 @@
 import org.finos.legend.engine.protocol.bigqueryFunction.deployment.BigQueryFunctionDeploymentResult;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorArtifact;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentConfiguration;
+import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentDetails;
 import org.finos.legend.engine.shared.core.identity.Identity;
+import org.finos.legend.pure.generated.Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction;
 import org.finos.legend.pure.generated.Root_meta_external_function_activator_bigQueryFunction_BigQueryFunctionDeploymentConfiguration;
 import org.finos.legend.pure.generated.Root_meta_pure_alloy_connections_alloy_specification_BigQueryDatasourceSpecification;
 import org.slf4j.Logger;
@@ -38,7 +40,7 @@
 /**
  * These deployment functions assume that the artifact has already been validated.
  */
-public class BigQueryFunctionDeploymentManager implements DeploymentManager<BigQueryFunctionArtifact, BigQueryFunctionDeploymentResult, BigQueryFunctionDeploymentConfiguration>
+public class BigQueryFunctionDeploymentManager implements DeploymentManager<BigQueryFunctionArtifact, BigQueryFunctionDeploymentResult, BigQueryFunctionDeploymentConfiguration, FunctionActivatorDeploymentDetails, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction>
 {
     private static final Logger LOGGER = LoggerFactory.getLogger(BigQueryFunctionDeploymentManager.class);
 
@@ -65,6 +67,12 @@ public BigQueryFunctionDeploymentResult deploy(Identity identity, BigQueryFuncti
         return new BigQueryFunctionDeploymentResult("", false);
     }
 
+    @Override
+    public FunctionActivatorDeploymentDetails getActivatorDetails(Identity identity, BigQueryFunctionDeploymentConfiguration runtimeConfig, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunction activator)
+    {
+        return new FunctionActivatorDeploymentDetails();
+    }
+
     public BigQueryFunctionDeploymentResult deployImpl(BigQueryFunctionArtifact artifact, Root_meta_external_function_activator_bigQueryFunction_BigQueryFunctionDeploymentConfiguration deploymentConfiguration)
     {
         LOGGER.info("Starting deployment");

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-deployment/pom.xml

@@ -42,6 +42,10 @@
             <groupId>org.finos.legend.engine</groupId>
             <artifactId>legend-engine-xt-functionActivator-generation</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.finos.legend.engine</groupId>
+            <artifactId>legend-engine-xt-functionActivator-pure</artifactId>
+        </dependency>
         <!-- ENGINE -->
 
         <!-- ECLIPSE -->

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-deployment/src/main/java/org/finos/legend/engine/functionActivator/deployment/DeploymentManager.java

@@ -19,12 +19,14 @@
 import org.finos.legend.engine.protocol.functionActivator.deployment.DeploymentResult;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorArtifact;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentConfiguration;
+import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentDetails;
 import org.finos.legend.engine.protocol.functionActivator.deployment.PostDeploymentActionResult;
 import org.finos.legend.engine.shared.core.identity.Identity;
+import org.finos.legend.pure.generated.Root_meta_external_function_activator_FunctionActivator;
 
 import java.util.List;
 
-public interface DeploymentManager<U extends FunctionActivatorArtifact, V extends DeploymentResult, W extends FunctionActivatorDeploymentConfiguration>
+public interface DeploymentManager<U extends FunctionActivatorArtifact, V extends DeploymentResult, W extends FunctionActivatorDeploymentConfiguration, X extends FunctionActivatorDeploymentDetails, Y extends Root_meta_external_function_activator_FunctionActivator>
 {
 
     public List<W> selectConfig(List<FunctionActivatorDeploymentConfiguration> availableConfigs);
@@ -33,14 +35,19 @@ public interface DeploymentManager<U extends FunctionActivatorArtifact, V extend
 
     public V deploy(Identity identity, U artifact, List<W> availableRuntimeConfigurations);
 
+    public X getActivatorDetails(Identity identity, W deploymentConfig, Y activator);
+
     public boolean canDeploy(FunctionActivatorArtifact activatorArtifact);
 
     public default List<PostDeploymentActionResult> deployActions(Identity identity, U artifact)
     {
         List<PostDeploymentActionResult> actionResults = Lists.mutable.empty();
         PostDeploymentActionLoader.extensions().forEach((ex) ->
         {
-            actionResults.addAll(ex.processAction(identity, artifact));
+            if (ex.canDeploy(artifact))
+            {
+                actionResults.addAll(ex.processAction(identity, artifact));
+            }
         });
         return actionResults;
     }

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/pom.xml

@@ -60,6 +60,10 @@
             <groupId>org.finos.legend.engine</groupId>
             <artifactId>legend-engine-identity-core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.finos.legend.engine</groupId>
+            <artifactId>legend-engine-pure-code-compiled-core</artifactId>
+        </dependency>
 
         <!-- ENGINE -->
 

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/generation/FunctionActivatorGenerator.java

@@ -14,22 +14,25 @@
 
 package org.finos.legend.engine.functionActivator.generation;
 
+import org.eclipse.collections.api.RichIterable;
+import org.eclipse.collections.api.block.function.Function;
 import org.eclipse.collections.api.factory.Lists;
 import org.finos.legend.engine.functionActivator.postDeployment.PostDeploymentActionLoader;
 import org.finos.legend.engine.language.pure.compiler.toPureGraph.PureModel;
 import org.finos.legend.engine.protocol.functionActivator.postDeployment.ActionContent;
 import org.finos.legend.pure.generated.Root_meta_external_function_activator_FunctionActivator;
+import org.finos.legend.pure.generated.Root_meta_pure_extension_Extension;
 
 import java.util.List;
 
 public abstract class FunctionActivatorGenerator
 {
-    public static List<ActionContent> generateActions(Root_meta_external_function_activator_FunctionActivator activator, PureModel pureModel)
+    public static List<ActionContent> generateActions(Root_meta_external_function_activator_FunctionActivator activator, PureModel pureModel, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions)
     {
         List<ActionContent> actionResults = Lists.mutable.empty();
         PostDeploymentActionLoader.generationExtensions().forEach((ex) ->
         {
-            actionResults.addAll(ex.generate(activator, pureModel));
+            actionResults.addAll(ex.generate(activator, pureModel, routerExtensions));
         });
         return actionResults;
     }

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/postDeployment/PostDeploymentActionDeploymentContract.java

@@ -23,4 +23,6 @@
 public interface PostDeploymentActionDeploymentContract
 {
     List<PostDeploymentActionResult> processAction(Identity identity, FunctionActivatorArtifact artifact);
+
+    boolean canDeploy(FunctionActivatorArtifact artifact);
 }

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/postDeployment/PostDeploymentGeneration.java

@@ -14,13 +14,16 @@
 
 package org.finos.legend.engine.functionActivator.postDeployment;
 
+import org.eclipse.collections.api.RichIterable;
+import org.eclipse.collections.api.block.function.Function;
 import org.finos.legend.engine.language.pure.compiler.toPureGraph.PureModel;
 import org.finos.legend.engine.protocol.functionActivator.postDeployment.ActionContent;
 import org.finos.legend.pure.generated.Root_meta_external_function_activator_FunctionActivator;
+import org.finos.legend.pure.generated.Root_meta_pure_extension_Extension;
 
 import java.util.List;
 
 public interface PostDeploymentGeneration
 {
-        List<ActionContent> generate(Root_meta_external_function_activator_FunctionActivator activator, PureModel pureModel);
+        List<ActionContent> generate(Root_meta_external_function_activator_FunctionActivator activator, PureModel pureModel, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions);
 }

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/validation/FunctionActivatorResult.java

@@ -0,0 +1,66 @@
+//  Copyright 2023 Goldman Sachs
+//
+//  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 org.finos.legend.engine.functionActivator.validation;
+
+import org.eclipse.collections.api.factory.Lists;
+import org.eclipse.collections.api.list.MutableList;
+
+public class FunctionActivatorResult
+{
+    public MutableList<FunctionActivatorError> errors = Lists.mutable.empty();
+    public MutableList<FunctionActivatorWarning> warnings = Lists.mutable.empty();
+
+    public FunctionActivatorResult()
+    {
+
+    }
+
+    public FunctionActivatorResult(MutableList<FunctionActivatorError> errors)
+    {
+        this.errors = errors;
+    }
+
+    public FunctionActivatorResult(MutableList<FunctionActivatorError> errors, MutableList<FunctionActivatorWarning> warnings)
+    {
+        this.errors = errors;
+        this.warnings = warnings;
+    }
+
+    public MutableList<FunctionActivatorError> getErrors()
+    {
+        return this.errors;
+    }
+
+    public MutableList<FunctionActivatorWarning> getWarnings()
+    {
+        return this.warnings;
+    }
+
+    public void addError(FunctionActivatorError error)
+    {
+        this.errors.add(error);
+    }
+
+    public void addWarning(FunctionActivatorWarning warning)
+    {
+        this.warnings.add(warning);
+    }
+
+    public void addAll(FunctionActivatorResult result)
+    {
+        this.errors.addAll(result.errors);
+        this.warnings.addAll(result.warnings);
+    }
+}

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/validation/FunctionActivatorValidator.java

@@ -15,14 +15,14 @@
 
 package org.finos.legend.engine.functionActivator.validation;
 
-import org.finos.legend.engine.language.pure.compiler.toPureGraph.PureModel;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorArtifact;
+import org.finos.legend.engine.protocol.functionActivator.postDeployment.ActionContent;
 import org.finos.legend.engine.shared.core.identity.Identity;
 import org.finos.legend.pure.generated.Root_meta_external_function_activator_FunctionActivator;
 
 import java.util.List;
 
-public interface FunctionActivatorValidator<T extends Root_meta_external_function_activator_FunctionActivator, V extends FunctionActivatorArtifact>
+public interface FunctionActivatorValidator<T extends Root_meta_external_function_activator_FunctionActivator, V extends FunctionActivatorArtifact, W extends ActionContent>
 {
     boolean supports(T activator);
 
@@ -32,5 +32,5 @@ public interface FunctionActivatorValidator<T extends Root_meta_external_functio
 
     List<FunctionActivatorError> validate(Identity identity, V artifact);
 
-    List<FunctionActivatorError> validate(T activator, PureModel pureModel);
+    FunctionActivatorResult validateArtifactActions(List<W> actual, List<W> exists);
 }

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-generation/src/main/java/org/finos/legend/engine/functionActivator/validation/FunctionActivatorWarning.java

@@ -0,0 +1,25 @@
+//  Copyright 2023 Goldman Sachs
+//
+//  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 org.finos.legend.engine.functionActivator.validation;
+
+public class FunctionActivatorWarning
+{
+    public String message;
+
+    public FunctionActivatorWarning(String message)
+    {
+        this.message = message;
+    }
+}

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-http-api/src/main/java/org/finos/legend/engine/functionActivator/api/FunctionActivatorAPI.java

@@ -24,7 +24,7 @@
 import org.eclipse.collections.api.list.MutableList;
 import org.finos.legend.engine.functionActivator.api.input.FunctionActivatorInput;
 import org.finos.legend.engine.functionActivator.api.output.FunctionActivatorInfo;
-import org.finos.legend.engine.functionActivator.validation.FunctionActivatorError;
+import org.finos.legend.engine.functionActivator.validation.FunctionActivatorResult;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentConfiguration;
 import org.finos.legend.engine.functionActivator.service.FunctionActivatorLoader;
 import org.finos.legend.engine.functionActivator.service.FunctionActivatorService;
@@ -115,7 +115,7 @@ public Response validate(FunctionActivatorInput input, @ApiParam(hidden = true)
             PureModel pureModel = modelManager.loadModel(input.model, clientVersion, identity, null);
             Root_meta_external_function_activator_FunctionActivator activator = (Root_meta_external_function_activator_FunctionActivator) pureModel.getPackageableElement(input.functionActivator);
             FunctionActivatorService<Root_meta_external_function_activator_FunctionActivator, FunctionActivatorDeploymentConfiguration, DeploymentResult> service = getActivatorService(activator, pureModel);
-            MutableList<? extends FunctionActivatorError> validate = service.validate(Identity.makeIdentity(profiles), pureModel, activator, input.model, routerExtensions);
+            FunctionActivatorResult validate = service.validate(Identity.makeIdentity(profiles), pureModel, activator, input.model, service.selectConfig(this.runtimeDeploymentConfig), routerExtensions);
             long end = System.currentTimeMillis();
             MetricsHandler.observeRequest(uriInfo != null ? uriInfo.getPath() : null, start, end);
             return Response.ok(objectMapper.writeValueAsString(validate)).type(MediaType.APPLICATION_JSON_TYPE).build();

legend-engine-xts-functionActivator/legend-engine-xt-functionActivator-http-api/src/main/java/org/finos/legend/engine/functionActivator/service/FunctionActivatorService.java

@@ -16,9 +16,8 @@
 
 import org.eclipse.collections.api.RichIterable;
 import org.eclipse.collections.api.block.function.Function;
-import org.eclipse.collections.api.list.MutableList;
 import org.finos.legend.engine.functionActivator.api.output.FunctionActivatorInfo;
-import org.finos.legend.engine.functionActivator.validation.FunctionActivatorError;
+import org.finos.legend.engine.functionActivator.validation.FunctionActivatorResult;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorArtifact;
 import org.finos.legend.engine.protocol.functionActivator.deployment.FunctionActivatorDeploymentConfiguration;
 import org.finos.legend.engine.language.pure.compiler.toPureGraph.PureModel;
@@ -43,7 +42,7 @@ default String type()
 
     boolean supports(Root_meta_external_function_activator_FunctionActivator packageableElement);
 
-    MutableList<? extends FunctionActivatorError> validate(Identity identity, PureModel pureModel, T functionActivator, PureModelContext inputModel, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions);
+    FunctionActivatorResult validate(Identity identity, PureModel pureModel, T functionActivator, PureModelContext inputModel, List<U> runtimeConfigurations, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions);
 
     V publishToSandbox(Identity identity, PureModel pureModel, T functionActivator, PureModelContext inputModel, List<U> runtimeConfigurations, Function<PureModel, RichIterable<? extends Root_meta_pure_extension_Extension>> routerExtensions);