Examples with GenerateAotSources org.springframework.aot.gradle.tasks.GenerateAotSources used on opensource projects

Example 1 with GenerateAotSources

use of org.springframework.aot.gradle.tasks.GenerateAotSources in project spring-native by spring-projects-experimental.

the class SpringAotGradlePlugin method apply.

@Override
public void apply(final Project project) {
    project.getPluginManager().apply(NativeImagePlugin.class);
    project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
        GraalVMExtension graal = project.getExtensions().findByType(GraalVMExtension.class);
        graal.getToolchainDetection().set(false);
        // Create the "springAot" DSL extension for user configuration
        project.getExtensions().create(EXTENSION_NAME, SpringAotExtension.class, project.getObjects());
        // Automatically add the spring-native dependency to the implementation configuration
        // as it's required for hints
        addSpringNativeDependency(project);
        Path generatedFilesPath = createGeneratedSourcesFolder(project);
        // deprecation replaced with new API introduced in Gradle 7.1
        // noinspection deprecation
        SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
        // Create a detached configuration that holds dependencies for AOT generation
        SourceSet aotMainSourceSet = createAotMainSourceSet(sourceSets, project.getConfigurations(), generatedFilesPath);
        GenerateAotSources generateAotSources = createGenerateAotSourcesTask(project, sourceSets);
        project.getTasks().named(aotMainSourceSet.getCompileJavaTaskName(), JavaCompile.class, (aotCompileJava) -> {
            aotCompileJava.source(generateAotSources.getSourcesOutputDirectory());
        });
        project.getTasks().named(aotMainSourceSet.getProcessResourcesTaskName(), Copy.class, (aotProcessResources) -> {
            aotProcessResources.from(generateAotSources.getResourcesOutputDirectory());
            aotProcessResources.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
        });
        Jar generatedSourcesJar = project.getTasks().create(aotMainSourceSet.getJarTaskName(), Jar.class, jar -> {
            jar.from(aotMainSourceSet.getOutput());
            jar.setGroup(BasePlugin.BUILD_GROUP);
            jar.getArchiveClassifier().convention("aot");
        });
        createAotMainConfiguration(project, aotMainSourceSet);
        // Generated+compiled sources must be used by 'bootRun' and packaged by 'bootJar'
        project.getPlugins().withType(SpringBootPlugin.class, springBootPlugin -> {
            Provider<RegularFile> generatedSources = generatedSourcesJar.getArchiveFile();
            project.getTasks().named(SpringBootPlugin.BOOT_JAR_TASK_NAME, BootJar.class, (bootJar) -> {
                bootJar.setClasspath(project.files(generatedSources).plus(bootJar.getClasspath()));
            });
            project.getTasks().named("bootRun", BootRun.class, (bootRun) -> {
                bootRun.setClasspath(project.files(generatedSources).plus(bootRun.getClasspath()));
            });
        });
        // Create a detached configuration that holds dependencies for AOT test generation
        SourceSet aotTestSourceSet = createAotTestSourceSet(sourceSets, project.getConfigurations(), generatedFilesPath);
        GenerateAotTestSources generateAotTestSources = createGenerateAotTestSourcesTask(project, sourceSets);
        project.getTasks().named(aotTestSourceSet.getCompileJavaTaskName(), JavaCompile.class, (aotTestCompileJava) -> {
            aotTestCompileJava.source(generateAotTestSources.getGeneratedSourcesOutputDirectory());
        });
        project.getTasks().named(aotTestSourceSet.getProcessResourcesTaskName(), Copy.class, (aotTestProcessResources) -> {
            aotTestProcessResources.from(generateAotTestSources.getGeneratedResourcesOutputDirectory());
            aotTestProcessResources.setDuplicatesStrategy(DuplicatesStrategy.INCLUDE);
        });
        Jar generatedTestSourcesJar = project.getTasks().create(aotTestSourceSet.getJarTaskName(), Jar.class, jar -> {
            jar.from(aotTestSourceSet.getOutput());
            jar.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
            jar.getArchiveClassifier().convention("aot-test");
        });
        // Create the aotTest task to allow execution of both regular and aotTest
        createAotTestTask(project, sourceSets, generatedTestSourcesJar);
        project.getPlugins().withType(NativeImagePlugin.class, nativeImagePlugin -> {
            project.getTasks().named(NativeImagePlugin.NATIVE_COMPILE_TASK_NAME).configure(nativeCompile -> {
                nativeCompile.dependsOn(generatedSourcesJar);
            });
            graal.getBinaries().named(NativeImagePlugin.NATIVE_MAIN_EXTENSION).configure(options -> {
                Provider<RegularFile> generatedSources = generatedSourcesJar.getArchiveFile();
                options.classpath(generatedSources);
            });
            graal.getBinaries().named(NativeImagePlugin.NATIVE_TEST_EXTENSION).configure(options -> {
                Provider<RegularFile> generatedTestSources = generatedTestSourcesJar.getArchiveFile();
                options.classpath(generatedTestSources);
                options.runtimeArgs("-Dspring.test.context.default.CacheAwareContextLoaderDelegate=" + "org.springframework.aot.test.AotCacheAwareContextLoaderDelegate");
            });
        });
        // Ensure that Kotlin compilation depends on AOT source generation
        project.getPlugins().withId("org.jetbrains.kotlin.jvm", kotlinPlugin -> {
            project.getTasks().named("compileAotMainKotlin").configure(compileKotlin -> compileKotlin.dependsOn(generateAotSources));
        });
    });
}

Example 2 with GenerateAotSources

use of org.springframework.aot.gradle.tasks.GenerateAotSources in project spring-native by spring-projects-experimental.

the class SpringAotGradlePluginTest method pluginRegistersAotTask.

@Test
void pluginRegistersAotTask() {
    Project project = createTestProject();
    JavaPluginExtension java = project.getExtensions().findByType(JavaPluginExtension.class);
    SourceSet aotSourceSet = java.getSourceSets().findByName(SpringAotGradlePlugin.AOT_MAIN_SOURCE_SET_NAME);
    TaskProvider<GenerateAotSources> generateAotSourcesProvider = project.getTasks().withType(GenerateAotSources.class).named(SpringAotGradlePlugin.GENERATE_MAIN_TASK_NAME);
    assertThat(generateAotSourcesProvider.isPresent()).isTrue();
    TaskProvider<Task> compileAotProvider = project.getTasks().named(aotSourceSet.getCompileJavaTaskName());
    assertThat(compileAotProvider.isPresent()).isTrue();
}

Example 3 with GenerateAotSources

use of org.springframework.aot.gradle.tasks.GenerateAotSources in project spring-native by spring-projects-experimental.

the class SpringAotGradlePlugin method createGenerateAotSourcesTask.

private GenerateAotSources createGenerateAotSourcesTask(Project project, SourceSetContainer sourceSets) {
    SourceSet mainSourceSet = sourceSets.findByName(SourceSet.MAIN_SOURCE_SET_NAME);
    SourceSet aotSourceSet = sourceSets.findByName(AOT_MAIN_SOURCE_SET_NAME);
    GenerateAotSources generate = project.getTasks().create(GENERATE_MAIN_TASK_NAME, GenerateAotSources.class);
    generate.setMainSourceSetOutputDirectories(mainSourceSet.getOutput());
    generate.setClasspath(createAotGenerationConfiguration(project).plus(aotSourceSet.getCompileClasspath()));
    generate.setResourceInputDirectories(mainSourceSet.getResources());
    generate.getSourcesOutputDirectory().set(aotSourceSet.getJava().getSourceDirectories().getSingleFile());
    generate.getResourcesOutputDirectory().set(aotSourceSet.getResources().getSourceDirectories().getSingleFile());
    generate.setDebug(isDebug());
    generate.getDebugOptions().getPort().set(getDebugPort());
    generate.setGroup(BasePlugin.BUILD_GROUP);
    configureToolchainConvention(project, generate);
    return generate;
}