Examples with PackageableRuntime org.finos.legend.engine.protocol.pure.v1.model.packageableElement.runtime.PackageableRuntime used on opensource projects

Example 1 with PackageableRuntime

use of org.finos.legend.engine.protocol.pure.v1.model.packageableElement.runtime.PackageableRuntime in project legend-engine by finos.

the class HelperRuntimeBuilder method buildEngineRuntime.

public static org.finos.legend.pure.m3.coreinstance.meta.pure.runtime.Runtime buildEngineRuntime(EngineRuntime engineRuntime, CompileContext context) {
    if (engineRuntime.mappings.isEmpty()) {
        throw new EngineException("Runtime must cover at least one mapping", engineRuntime.sourceInformation, EngineErrorType.COMPILATION);
    }
    // verify if each mapping associated with the PackageableRuntime exists
    List<Mapping> mappings = engineRuntime.mappings.stream().map(mappingPointer -> context.resolveMapping(mappingPointer.path, mappingPointer.sourceInformation)).collect(Collectors.toList());
    // build connections
    List<Connection> connections = new ArrayList<>();
    Set<String> ids = new HashSet<>();
    ListIterate.forEach(engineRuntime.connections, storeConnections -> {
        if (!storeConnections.store.path.equals("ModelStore")) {
            // verify stores used for indexing exist
            context.resolveStore(storeConnections.store.path, storeConnections.store.sourceInformation);
        }
        ListIterate.forEach(storeConnections.storeConnections, identifiedConnection -> {
            // ID must be unique across all connections of the runtime
            if (ids.contains(identifiedConnection.id)) {
                throw new EngineException("Runtime connection with ID '" + identifiedConnection.id + "' has already been specified", identifiedConnection.sourceInformation, EngineErrorType.COMPILATION);
            } else {
                ids.add(identifiedConnection.id);
            }
            if (identifiedConnection.connection instanceof ConnectionPointer) {
                ConnectionPointer pointer = (ConnectionPointer) identifiedConnection.connection;
                Store connectionStore = HelperRuntimeBuilder.getConnectionStore(context.resolveConnection(pointer.connection, pointer.sourceInformation));
                String connectionStorePath = HelperModelBuilder.getElementFullPath(connectionStore, context.pureModel.getExecutionSupport());
                if (!storeConnections.store.path.equals(connectionStorePath)) {
                    throw new EngineException("Connection pointer for store '" + connectionStorePath + "' should not be indexed to store '" + storeConnections.store.path + "'", pointer.sourceInformation, EngineErrorType.COMPILATION);
                }
                connections.add(identifiedConnection.connection);
            } else if (storeConnections.store.path.equals(identifiedConnection.connection.element)) {
                connections.add(identifiedConnection.connection);
            } else if (identifiedConnection.connection.element == null) {
                identifiedConnection.connection.element = storeConnections.store.path;
                identifiedConnection.connection.elementSourceInformation = identifiedConnection.connection.sourceInformation;
                connections.add(identifiedConnection.connection);
            } else {
                throw new EngineException("Connection for store '" + identifiedConnection.connection.element + "' should not be indexed to store '" + storeConnections.store.path + "'", identifiedConnection.connection.sourceInformation, EngineErrorType.COMPILATION);
            }
        });
    });
    // convert EngineRuntime with connection as a map indexes by store to Pure runtime which only contains an array of connections
    org.finos.legend.pure.m3.coreinstance.meta.pure.runtime.Runtime pureRuntime = new Root_meta_pure_runtime_Runtime_Impl("Root::meta::pure::runtime::Runtime");
    ListIterate.forEach(connections, connection -> {
        final org.finos.legend.pure.m3.coreinstance.meta.pure.runtime.Connection pureConnection = connection.accept(new ConnectionFirstPassBuilder(context));
        connection.accept(new ConnectionSecondPassBuilder(context, pureConnection));
        pureRuntime._connectionsAdd(pureConnection);
    });
    // verify runtime mapping coverage
    checkRuntimeMappingCoverage(pureRuntime, mappings, context, engineRuntime.sourceInformation);
    return pureRuntime;
}

Example 2 with PackageableRuntime

use of org.finos.legend.engine.protocol.pure.v1.model.packageableElement.runtime.PackageableRuntime in project legend-engine by finos.

the class RuntimeParseTreeWalker method visitRuntime.

public PackageableRuntime visitRuntime(RuntimeParserGrammar.RuntimeContext ctx) {
    PackageableRuntime runtime = new PackageableRuntime();
    runtime.name = PureGrammarParserUtility.fromIdentifier(ctx.qualifiedName().identifier());
    runtime._package = ctx.qualifiedName().packagePath() == null ? "" : PureGrammarParserUtility.fromPath(ctx.qualifiedName().packagePath().identifier());
    runtime.sourceInformation = walkerSourceInformation.getSourceInformation(ctx);
    runtime.runtimeValue = new EngineRuntime();
    runtime.runtimeValue.sourceInformation = runtime.sourceInformation;
    RuntimeParserGrammar.MappingsContext mappingsContext = PureGrammarParserUtility.validateAndExtractRequiredField(ctx.mappings(), "mappings", runtime.sourceInformation);
    // mappings
    runtime.runtimeValue.mappings = ListIterate.collect(mappingsContext.qualifiedName(), pathCtx -> {
        PackageableElementPointer pointer = new PackageableElementPointer();
        pointer.type = PackageableElementType.MAPPING;
        pointer.path = PureGrammarParserUtility.fromQualifiedName(pathCtx.packagePath() == null ? Collections.emptyList() : pathCtx.packagePath().identifier(), pathCtx.identifier());
        pointer.sourceInformation = walkerSourceInformation.getSourceInformation(pathCtx);
        return pointer;
    });
    // connections (optional)
    RuntimeParserGrammar.ConnectionsContext connectionsContext = PureGrammarParserUtility.validateAndExtractOptionalField(ctx.connections(), "connections", runtime.sourceInformation);
    this.addConnectionsByStore(connectionsContext, runtime.runtimeValue);
    return runtime;
}

Example 3 with PackageableRuntime

use of org.finos.legend.engine.protocol.pure.v1.model.packageableElement.runtime.PackageableRuntime in project legend-engine by finos.

the class ServiceTestGenerationHelper method resolveRuntime.

private static EngineRuntime resolveRuntime(Runtime runtime, PureModelContextData pureModelContextData) {
    if (runtime instanceof EngineRuntime) {
        return (EngineRuntime) runtime;
    }
    if (runtime instanceof LegacyRuntime) {
        return ((LegacyRuntime) runtime).toEngineRuntime();
    }
    if (runtime instanceof RuntimePointer) {
        String runtimeFullPath = ((RuntimePointer) runtime).runtime;
        PackageableElement found = Iterate.detect(pureModelContextData.getElements(), e -> runtimeFullPath.equals(e.getPath()));
        if (!(found instanceof PackageableRuntime)) {
            throw new RuntimeException("Can't find runtime '" + runtimeFullPath + "'");
        }
        return ((PackageableRuntime) found).runtimeValue;
    }
    throw new UnsupportedOperationException("Unsupported runtime type: " + runtime.getClass().getName());
}