Search in sources :

Example 1 with ProcessCloudEventMetaFactoryGenerator

use of org.kie.kogito.codegen.process.events.ProcessCloudEventMetaFactoryGenerator in project kogito-runtimes by kiegroup.

the class ProcessCodegen method internalGenerate.

@Override
protected Collection<GeneratedFile> internalGenerate() {
    List<ProcessGenerator> ps = new ArrayList<>();
    List<ProcessInstanceGenerator> pis = new ArrayList<>();
    List<ProcessExecutableModelGenerator> processExecutableModelGenerators = new ArrayList<>();
    // REST resources
    List<ProcessResourceGenerator> rgs = new ArrayList<>();
    // message endpoints/consumers
    List<MessageConsumerGenerator> megs = new ArrayList<>();
    // message producers
    List<MessageProducerGenerator> mpgs = new ArrayList<>();
    Map<String, ModelClassGenerator> processIdToModelGenerator = new HashMap<>();
    Map<String, InputModelClassGenerator> processIdToInputModelGenerator = new HashMap<>();
    Map<String, OutputModelClassGenerator> processIdToOutputModelGenerator = new HashMap<>();
    Map<String, List<UserTaskModelMetaData>> processIdToUserTaskModel = new HashMap<>();
    Map<String, ProcessMetaData> processIdToMetadata = new HashMap<>();
    // first we generate all the data classes from variable declarations
    for (WorkflowProcess workFlowProcess : processes.values()) {
        ModelClassGenerator mcg = new ModelClassGenerator(context(), workFlowProcess);
        processIdToModelGenerator.put(workFlowProcess.getId(), mcg);
        InputModelClassGenerator imcg = new InputModelClassGenerator(context(), workFlowProcess);
        processIdToInputModelGenerator.put(workFlowProcess.getId(), imcg);
        OutputModelClassGenerator omcg = new OutputModelClassGenerator(context(), workFlowProcess);
        processIdToOutputModelGenerator.put(workFlowProcess.getId(), omcg);
    }
    // then we generate user task inputs and outputs if any
    for (WorkflowProcess workFlowProcess : processes.values()) {
        UserTasksModelClassGenerator utcg = new UserTasksModelClassGenerator(workFlowProcess);
        processIdToUserTaskModel.put(workFlowProcess.getId(), utcg.generate());
    }
    // then we can instantiate the exec model generator
    // with the data classes that we have already resolved
    ProcessToExecModelGenerator execModelGenerator = new ProcessToExecModelGenerator(context().getClassLoader());
    // collect all process descriptors (exec model)
    for (KogitoWorkflowProcess workFlowProcess : processes.values()) {
        ProcessExecutableModelGenerator execModelGen = new ProcessExecutableModelGenerator(workFlowProcess, execModelGenerator);
        String packageName = workFlowProcess.getPackageName();
        String id = workFlowProcess.getId();
        try {
            ProcessMetaData generate = execModelGen.generate();
            processIdToMetadata.put(id, generate);
            processExecutableModelGenerators.add(execModelGen);
        } catch (RuntimeException e) {
            throw new ProcessCodegenException(id, packageName, e);
        }
    }
    // generate Process, ProcessInstance classes and the REST resource
    for (ProcessExecutableModelGenerator execModelGen : processExecutableModelGenerators) {
        String classPrefix = StringUtils.ucFirst(execModelGen.extractedProcessId());
        KogitoWorkflowProcess workFlowProcess = execModelGen.process();
        ModelClassGenerator modelClassGenerator = processIdToModelGenerator.get(execModelGen.getProcessId());
        ProcessGenerator p = new ProcessGenerator(context(), workFlowProcess, execModelGen, classPrefix, modelClassGenerator.className(), applicationCanonicalName());
        ProcessInstanceGenerator pi = new ProcessInstanceGenerator(workFlowProcess.getPackageName(), classPrefix, modelClassGenerator.generate());
        ProcessMetaData metaData = processIdToMetadata.get(workFlowProcess.getId());
        // Creating and adding the ResourceGenerator
        ProcessResourceGenerator processResourceGenerator = new ProcessResourceGenerator(context(), workFlowProcess, modelClassGenerator.className(), execModelGen.className(), applicationCanonicalName());
        processResourceGenerator.withUserTasks(processIdToUserTaskModel.get(workFlowProcess.getId())).withSignals(metaData.getSignals()).withTriggers(metaData.isStartable(), metaData.isDynamic());
        rgs.add(processResourceGenerator);
        if (metaData.getTriggers() != null) {
            for (TriggerMetaData trigger : metaData.getTriggers()) {
                // generate message consumers for processes with message start events
                if (trigger.getType().equals(TriggerMetaData.TriggerType.ConsumeMessage)) {
                    MessageConsumerGenerator messageConsumerGenerator = new MessageConsumerGenerator(context(), workFlowProcess, modelClassGenerator.className(), execModelGen.className(), applicationCanonicalName(), trigger);
                    megs.add(messageConsumerGenerator);
                    metaData.getConsumers().put(trigger.getName(), messageConsumerGenerator.compilationUnit());
                } else if (trigger.getType().equals(TriggerMetaData.TriggerType.ProduceMessage)) {
                    MessageProducerGenerator messageProducerGenerator = new MessageProducerGenerator(context(), workFlowProcess, trigger);
                    mpgs.add(messageProducerGenerator);
                    metaData.getProducers().put(trigger.getName(), messageProducerGenerator.compilationUnit());
                }
            }
        }
        processGenerators.add(p);
        ps.add(p);
        pis.add(pi);
    }
    for (ModelClassGenerator modelClassGenerator : processIdToModelGenerator.values()) {
        ModelMetaData mmd = modelClassGenerator.generate();
        storeFile(MODEL_TYPE, modelClassGenerator.generatedFilePath(), mmd.generate());
    }
    for (InputModelClassGenerator modelClassGenerator : processIdToInputModelGenerator.values()) {
        ModelMetaData mmd = modelClassGenerator.generate();
        storeFile(MODEL_TYPE, modelClassGenerator.generatedFilePath(), mmd.generate());
    }
    for (OutputModelClassGenerator modelClassGenerator : processIdToOutputModelGenerator.values()) {
        ModelMetaData mmd = modelClassGenerator.generate();
        storeFile(MODEL_TYPE, modelClassGenerator.generatedFilePath(), mmd.generate());
    }
    for (List<UserTaskModelMetaData> utmd : processIdToUserTaskModel.values()) {
        for (UserTaskModelMetaData ut : utmd) {
            storeFile(MODEL_TYPE, UserTasksModelClassGenerator.generatedFilePath(ut.getInputModelClassName()), ut.generateInput());
            storeFile(MODEL_TYPE, UserTasksModelClassGenerator.generatedFilePath(ut.getOutputModelClassName()), ut.generateOutput());
            storeFile(MODEL_TYPE, UserTasksModelClassGenerator.generatedFilePath(ut.getTaskModelClassName()), ut.generateModel());
        }
    }
    // Generating the Producer classes for Dependency Injection
    StaticDependencyInjectionProducerGenerator.of(context()).generate().entrySet().forEach(entry -> storeFile(PRODUCER_TYPE, entry.getKey(), entry.getValue()));
    if (context().hasRESTForGenerator(this)) {
        for (ProcessResourceGenerator resourceGenerator : rgs) {
            storeFile(REST_TYPE, resourceGenerator.generatedFilePath(), resourceGenerator.generate());
            storeFile(MODEL_TYPE, UserTasksModelClassGenerator.generatedFilePath(resourceGenerator.getTaskModelFactoryClassName()), resourceGenerator.getTaskModelFactory());
        }
    }
    for (MessageConsumerGenerator messageConsumerGenerator : megs) {
        storeFile(MESSAGE_CONSUMER_TYPE, messageConsumerGenerator.generatedFilePath(), messageConsumerGenerator.generate());
    }
    for (MessageProducerGenerator messageProducerGenerator : mpgs) {
        storeFile(MESSAGE_PRODUCER_TYPE, messageProducerGenerator.generatedFilePath(), messageProducerGenerator.generate());
    }
    for (ProcessGenerator p : ps) {
        storeFile(PROCESS_TYPE, p.generatedFilePath(), p.generate());
        p.getAdditionalClasses().forEach(cp -> {
            String packageName = cp.getPackageDeclaration().map(pd -> pd.getName().toString()).orElse("");
            String clazzName = cp.findFirst(ClassOrInterfaceDeclaration.class).map(cls -> cls.getName().toString()).get();
            String path = (packageName + "." + clazzName).replace('.', '/') + ".java";
            storeFile(GeneratedFileType.SOURCE, path, cp.toString());
        });
    }
    if ((context().getAddonsConfig().useProcessSVG())) {
        Map<String, byte[]> svgs = context().getContextAttribute(ContextAttributesConstants.PROCESS_AUTO_SVG_MAPPING, Map.class);
        svgs.keySet().stream().forEach(key -> storeFile(GeneratedFileType.INTERNAL_RESOURCE, "META-INF/processSVG/" + key + ".svg", svgs.get(key)));
    }
    if (context().hasRESTForGenerator(this)) {
        final ProcessCloudEventMetaFactoryGenerator topicsGenerator = new ProcessCloudEventMetaFactoryGenerator(context(), processExecutableModelGenerators);
        storeFile(REST_TYPE, topicsGenerator.generatedFilePath(), topicsGenerator.generate());
    }
    for (ProcessInstanceGenerator pi : pis) {
        storeFile(PROCESS_INSTANCE_TYPE, pi.generatedFilePath(), pi.generate());
    }
    // generate Grafana dashboards
    if (context().getAddonsConfig().usePrometheusMonitoring()) {
        Optional<String> globalDbJson = generateOperationalDashboard(GLOBAL_OPERATIONAL_DASHBOARD_TEMPLATE, "Global", context().getPropertiesMap(), "Global", context().getGAV().orElse(KogitoGAV.EMPTY_GAV), false);
        String globalDbName = buildDashboardName(context().getGAV(), "Global");
        globalDbJson.ifPresent(dashboard -> generatedFiles.addAll(DashboardGeneratedFileUtils.operational(dashboard, globalDbName + ".json")));
        for (KogitoWorkflowProcess process : processes.values()) {
            String dbName = buildDashboardName(context().getGAV(), process.getId());
            Optional<String> dbJson = generateOperationalDashboard(PROCESS_OPERATIONAL_DASHBOARD_TEMPLATE, process.getId(), context().getPropertiesMap(), process.getId(), context().getGAV().orElse(KogitoGAV.EMPTY_GAV), false);
            dbJson.ifPresent(dashboard -> generatedFiles.addAll(DashboardGeneratedFileUtils.operational(dashboard, dbName + ".json")));
        }
    }
    return generatedFiles;
}
Also used : Arrays(java.util.Arrays) ServerlessWorkflowParser(org.kie.kogito.serverless.workflow.parser.ServerlessWorkflowParser) ProcessToExecModelGenerator(org.jbpm.compiler.canonical.ProcessToExecModelGenerator) XmlProcessReader(org.jbpm.compiler.xml.XmlProcessReader) LoggerFactory(org.slf4j.LoggerFactory) ProcessCloudEventMetaFactoryGenerator(org.kie.kogito.codegen.process.events.ProcessCloudEventMetaFactoryGenerator) SemanticModules(org.jbpm.compiler.xml.core.SemanticModules) BPMNSemanticModule(org.jbpm.bpmn2.xml.BPMNSemanticModule) CollectedResource(org.kie.kogito.codegen.api.io.CollectedResource) Map(java.util.Map) ModelMetaData(org.jbpm.compiler.canonical.ModelMetaData) KogitoBuildContext(org.kie.kogito.codegen.api.context.KogitoBuildContext) ValidationLogDecorator(org.kie.kogito.process.validation.ValidationLogDecorator) Collection(java.util.Collection) Process(org.kie.api.definition.process.Process) Set(java.util.Set) ApplicationSection(org.kie.kogito.codegen.api.ApplicationSection) Reader(java.io.Reader) BPMNDISemanticModule(org.jbpm.bpmn2.xml.BPMNDISemanticModule) String.format(java.lang.String.format) Resource(org.kie.api.io.Resource) BPMNExtensionsSemanticModule(org.jbpm.bpmn2.xml.BPMNExtensionsSemanticModule) List(java.util.List) Stream(java.util.stream.Stream) ProcessConfigGenerator(org.kie.kogito.codegen.process.config.ProcessConfigGenerator) SAXException(org.xml.sax.SAXException) Optional(java.util.Optional) ValidationException(org.kie.kogito.process.validation.ValidationException) ClassOrInterfaceDeclaration(com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) GeneratedFileType(org.drools.codegen.common.GeneratedFileType) TriggerMetaData(org.jbpm.compiler.canonical.TriggerMetaData) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) HashSet(java.util.HashSet) ProcessValidatorRegistry(org.jbpm.process.core.validation.ProcessValidatorRegistry) WorkflowProcess(org.kie.api.definition.process.WorkflowProcess) ContextAttributesConstants(org.kie.kogito.codegen.api.context.ContextAttributesConstants) ValidationContext(org.kie.kogito.process.validation.ValidationContext) GrafanaConfigurationWriter.generateOperationalDashboard(org.kie.kogito.grafana.GrafanaConfigurationWriter.generateOperationalDashboard) UserTaskModelMetaData(org.jbpm.compiler.canonical.UserTaskModelMetaData) AbstractGenerator(org.kie.kogito.codegen.core.AbstractGenerator) GrafanaConfigurationWriter.buildDashboardName(org.kie.kogito.grafana.GrafanaConfigurationWriter.buildDashboardName) Logger(org.slf4j.Logger) IOException(java.io.IOException) File(java.io.File) GeneratedInfo(org.kie.kogito.codegen.api.GeneratedInfo) ProcessMetaData(org.jbpm.compiler.canonical.ProcessMetaData) Collectors.toList(java.util.stream.Collectors.toList) KogitoGAV(org.kie.kogito.KogitoGAV) StringUtils(org.drools.util.StringUtils) DashboardGeneratedFileUtils(org.kie.kogito.codegen.core.DashboardGeneratedFileUtils) KogitoWorkflowProcess(org.kie.kogito.internal.process.runtime.KogitoWorkflowProcess) SourceFileCodegenBindEvent(org.kie.kogito.codegen.api.SourceFileCodegenBindEvent) Collections(java.util.Collections) GeneratedFile(org.drools.codegen.common.GeneratedFile) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) List(java.util.List) ArrayList(java.util.ArrayList) Collectors.toList(java.util.stream.Collectors.toList) WorkflowProcess(org.kie.api.definition.process.WorkflowProcess) KogitoWorkflowProcess(org.kie.kogito.internal.process.runtime.KogitoWorkflowProcess) UserTaskModelMetaData(org.jbpm.compiler.canonical.UserTaskModelMetaData) ProcessToExecModelGenerator(org.jbpm.compiler.canonical.ProcessToExecModelGenerator) KogitoWorkflowProcess(org.kie.kogito.internal.process.runtime.KogitoWorkflowProcess) ProcessCloudEventMetaFactoryGenerator(org.kie.kogito.codegen.process.events.ProcessCloudEventMetaFactoryGenerator) TriggerMetaData(org.jbpm.compiler.canonical.TriggerMetaData) ModelMetaData(org.jbpm.compiler.canonical.ModelMetaData) UserTaskModelMetaData(org.jbpm.compiler.canonical.UserTaskModelMetaData) ProcessMetaData(org.jbpm.compiler.canonical.ProcessMetaData)

Aggregations

ClassOrInterfaceDeclaration (com.github.javaparser.ast.body.ClassOrInterfaceDeclaration)1 File (java.io.File)1 IOException (java.io.IOException)1 Reader (java.io.Reader)1 String.format (java.lang.String.format)1 ArrayList (java.util.ArrayList)1 Arrays (java.util.Arrays)1 Collection (java.util.Collection)1 Collections (java.util.Collections)1 HashMap (java.util.HashMap)1 HashSet (java.util.HashSet)1 List (java.util.List)1 Map (java.util.Map)1 Optional (java.util.Optional)1 Set (java.util.Set)1 Collectors.toList (java.util.stream.Collectors.toList)1 Stream (java.util.stream.Stream)1 GeneratedFile (org.drools.codegen.common.GeneratedFile)1 GeneratedFileType (org.drools.codegen.common.GeneratedFileType)1 StringUtils (org.drools.util.StringUtils)1