in kogito-codegen-modules/kogito-codegen-processes/src/main/java/org/kie/kogito/codegen/process/ProcessCodegen.java [279:535]
protected Collection<GeneratedFile> internalGenerate() {
List<ProcessGenerator> ps = new ArrayList<>();
List<ProcessInstanceGenerator> pis = new ArrayList<>();
List<ProcessExecutableModelGenerator> processExecutableModelGenerators = new ArrayList<>();
List<ProcessResourceGenerator> rgs = new ArrayList<>(); // REST resources
Map<ProcessCloudEventMeta, MessageConsumerGenerator> megs = new HashMap<>(); // message endpoints/consumers
List<MessageProducerGenerator> mpgs = new ArrayList<>(); // message producers
Map<String, ModelClassGenerator> processIdToModelGenerator = new HashMap<>();
Map<String, InputModelClassGenerator> processIdToInputModelGenerator = new HashMap<>();
Map<String, OutputModelClassGenerator> processIdToOutputModelGenerator = new HashMap<>();
Map<String, List<WorkItemModelMetaData>> processIdToWorkItemModel = new HashMap<>();
Map<String, ProcessMetaData> processIdToMetadata = new HashMap<>();
// first we generate all the data classes from variable declarations
for (WorkflowProcess workFlowProcess : processes.values()) {
// transaction is disabled by default for SW types
boolean defaultTransactionEnabled = !KogitoWorkflowProcess.SW_TYPE.equals(workFlowProcess.getType());
if (isTransactionEnabled(this, context(), defaultTransactionEnabled)) {
((WorkflowProcessImpl) workFlowProcess).setMetaData(WorkflowProcessParameters.WORKFLOW_PARAM_TRANSACTIONS.getName(), "true");
}
if (!skipModelGeneration(workFlowProcess)) {
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);
}
}
boolean isServerless = false;
// then we generate work items task inputs and outputs if any
for (WorkflowProcess workFlowProcess : processes.values()) {
isServerless |= KogitoWorkflowProcess.SW_TYPE.equals(workFlowProcess.getType());
if (KogitoWorkflowProcess.SW_TYPE.equals(workFlowProcess.getType())) {
continue;
}
WorkItemModelClassGenerator utcg = new WorkItemModelClassGenerator(workFlowProcess);
processIdToWorkItemModel.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 = sanitizeClassName(execModelGen.extractedProcessId());
KogitoWorkflowProcess workFlowProcess = execModelGen.process();
ModelClassGenerator modelClassGenerator =
processIdToModelGenerator.getOrDefault(execModelGen.getProcessId(), new ModelClassGenerator(context(), workFlowProcess));
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 for REST generation
if (context().hasRest()) {
ProcessResourceGenerator processResourceGenerator = new ProcessResourceGenerator(
context(),
workFlowProcess,
modelClassGenerator.className(),
execModelGen.className(),
applicationCanonicalName());
processResourceGenerator
.withWorkItems(processIdToWorkItemModel.get(workFlowProcess.getId()))
.withSignals(metaData.getSignals())
.withTriggers(metaData.isStartable(), metaData.isDynamic(), metaData.getTriggers())
.withTransaction(isTransactionEnabled(this, context()));
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 =
megs.computeIfAbsent(new ProcessCloudEventMeta(workFlowProcess.getId(), trigger), k -> new MessageConsumerGenerator(
context(),
workFlowProcess,
modelClassGenerator.className(),
execModelGen.className(),
applicationCanonicalName(),
trigger));
metaData.addConsumer(trigger.getName(), messageConsumerGenerator.compilationUnit());
} else if (trigger.getType().equals(TriggerMetaData.TriggerType.ProduceMessage)) {
MessageProducerGenerator messageProducerGenerator = new MessageProducerGenerator(
context(),
workFlowProcess,
trigger);
mpgs.add(messageProducerGenerator);
metaData.addProducer(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<WorkItemModelMetaData> utmd : processIdToWorkItemModel.values()) {
for (WorkItemModelMetaData ut : utmd) {
storeFile(MODEL_TYPE, WorkItemModelClassGenerator.generatedFilePath(ut.getInputModelClassName()), ut.generateInput());
storeFile(MODEL_TYPE, WorkItemModelClassGenerator.generatedFilePath(ut.getOutputModelClassName()), ut.generateOutput());
storeFile(MODEL_TYPE, WorkItemModelClassGenerator.generatedFilePath(ut.getTaskModelClassName()), ut.generateModel());
}
}
//Generating the Producer classes for Dependency Injection
StaticDependencyInjectionProducerGenerator staticDependencyInjectionProducerGenerator = StaticDependencyInjectionProducerGenerator.of(context());
staticDependencyInjectionProducerGenerator.generate()
.entrySet()
.forEach(entry -> storeFile(PRODUCER_TYPE, entry.getKey(), entry.getValue()));
generateBusinessCalendarProducer();
if (CodegenUtil.isTransactionEnabled(this, context()) && !isServerless) {
String template = "ExceptionHandlerTransaction";
TemplatedGenerator generator = TemplatedGenerator.builder()
.withTemplateBasePath("/class-templates/transaction/")
.withFallbackContext(JavaKogitoBuildContext.CONTEXT_NAME)
.withTargetTypeName(template)
.build(context(), template);
CompilationUnit handler = generator.compilationUnitOrThrow();
storeFile(MODEL_TYPE, generator.generatedFilePath(), handler.toString());
}
if (context().hasRESTForGenerator(this)) {
for (ProcessResourceGenerator resourceGenerator : rgs) {
storeFile(REST_TYPE, resourceGenerator.generatedFilePath(),
resourceGenerator.generate());
storeFile(MODEL_TYPE, WorkItemModelClassGenerator.generatedFilePath(resourceGenerator.getTaskModelFactoryClassName()), resourceGenerator.getTaskModelFactory());
}
}
for (MessageConsumerGenerator messageConsumerGenerator : megs.values()) {
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().hasRest() && 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;
}