Examples with GraalVMExtension org.graalvm.buildtools.gradle.dsl.GraalVMExtension used on opensource projects

Example 1 with GraalVMExtension

use of org.graalvm.buildtools.gradle.dsl.GraalVMExtension 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 GraalVMExtension

use of org.graalvm.buildtools.gradle.dsl.GraalVMExtension in project micronaut-gradle-plugin by micronaut-projects.

the class MicronautGraalPlugin method apply.

@Override
public void apply(Project project) {
    project.getPluginManager().apply(NativeImagePlugin.class);
    workaroundForResourcesDirectoryMissing(project);
    project.getPluginManager().withPlugin("io.micronaut.minimal.library", plugin -> {
        MicronautExtension extension = project.getExtensions().findByType(MicronautExtension.class);
        configureAnnotationProcessing(project, extension);
    });
    project.getPluginManager().withPlugin("io.micronaut.minimal.application", plugin -> {
        MicronautExtension extension = project.getExtensions().findByType(MicronautExtension.class);
        configureAnnotationProcessing(project, extension);
    });
    GraalVMExtension graal = project.getExtensions().findByType(GraalVMExtension.class);
    graal.getBinaries().configureEach(options -> options.resources(rsrc -> rsrc.autodetection(inf -> {
        inf.getEnabled().convention(true);
        inf.getIgnoreExistingResourcesConfigFile().convention(true);
        inf.getRestrictToProjectDependencies().convention(true);
    })));
    project.getPluginManager().withPlugin("application", plugin -> {
        TaskContainer tasks = project.getTasks();
        tasks.withType(BuildNativeImageTask.class).named("nativeCompile", nativeImageTask -> {
            MicronautRuntime mr = PluginsHelper.resolveRuntime(project);
            if (mr.isLambdaProvided()) {
                DependencySet implementation = project.getConfigurations().getByName("implementation").getDependencies();
                boolean isAwsApp = implementation.stream().noneMatch(dependency -> Objects.equals(dependency.getGroup(), "io.micronaut.aws") && dependency.getName().equals("micronaut-function-aws"));
                if (isAwsApp) {
                    nativeImageTask.getOptions().get().getMainClass().set("io.micronaut.function.aws.runtime.MicronautLambdaRuntime");
                }
            }
        });
        // We use `afterEvaluate` here in order to preserve laziness of task configuration
        // and because there is no API to allow reacting to registration of tasks.
        Set<String> alreadyRegisteredTaskNames = new HashSet<>();
        project.afterEvaluate(p -> tasks.withType(Test.class).getCollectionSchema().getElements().forEach(element -> {
            String testName = element.getName();
            registerTestAgainstNativeImageTask(alreadyRegisteredTaskNames, tasks, testName);
        }));
    });
}

Example 3 with GraalVMExtension

use of org.graalvm.buildtools.gradle.dsl.GraalVMExtension in project native-build-tools by graalvm.

the class NativeImagePlugin method configureJvmReachabilityConfigurationDirectories.

private void configureJvmReachabilityConfigurationDirectories(Project project, GraalVMExtension graalExtension, NativeImageOptions options, SourceSet sourceSet) {
    JvmReachabilityMetadataRepositoryExtension repositoryExtension = reachabilityExtensionOn(graalExtension);
    Provider<JvmReachabilityMetadataService> serviceProvider = project.getGradle().getSharedServices().registerIfAbsent("nativeConfigurationService", JvmReachabilityMetadataService.class, spec -> {
        LogLevel logLevel = determineLogLevel();
        spec.getParameters().getLogLevel().set(logLevel);
        spec.getParameters().getUri().set(repositoryExtension.getUri());
        spec.getParameters().getCacheDir().set(new File(project.getGradle().getGradleUserHomeDir(), "native-build-tools/repositories"));
    });
    options.getConfigurationFileDirectories().from(repositoryExtension.getEnabled().flatMap(enabled -> {
        if (enabled) {
            if (repositoryExtension.getUri().isPresent()) {
                Configuration classpath = project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName());
                Set<String> excludedModules = repositoryExtension.getExcludedModules().getOrElse(Collections.emptySet());
                Map<String, String> forcedVersions = repositoryExtension.getModuleToConfigVersion().getOrElse(Collections.emptyMap());
                return serviceProvider.map(repo -> repo.findConfigurationDirectoriesFor(query -> classpath.getIncoming().getResolutionResult().allComponents(component -> {
                    ModuleVersionIdentifier moduleVersion = component.getModuleVersion();
                    String module = moduleVersion.getGroup() + ":" + moduleVersion.getName();
                    if (!excludedModules.contains(module)) {
                        query.forArtifact(artifact -> {
                            artifact.gav(module + ":" + moduleVersion.getVersion());
                            if (forcedVersions.containsKey(module)) {
                                artifact.forceConfigVersion(forcedVersions.get(module));
                            }
                        });
                    }
                    query.useLatestConfigWhenVersionIsUntested();
                })).stream().map(Path::toAbsolutePath).map(Path::toFile).collect(Collectors.toList()));
            }
        }
        return project.getProviders().provider(Collections::emptySet);
    }));
}

Example 4 with GraalVMExtension

use of org.graalvm.buildtools.gradle.dsl.GraalVMExtension in project spring-boot by spring-projects.

the class NativeImagePluginAction method execute.

@Override
public void execute(Project project) {
    project.getPlugins().apply(SpringBootAotPlugin.class);
    project.getPlugins().withType(JavaPlugin.class).all((plugin) -> {
        JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
        SourceSetContainer sourceSets = javaPluginExtension.getSourceSets();
        SourceSet aotSourceSet = sourceSets.getByName(SpringBootAotPlugin.AOT_SOURCE_SET_NAME);
        project.getTasks().named(NativeImagePlugin.NATIVE_COMPILE_TASK_NAME, BuildNativeImageTask.class, (nativeCompile) -> nativeCompile.getOptions().get().classpath(aotSourceSet.getOutput()));
    });
    GraalVMExtension graalVmExtension = project.getExtensions().getByType(GraalVMExtension.class);
    graalVmExtension.getToolchainDetection().set(false);
}

Example 5 with GraalVMExtension

use of org.graalvm.buildtools.gradle.dsl.GraalVMExtension in project micronaut-gradle-plugin by micronaut-projects.

the class MicronautAotPlugin method registerOptimizedBinary.

private void registerOptimizedBinary(Project project, TaskProvider<MicronautAotOptimizerTask> prepareNative) {
    GraalVMExtension graalVMExtension = project.getExtensions().getByType(GraalVMExtension.class);
    NamedDomainObjectContainer<NativeImageOptions> binaries = graalVMExtension.getBinaries();
    binaries.create(OPTIMIZED_BINARY_NAME, binary -> {
        NativeImageOptions main = binaries.getByName(MAIN_BINARY_NAME);
        binary.getMainClass().set(main.getMainClass());
        binary.getClasspath().from(main.getClasspath());
        binary.getClasspath().from(prepareNative.map(MicronautAotOptimizerTask::getGeneratedClassesDirectory));
        project.getPlugins().withId("java-library", p -> binary.getSharedLibrary().convention(true));
    });
}