use of org.kie.kogito.codegen.process.persistence.proto.ReflectionProtoGenerator in project kogito-runtimes by kiegroup.
the class MongoDBPersistenceGeneratorTest method test.
@ParameterizedTest
@MethodSource("persistenceTestContexts")
void test(KogitoBuildContext context) {
context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context));
Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
if (context.hasDI()) {
Optional<GeneratedFile> generatedCLASSFile = generatedFiles.stream().filter(gf -> gf.category() == GeneratedFileType.SOURCE.category()).filter(f -> PERSISTENCE_FILE_PATH.equals(f.relativePath())).findAny();
assertTrue(generatedCLASSFile.isPresent());
GeneratedFile classFile = generatedCLASSFile.get();
assertEquals(PERSISTENCE_FILE_PATH, classFile.relativePath());
final CompilationUnit compilationUnit = parse(new ByteArrayInputStream(classFile.contents()));
final ClassOrInterfaceDeclaration classDeclaration = compilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
assertNotNull(classDeclaration);
final MethodDeclaration methodDeclaration = classDeclaration.findFirst(MethodDeclaration.class, d -> d.getName().getIdentifier().equals("dbName")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"dbName\"!"));
assertNotNull(methodDeclaration);
assertTrue(methodDeclaration.getBody().isPresent());
final BlockStmt body = methodDeclaration.getBody().get();
assertThat(body.getStatements().size()).isOne();
assertTrue(body.getStatements().get(0).isReturnStmt());
final ReturnStmt returnStmt = (ReturnStmt) body.getStatements().get(0);
assertThat(returnStmt.toString()).contains("kogito");
final MethodDeclaration transactionMethodDeclaration = classDeclaration.findFirst(MethodDeclaration.class, d -> "transactionManager".equals(d.getName().getIdentifier())).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"transactionManager\"!"));
assertNotNull(transactionMethodDeclaration);
assertTrue(transactionMethodDeclaration.getBody().isPresent());
final BlockStmt transactionMethodBody = transactionMethodDeclaration.getBody().get();
assertThat(transactionMethodBody.getStatements().size()).isOne();
assertTrue(transactionMethodBody.getStatements().get(0).isReturnStmt());
final ReturnStmt transactionReturnStmt = (ReturnStmt) transactionMethodBody.getStatements().get(0);
assertThat(transactionReturnStmt.toString()).contains("transactionManager");
Optional<GeneratedFile> generatedTransactionCLASSFile = generatedFiles.stream().filter(gf -> gf.category() == GeneratedFileType.SOURCE.category()).filter(f -> TRANSACTION_FILE_PATH.equals(f.relativePath())).findAny();
assertTrue(generatedTransactionCLASSFile.isPresent());
final CompilationUnit transactionCompilationUnit = parse(new ByteArrayInputStream(generatedTransactionCLASSFile.get().contents()));
final ClassOrInterfaceDeclaration transactionClassDeclaration = transactionCompilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
assertNotNull(transactionClassDeclaration);
final List<ConstructorDeclaration> constructorDeclarations = transactionCompilationUnit.findAll(ConstructorDeclaration.class);
assertEquals(2, constructorDeclarations.size());
Optional<ConstructorDeclaration> annotatedConstructorDeclaration = constructorDeclarations.stream().filter(c -> c.isAnnotationPresent(injectionAnnotation(context))).findAny();
assertTrue(annotatedConstructorDeclaration.isPresent());
final MethodDeclaration transactionEnabledMethodDeclaration = transactionClassDeclaration.findFirst(MethodDeclaration.class, d -> d.getName().getIdentifier().equals("enabled")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a method named \"enabled\"!"));
assertNotNull(transactionEnabledMethodDeclaration);
assertTrue(transactionEnabledMethodDeclaration.getBody().isPresent());
final BlockStmt enabledMethodBody = transactionEnabledMethodDeclaration.getBody().get();
assertThat(enabledMethodBody.getStatements().size()).isOne();
assertTrue(enabledMethodBody.getStatements().get(0).isReturnStmt());
final ReturnStmt enabledReturnStmt = (ReturnStmt) enabledMethodBody.getStatements().get(0);
assertThat(enabledReturnStmt.toString()).contains("enabled");
final FieldDeclaration transactionEnabledFieldDeclaration = transactionClassDeclaration.findFirst(FieldDeclaration.class, f -> f.getVariable(0).getName().getIdentifier().equals("enabled")).orElseThrow(() -> new NoSuchElementException("Class declaration doesn't contain a field named \"enabled\"!"));
assertNotNull(transactionEnabledFieldDeclaration);
final AnnotationExpr transactionEnabledAnnotationDeclaration = transactionEnabledFieldDeclaration.findFirst(AnnotationExpr.class, a -> ((Name) a.getChildNodes().get(0)).getIdentifier().equals(configInjectionAnnotation(context))).orElseThrow(() -> new NoSuchElementException("Field declaration doesn't contain an annotation named \"" + configInjectionAnnotation(context) + "\"!"));
assertNotNull(transactionEnabledAnnotationDeclaration);
assertThat(transactionEnabledAnnotationDeclaration.getChildNodes().get(1).toString()).contains("kogito.persistence.transaction.enabled");
}
}
use of org.kie.kogito.codegen.process.persistence.proto.ReflectionProtoGenerator in project kogito-runtimes by kiegroup.
the class AbstractPersistenceGeneratorTest method persistenceGeneratorSanityCheck.
@ParameterizedTest
@MethodSource("persistenceTestContexts")
void persistenceGeneratorSanityCheck(KogitoBuildContext context) {
context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context, null));
Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
int expectedDataIndexProto = hasDataIndexProto(context) ? 2 : 0;
int expectedListDataIndexProto = hasDataIndexProto(context) ? 1 : 0;
assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(ProtoGenerator.PROTO_TYPE)).count()).isEqualTo(expectedDataIndexProto);
assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(ProtoGenerator.PROTO_TYPE) && gf.relativePath().endsWith(".json")).count()).isEqualTo(expectedListDataIndexProto);
int expectedProtoMarshaller = hasProtoMarshaller(context) ? 10 : 0;
assertThat(generatedFiles.stream().filter(gf -> gf.type().equals(GeneratedFileType.SOURCE) && gf.relativePath().endsWith("Marshaller.java"))).hasSize(expectedProtoMarshaller);
}
use of org.kie.kogito.codegen.process.persistence.proto.ReflectionProtoGenerator in project kogito-runtimes by kiegroup.
the class InfinispanPersistenceGeneratorTest method test.
@ParameterizedTest
@MethodSource("persistenceTestContexts")
void test(KogitoBuildContext context) {
context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context));
Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
if (context.hasDI()) {
Optional<GeneratedFile> persistenceFactoryImpl = generatedFiles.stream().filter(gf -> gf.relativePath().equals("org/kie/kogito/persistence/KogitoProcessInstancesFactoryImpl.java")).findFirst();
if (hasDataIndexProto(context)) {
List<GeneratedFile> marshallerFiles = generatedFiles.stream().filter(gf -> gf.relativePath().endsWith("MessageMarshaller.java")).collect(Collectors.toList());
String expectedMarshaller = "PersonMessageMarshaller";
assertThat(persistenceFactoryImpl).isNotEmpty();
assertThat(marshallerFiles.size()).isEqualTo(1);
assertThat(marshallerFiles.get(0).relativePath()).endsWith(expectedMarshaller + ".java");
}
final CompilationUnit compilationUnit = parse(new ByteArrayInputStream(persistenceFactoryImpl.get().contents()));
compilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
}
}
use of org.kie.kogito.codegen.process.persistence.proto.ReflectionProtoGenerator in project kogito-runtimes by kiegroup.
the class KafkaPersistenceGeneratorTest method test.
@ParameterizedTest
@MethodSource("persistenceTestContexts")
void test(KogitoBuildContext context) {
context.setApplicationProperty(KOGITO_PERSISTENCE_TYPE, persistenceType());
ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().build(Collections.singleton(GeneratedPOJO.class));
PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context));
Collection<GeneratedFile> generatedFiles = persistenceGenerator.generate();
if (context.hasDI()) {
Optional<GeneratedFile> persistenceFactoryImpl = generatedFiles.stream().filter(gf -> gf.relativePath().equals("org/kie/kogito/persistence/KogitoProcessInstancesFactoryImpl.java")).findFirst();
if (hasProtoMarshaller(context)) {
List<GeneratedFile> marshallerFiles = generatedFiles.stream().filter(gf -> gf.relativePath().endsWith("MessageMarshaller.java")).collect(Collectors.toList());
String expectedMarshaller = "PersonMessageMarshaller";
assertThat(persistenceFactoryImpl).isNotEmpty();
assertThat(marshallerFiles.size()).isEqualTo(1);
assertThat(marshallerFiles.get(0).relativePath()).endsWith(expectedMarshaller + ".java");
}
final CompilationUnit compilationUnit = parse(new ByteArrayInputStream(persistenceFactoryImpl.get().contents()));
compilationUnit.findFirst(ClassOrInterfaceDeclaration.class).orElseThrow(() -> new NoSuchElementException("Compilation unit doesn't contain a class or interface declaration!"));
}
}
use of org.kie.kogito.codegen.process.persistence.proto.ReflectionProtoGenerator in project kogito-runtimes by kiegroup.
the class ProcessClassesMojo method execute.
@Override
public void execute() throws MojoExecutionException {
try {
JavaCompilerSettings settings = new JavaCompilerSettings();
List<URL> pathUrls = new ArrayList<>();
for (String path : project.getRuntimeClasspathElements()) {
File pathFile = new File(path);
pathUrls.add(pathFile.toURI().toURL());
settings.addClasspath(pathFile);
}
URL[] urlsForClassLoader = pathUrls.toArray(new URL[pathUrls.size()]);
// need to define parent classloader which knows all dependencies of the plugin
try (URLClassLoader cl = new URLClassLoader(urlsForClassLoader, Thread.currentThread().getContextClassLoader())) {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.addUrls(cl.getURLs());
builder.addClassLoader(cl);
Reflections reflections = new Reflections(builder);
@SuppressWarnings({ "rawtype", "unchecked" }) Set<Class<?>> modelClasses = (Set) reflections.getSubTypesOf(Model.class);
// collect constructor parameters so the generated class can create constructor with injection
Class<?> persistenceClass = reflections.getSubTypesOf(ProcessInstancesFactory.class).stream().filter(c -> !c.isInterface()).findFirst().orElse(null);
ReflectionProtoGenerator protoGenerator = ReflectionProtoGenerator.builder().withPersistenceClass(persistenceClass).build(modelClasses);
KogitoBuildContext context = discoverKogitoRuntimeContext(cl);
// Generate persistence files
PersistenceGenerator persistenceGenerator = new PersistenceGenerator(context, protoGenerator, new ReflectionMarshallerGenerator(context, protoGenerator.getDataClasses()));
Collection<GeneratedFile> persistenceFiles = persistenceGenerator.generate();
validateGeneratedFileTypes(persistenceFiles, asList(GeneratedFileType.Category.SOURCE, GeneratedFileType.Category.INTERNAL_RESOURCE, GeneratedFileType.Category.STATIC_HTTP_RESOURCE));
Collection<GeneratedFile> generatedClasses = persistenceFiles.stream().filter(x -> x.category().equals(GeneratedFileType.Category.SOURCE)).collect(Collectors.toList());
Collection<GeneratedFile> generatedResources = persistenceFiles.stream().filter(x -> x.category().equals(GeneratedFileType.Category.INTERNAL_RESOURCE) || x.category().equals(GeneratedFileType.Category.STATIC_HTTP_RESOURCE)).collect(Collectors.toList());
// Compile and write persistence files
compileAndWriteClasses(generatedClasses, cl, settings);
// Dump resources
generatedResources.forEach(this::writeGeneratedFile);
// Json schema generation
Stream<Class<?>> processClassStream = reflections.getTypesAnnotatedWith(ProcessInput.class).stream();
generateJsonSchema(processClassStream).forEach(this::writeGeneratedFile);
Stream<Class<?>> userTaskClassStream = reflections.getTypesAnnotatedWith(UserTask.class).stream();
generateJsonSchema(userTaskClassStream).forEach(this::writeGeneratedFile);
}
} catch (Exception e) {
throw new MojoExecutionException("Error during processing model classes", e);
}
}
Aggregations