add jpackage task to jlink plugin

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JDepsTask.java

@@ -1,5 +1,6 @@
 package org.xbib.gradle.plugin.jlink;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -48,9 +49,9 @@ public class JDepsTask extends AbstractExecTask<JDepsTask> {
     @Inject
     public JDepsTask() {
         super(JDepsTask.class);
-        javaCompiler = getProject().getObjects().property(JavaCompiler.class);
         JavaToolchainSpec toolchain = getProject().getExtensions().getByType(JavaPluginExtension.class).getToolchain();
         JavaToolchainService service = getProject().getExtensions().getByType(JavaToolchainService.class);
+        javaCompiler = getProject().getObjects().property(JavaCompiler.class);
         javaCompiler.convention(service.compilerFor(toolchain));
         Provider<Directory> modulePathProvider = javaCompiler.map(it -> {
             Directory jmods = it.getMetadata().getInstallationPath().dir("jmods");
@@ -87,9 +88,9 @@ public class JDepsTask extends AbstractExecTask<JDepsTask> {
         args.add("--module-path");
         args.add(modulePath.get().getAsFile().getAbsolutePath());
         args.add("--module-path");
-        args.add(String.join(";", jarFiles)); // jdeps does not understand jmod files
+        args.add(String.join(File.pathSeparator, jarFiles)); // jdeps does not understand jmod files
         args.add("--class-path");
-        args.add(String.join(";", jarFiles));
+        args.add(String.join(File.pathSeparator, jarFiles));
         if (printModuleDeps.get()) {
             args.add("--print-module-deps");
         }
@@ -99,6 +100,9 @@ public class JDepsTask extends AbstractExecTask<JDepsTask> {
         if (verbose.get()) {
             args.add("-v"); // verbose, list deps for each class
         }
+        args.add("--multi-release");
+        String version = javaCompiler.get().getMetadata().getLanguageVersion().toString();
+        args.add(version);
         args.add(jarTask.get().getArchiveFile().get().getAsFile().getAbsolutePath());
         setArgs(args);
         getLogger().log(LogLevel.INFO, "executing " + getExecutable() + " with " + args);

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JLinkExtension.java

@@ -15,7 +15,7 @@ public class JLinkExtension {
 
     private final DirectoryProperty modulePath;
 
-    private final DirectoryProperty outputDirectory;
+    private final DirectoryProperty jLinkOutputDirectory;
 
     private final ListProperty<String> addModules;
 
@@ -29,6 +29,8 @@ public class JLinkExtension {
 
     private final Property<Boolean> stripDebug;
 
+    private final Property<Boolean> stripNativeCommands;
+
     private final Property<Boolean> noHeaderFiles;
 
     private final Property<Boolean> noManPages;
@@ -48,13 +50,14 @@ public class JLinkExtension {
     public JLinkExtension(Project project) {
         javaCompiler = project.getObjects().property(JavaCompiler.class);
         modulePath = project.getObjects().directoryProperty();
-        outputDirectory = project.getObjects().directoryProperty();
+        jLinkOutputDirectory = project.getObjects().directoryProperty();
         addModules = project.getObjects().listProperty(String.class);
         limitModules = project.getObjects().listProperty(String.class);
         bindServices = project.getObjects().property(Boolean.class);
         launcher = project.getObjects().property(String.class);
         compress = project.getObjects().property(Integer.class);
         stripDebug = project.getObjects().property(Boolean.class);
+        stripNativeCommands  = project.getObjects().property(Boolean.class);
         noHeaderFiles = project.getObjects().property(Boolean.class);
         noManPages = project.getObjects().property(Boolean.class);
         endian = project.getObjects().property(Endian.class);
@@ -78,12 +81,12 @@ public class JLinkExtension {
         return modulePath;
     }
 
-    public void setOutputDirectory(Directory outputDirectory) {
+    public void setjLinkOutputDirectory(Directory jLinkOutputDirectory) {
-        this.outputDirectory.set(outputDirectory);
+        this.jLinkOutputDirectory.set(jLinkOutputDirectory);
     }
 
-    public DirectoryProperty getOutputDirectory() {
+    public DirectoryProperty getjLinkOutputDirectory() {
-        return outputDirectory;
+        return jLinkOutputDirectory;
     }
 
     public void setAddModules(List<String> addModules) {
@@ -134,6 +137,14 @@ public class JLinkExtension {
         return stripDebug;
     }
 
+    public void setStripNativeCommands(Boolean stripNativeCommands) {
+        this.stripNativeCommands.set(stripNativeCommands);
+    }
+
+    public Property<Boolean> getStripNativeCommands() {
+        return stripNativeCommands;
+    }
+
     public void setNoHeaderFiles(Boolean noHeaderFiles) {
         this.noHeaderFiles.set(noHeaderFiles);
     }

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JLinkPlugin.java

@@ -29,11 +29,11 @@ public abstract class JLinkPlugin implements Plugin<Project> {
             throw new GradleException("this plugin is only available for Linux");
         }
         project.getPluginManager().apply(JavaLibraryPlugin.class);
-        JLinkExtension extension = project.getExtensions().create("jlink", JLinkExtension.class);
         JavaToolchainSpec toolchain = project.getExtensions().getByType(JavaPluginExtension.class).getToolchain();
         JavaToolchainService service = project.getExtensions().getByType(JavaToolchainService.class);
-        extension.getJavaCompiler().convention(service.compilerFor(toolchain));
+        JLinkExtension jLinkExtension = project.getExtensions().create("jlink", JLinkExtension.class);
-        Provider<Directory> modulePathProvider = extension.getJavaCompiler().map(it -> {
+        jLinkExtension.getJavaCompiler().convention(service.compilerFor(toolchain));
+        Provider<Directory> modulePathProvider = jLinkExtension.getJavaCompiler().map(it -> {
             Directory jmods = it.getMetadata().getInstallationPath().dir("jmods");
             if (jmods.getAsFile().exists()) {
                 project.getLogger().log(LogLevel.INFO, "using jmods directory found in installation for module path");
@@ -43,59 +43,98 @@ public abstract class JLinkPlugin implements Plugin<Project> {
                 return null;
             }
         });
-        extension.getModulePath().convention(modulePathProvider);
+        jLinkExtension.getModulePath().convention(modulePathProvider);
-        extension.getOutputDirectory().convention(project.getLayout().getBuildDirectory().dir("jlink"));
+        jLinkExtension.getjLinkOutputDirectory().convention(project.getLayout().getBuildDirectory().dir("jlink"));
-        extension.getAddModules().convention(List.of("java.base"));
+        jLinkExtension.getAddModules().convention(List.of("java.base"));
-        extension.getLimitModules().convention(List.of());
+        jLinkExtension.getLimitModules().convention(List.of());
-        extension.getBindServices().convention(false);
+        jLinkExtension.getBindServices().convention(false);
-        extension.getLauncher().unsetConvention();
+        jLinkExtension.getLauncher().unsetConvention();
-        extension.getCompress().convention(6); // zip-6, default
+        jLinkExtension.getCompress().convention(6); // zip-6, default
-        extension.getStripDebug().convention(false);
+        jLinkExtension.getStripDebug().convention(true); // same as jpackage default
-        extension.getNoHeaderFiles().convention(true);
+        jLinkExtension.getStripNativeCommands().convention(false);
-        extension.getNoManPages().convention(true);
+        jLinkExtension.getNoHeaderFiles().convention(true); // same as jpackage default
-        extension.getEndian().convention(JLinkExtension.Endian.NATIVE);
+        jLinkExtension.getNoManPages().convention(true); // same as jpackage default
-        extension.getIncludeLocales().unsetConvention();
+        jLinkExtension.getEndian().convention(JLinkExtension.Endian.NATIVE);
-        extension.getModuleVersion().convention(project.getVersion().toString());
+        jLinkExtension.getIncludeLocales().unsetConvention();
+        jLinkExtension.getModuleVersion().convention(project.getVersion().toString());
+
+        JPackageExtension jPackageExtension = project.getExtensions().create("jpackage", JPackageExtension.class);
+        jPackageExtension.getJavaCompiler().convention(service.compilerFor(toolchain));
+        jPackageExtension.getModulePath().convention(modulePathProvider);
+        jPackageExtension.getjPackageOutputDirectory().convention(project.getLayout().getBuildDirectory().dir("jpackage"));
+        jPackageExtension.getAddModules().convention(List.of("java.base"));
+        jPackageExtension.getModule().unsetConvention();
+        jPackageExtension.getInput().convention(project.getLayout().getBuildDirectory().dir("jlink"));
+        jPackageExtension.getType().convention("rpm"); // Fedora/Red Hat Linux
+        jPackageExtension.getAppName().convention(project.getName());
+        jPackageExtension.getAppVersion().convention(project.getVersion().toString());
+
         // get the jar task
         TaskProvider<Jar> jarTask = project.getTasks().named("jar", Jar.class);
         Objects.requireNonNull(jarTask, "jar task required to be present");
         TaskProvider<JModTask> jModTask = project.getTasks().register("jmod", JModTask.class);
         project.getTasks().withType(JModTask.class).forEach(it -> {
+            it.setGroup("build");
             it.dependsOn(jarTask);
-            it.javaCompiler.set(extension.getJavaCompiler());
+            it.javaCompiler.set(jLinkExtension.getJavaCompiler());
-            it.moduleVersion.set(extension.getModuleVersion());
+            it.moduleVersion.set(jLinkExtension.getModuleVersion());
         });
         // install the jdeps task
         TaskProvider<JDepsTask> jDepsTask = project.getTasks().register("jdeps", JDepsTask.class);
         project.getTasks().withType(JDepsTask.class).forEach(it -> {
+            it.setGroup("build");
             it.dependsOn(jModTask);
-            it.modulePath.set(extension.getModulePath());
+            it.javaCompiler.set(jLinkExtension.getJavaCompiler());
+            it.modulePath.set(jLinkExtension.getModulePath());
         });
         Objects.requireNonNull(jModTask, "jmod task required to be present");
-        // depend jlink on jdeps and jmod task
+        // depend jlink on jdeps task
         TaskProvider<JLinkTask> jLinkTask = project.getTasks().register("jlink", JLinkTask.class);
-        Objects.requireNonNull(jLinkTask, "jlink task required to be present");
         project.getTasks().withType(JLinkTask.class).forEach(it -> {
+            it.setGroup("build");
             it.dependsOn(jDepsTask);
-            it.javaCompiler.set(extension.getJavaCompiler());
+            it.javaCompiler.set(jLinkExtension.getJavaCompiler());
-            it.modulePath.set(extension.getModulePath());
+            it.modulePath.set(jLinkExtension.getModulePath());
-            it.outputDirectory.set(extension.getOutputDirectory());
+            it.jLinkOutputDirectory.set(jLinkExtension.getjLinkOutputDirectory());
-            it.addModules.set(extension.getAddModules());
+            it.addModules.set(jLinkExtension.getAddModules());
-            it.limitModules.set(extension.getLimitModules());
+            it.limitModules.set(jLinkExtension.getLimitModules());
-            it.bindServices.set(extension.getBindServices());
+            it.bindServices.set(jLinkExtension.getBindServices());
-            it.launcher.set(extension.getLauncher());
+            it.launcher.set(jLinkExtension.getLauncher());
-            it.compress.set(extension.getCompress());
+            it.compress.set(jLinkExtension.getCompress());
-            it.stripDebug.set(extension.getStripDebug());
+            it.stripDebug.set(jLinkExtension.getStripDebug());
-            it.noHeaderFiles.set(extension.getNoHeaderFiles());
+            it.stripNativeCommands.set(jLinkExtension.getStripNativeCommands());
-            it.noManPages.set(extension.getNoManPages());
+            it.noHeaderFiles.set(jLinkExtension.getNoHeaderFiles());
-            it.endian.set(extension.getEndian());
+            it.noManPages.set(jLinkExtension.getNoManPages());
+            it.endian.set(jLinkExtension.getEndian());
         });
-        Configuration configuration = project.getConfigurations().create("jlink");
+        // depend jpackage on jlink task
-        configuration.setCanBeConsumed(true);
+        TaskProvider<JPackageTask> jPackageTask = project.getTasks().register("jpackage", JPackageTask.class);
-        configuration.setCanBeResolved(false);
+        project.getTasks().withType(JPackageTask.class).forEach(it -> {
-        configuration.setVisible(false);
+            it.setGroup("build");
-        configuration.attributes(a -> a.attribute(Usage.USAGE_ATTRIBUTE,
+            it.dependsOn(jLinkTask);
+            it.javaCompiler.set(jPackageExtension.getJavaCompiler());
+            it.modulePath.set(jPackageExtension.getModulePath());
+            it.jPackageOutputDirectory.set(jPackageExtension.getjPackageOutputDirectory());
+            it.addModules.set(jPackageExtension.getAddModules());
+            it.module.set(jPackageExtension.getModule());
+            it.input.set(jPackageExtension.getInput());
+            it.type.set(jPackageExtension.getType());
+            it.appName.set(jPackageExtension.getAppName());
+            it.appVersion.set(jPackageExtension.getAppVersion());
+        });
+        Configuration jLinkConfiguration = project.getConfigurations().create("jlink");
+        jLinkConfiguration.setCanBeConsumed(true);
+        jLinkConfiguration.setCanBeResolved(false);
+        jLinkConfiguration.setVisible(false);
+        jLinkConfiguration.attributes(a -> a.attribute(Usage.USAGE_ATTRIBUTE,
                 project.getObjects().named(Usage.class, "jlink")));
-        configuration.outgoing(o -> o.artifact(jLinkTask.flatMap(t -> t.outputDirectory)));
+        jLinkConfiguration.outgoing(o -> o.artifact(jLinkTask.flatMap(t -> t.jLinkOutputDirectory)));
+        Configuration jPackageConfiguration = project.getConfigurations().create("jpackage");
+        jPackageConfiguration.setCanBeConsumed(true);
+        jPackageConfiguration.setCanBeResolved(false);
+        jPackageConfiguration.setVisible(false);
+        jPackageConfiguration.attributes(a -> a.attribute(Usage.USAGE_ATTRIBUTE,
+                project.getObjects().named(Usage.class, "jpackage")));
+        jPackageConfiguration.outgoing(o -> o.artifact(jPackageTask.flatMap(t -> t.jPackageOutputDirectory)));
     }
 }

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JLinkTask.java

@@ -36,7 +36,7 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
     DirectoryProperty modulePath;
 
     @OutputDirectory
-    DirectoryProperty outputDirectory;
+    DirectoryProperty jLinkOutputDirectory;
 
     @Input
     ListProperty<String> addModules;
@@ -57,6 +57,10 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
     @Optional
     Property<Integer> compress;
 
+    @Input
+    @Optional
+    Property<Boolean> stripNativeCommands;
+
     @Input
     @Optional
     Property<Boolean> stripDebug;
@@ -82,13 +86,14 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
         super(JLinkTask.class);
         javaCompiler = getProject().getObjects().property(JavaCompiler.class);
         modulePath = getProject().getObjects().directoryProperty();
-        outputDirectory = getProject().getObjects().directoryProperty();
+        jLinkOutputDirectory = getProject().getObjects().directoryProperty();
         addModules = getProject().getObjects().listProperty(String.class);
         limitModules = getProject().getObjects().listProperty(String.class);
         bindServices = getProject().getObjects().property(Boolean.class);
         launcher = getProject().getObjects().property(String.class);
         compress = getProject().getObjects().property(Integer.class);
         stripDebug = getProject().getObjects().property(Boolean.class);
+        stripNativeCommands = getProject().getObjects().property(Boolean.class);
         noHeaderFiles = getProject().getObjects().property(Boolean.class);
         noManPages = getProject().getObjects().property(Boolean.class);
         endian = getProject().getObjects().property(JLinkExtension.Endian.class);
@@ -98,7 +103,7 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
     @Override
     public void exec() {
         setExecutable(javaCompiler.get().getMetadata().getInstallationPath().file("bin/jlink"));
-        File jlinkOutput = outputDirectory.get().getAsFile();
+        File jlinkOutput = jLinkOutputDirectory.get().getAsFile();
         try {
             createDirectory(jlinkOutput.toPath());
         } catch (IOException e) {
@@ -122,10 +127,12 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
         }
         if (stripDebug.get()) {
             args.add("--strip-debug");
-            //args.add("--strip-native-debug-symbols=keep-debuginfo-files");
             args.add("--strip-native-debug-symbols=exclude-debuginfo-files");
             args.add("--strip-java-debug-attributes");
         }
+        if (stripNativeCommands.get()) {
+            args.add("--strip-native-commands");
+        }
         if (noHeaderFiles.get()) {
             args.add("--no-header-files");
         }
@@ -169,12 +176,12 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
         return modulePath;
     }
 
-    public void setOutputDirectory(Directory outputDirectory) {
+    public void setjLinkOutputDirectory(Directory jLinkOutputDirectory) {
-        this.outputDirectory.set(outputDirectory);
+        this.jLinkOutputDirectory.set(jLinkOutputDirectory);
     }
 
-    public DirectoryProperty getOutputDirectory() {
+    public DirectoryProperty getjLinkOutputDirectory() {
-        return outputDirectory;
+        return jLinkOutputDirectory;
     }
 
     public void setAddModules(List<String> addModules) {
@@ -225,6 +232,14 @@ public class JLinkTask extends AbstractExecTask<JLinkTask> {
         return stripDebug;
     }
 
+    public void setStripNativeCommands(Boolean stripNativeCommands) {
+        this.stripNativeCommands.set(stripNativeCommands);
+    }
+
+    public Property<Boolean> getStripNativeCommands() {
+        return stripNativeCommands;
+    }
+
     public void setNoHeaderFiles(Boolean noHeaderFiles) {
         this.noHeaderFiles.set(noHeaderFiles);
     }

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JPackageExtension.java

@@ -0,0 +1,114 @@
+package org.xbib.gradle.plugin.jlink;
+
+import java.util.List;
+import org.gradle.api.Project;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.jvm.toolchain.JavaCompiler;
+
+public class JPackageExtension {
+
+    private final Property<JavaCompiler> javaCompiler;
+
+    private final DirectoryProperty modulePath;
+
+    private final DirectoryProperty jPackageOutputDirectory;
+
+    private final ListProperty<String> addModules;
+
+    private final Property<String> module;
+
+    private final DirectoryProperty input;
+
+    private final Property<String> type;
+
+    private final Property<String> appName;
+
+    private final Property<String> appVersion;
+
+    public JPackageExtension(Project project) {
+        javaCompiler = project.getObjects().property(JavaCompiler.class);
+        modulePath = project.getObjects().directoryProperty();
+        jPackageOutputDirectory = project.getObjects().directoryProperty();
+        addModules = project.getObjects().listProperty(String.class);
+        module = project.getObjects().property(String.class);
+        input = project.getObjects().directoryProperty();
+        type = project.getObjects().property(String.class);
+        appName = project.getObjects().property(String.class);
+        appVersion = project.getObjects().property(String.class);
+    }
+
+    public void setJavaCompiler(JavaCompiler javaCompiler) {
+        this.javaCompiler.set(javaCompiler);
+    }
+
+    public Property<JavaCompiler> getJavaCompiler() {
+        return javaCompiler;
+    }
+
+    public void setModulePath(Directory modulePath) {
+        this.modulePath.set(modulePath);
+    }
+
+    public DirectoryProperty getModulePath() {
+        return modulePath;
+    }
+
+    public void setjPackageOutputDirectory(Directory jPackageOutputDirectory) {
+        this.jPackageOutputDirectory.set(jPackageOutputDirectory);
+    }
+
+    public DirectoryProperty getjPackageOutputDirectory() {
+        return jPackageOutputDirectory;
+    }
+
+    public void setAddModules(List<String> addModules) {
+        this.addModules.set(addModules);
+    }
+
+    public ListProperty<String> getAddModules() {
+        return addModules;
+    }
+
+    public void setModule(String module) {
+        this.module.set(module);
+    }
+
+    public Property<String> getModule() {
+        return module;
+    }
+
+    public void setInput(Directory input) {
+        this.input.set(input);
+    }
+
+    public DirectoryProperty getInput() {
+        return input;
+    }
+
+    public void setType(String type) {
+        this.type.set(type);
+    }
+
+    public Property<String> getType() {
+        return type;
+    }
+
+    public void setAppName(String appName) {
+        this.appName.set(appName);
+    }
+
+    public Property<String> getAppName() {
+        return appName;
+    }
+
+    public void setAppVersion(String appVersion) {
+        this.appVersion.set(appVersion);
+    }
+
+    public Property<String> getAppVersion() {
+        return appVersion;
+    }
+}

gradle-plugin-jlink/src/main/java/org/xbib/gradle/plugin/jlink/JPackageTask.java

@@ -0,0 +1,279 @@
+package org.xbib.gradle.plugin.jlink;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import javax.inject.Inject;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.logging.LogLevel;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.AbstractExecTask;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputDirectory;
+import org.gradle.api.tasks.Nested;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.jvm.toolchain.JavaCompiler;
+
+public class JPackageTask extends AbstractExecTask<JPackageTask> {
+
+    @Nested
+    Property<JavaCompiler> javaCompiler;
+
+    @InputDirectory
+    @Optional
+    DirectoryProperty modulePath;
+
+    @OutputDirectory
+    DirectoryProperty jPackageOutputDirectory;
+
+    @Input
+    ListProperty<String> addModules;
+
+    @Input
+    Property<String> module;
+
+    @Input
+    @Optional
+    Property<String> appImage;
+
+    @InputDirectory
+    @Optional
+    DirectoryProperty input;
+
+    @Input
+    @Optional
+    Property<String> type;
+
+    @Input
+    @Optional
+    Property<String> appName;
+
+    @Input
+    @Optional
+    Property<String> appVersion;
+
+    @Input
+    @Optional
+    Property<String> copyright;
+
+    @Input
+    @Optional
+    Property<String> appDescription;
+
+    @Input
+    @Optional
+    Property<String> icon;
+
+    @Inject
+    public JPackageTask() {
+        super(JPackageTask.class);
+        javaCompiler = getProject().getObjects().property(JavaCompiler.class);
+        modulePath = getProject().getObjects().directoryProperty();
+        modulePath = getProject().getObjects().directoryProperty();
+        jPackageOutputDirectory = getProject().getObjects().directoryProperty();
+        addModules = getProject().getObjects().listProperty(String.class);
+        module = getProject().getObjects().property(String.class);
+        appImage = getProject().getObjects().property(String.class);
+        input = getProject().getObjects().directoryProperty();
+        type = getProject().getObjects().property(String.class);
+        appName = getProject().getObjects().property(String.class);
+        appVersion = getProject().getObjects().property(String.class);
+        copyright = getProject().getObjects().property(String.class);
+        appDescription = getProject().getObjects().property(String.class);
+        icon = getProject().getObjects().property(String.class);
+    }
+
+    @Override
+    protected void exec() {
+        setExecutable(javaCompiler.get().getMetadata().getInstallationPath().file("bin/jpackage"));
+        File jPackageOutput = jPackageOutputDirectory.get().getAsFile();
+        try {
+            createDirectory(jPackageOutput.toPath());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        List<String> args = new ArrayList<>();
+        args.add("--module-path");
+        args.add(modulePath.get().getAsFile().getAbsolutePath());
+        args.add("--module-path");
+        TaskProvider<JModTask> jmodTask = getProject().getTasks().named("jmod", JModTask.class);
+        Objects.requireNonNull(jmodTask, "jmod task must be present");
+        args.add(jmodTask.get().jModDirectory.getAsFile().get().getAbsolutePath());
+        args.add("--dest");
+        args.add(jPackageOutput.getAbsolutePath());
+        args.add("--add-modules");
+        args.add(String.join(",", addModules.get()));
+        args.add("--module");
+        args.add(module.get());
+        if (input.isPresent()) {
+            args.add("--input");
+            args.add(input.getAsFile().get().getAbsolutePath());
+        }
+        if (appImage.isPresent()) {
+            args.add("--app-image");
+            args.add(appImage.get());
+        }
+        args.add("--type");
+        args.add(type.get());
+        if (appName.isPresent()) {
+            args.add("--name");
+            args.add(appName.get());
+        }
+        if (appVersion.isPresent()) {
+            args.add("--app-version");
+            args.add(appVersion.get());
+        }
+        if (copyright.isPresent()) {
+            args.add("--copyright");
+            args.add(copyright.get());
+        }
+        if (appDescription.isPresent()) {
+            args.add("--description");
+            args.add(appDescription.get());
+        }
+        if (icon.isPresent()) {
+            args.add("--icon");
+            args.add(icon.get());
+        }
+        setArgs(args);
+        System.err.println("executing " + getExecutable() + " with " + args);
+        getLogger().log(LogLevel.INFO, "executing " + getExecutable() + " with " + args);
+        super.exec();
+    }
+
+    public void setJavaCompiler(JavaCompiler javaCompiler) {
+        this.javaCompiler.set(javaCompiler);
+    }
+
+    public Property<JavaCompiler> getJavaCompiler() {
+        return javaCompiler;
+    }
+
+    public void setModulePath(Directory modulePath) {
+        this.modulePath.set(modulePath);
+    }
+
+    public DirectoryProperty getModulePath() {
+        return modulePath;
+    }
+
+    public void setjPackageOutputDirectory(Directory jPackageOutputDirectory) {
+        this.jPackageOutputDirectory.set(jPackageOutputDirectory);
+    }
+
+    public DirectoryProperty getjPackageOutputDirectory() {
+        return jPackageOutputDirectory;
+    }
+
+    public void setAddModules(List<String> addModules) {
+        this.addModules.set(addModules);
+    }
+
+    public ListProperty<String> getAddModules() {
+        return addModules;
+    }
+
+    public void setModule(String module) {
+        this.module.set(module);
+    }
+
+    public Property<String> getModule() {
+        return module;
+    }
+
+    public void setAppImage(String appImage) {
+        this.appImage .set(appImage);
+    }
+
+    public Property<String> getAppImage() {
+        return appImage;
+    }
+
+    /*public void setInput(DirectoryProperty input) {
+        this.input = input;
+    }*/
+
+    public DirectoryProperty getInput() {
+        return input;
+    }
+
+    public void setType(String type) {
+        this.type.set(type);
+    }
+
+    public Property<String> getType() {
+        return type;
+    }
+
+    public void setAppName(String appName) {
+        this.appName.set(appName);
+    }
+
+    public Property<String> getAppName() {
+        return appName;
+    }
+
+    public void setAppVersion(String appVersion) {
+        this.appVersion.set(appVersion);
+    }
+
+    public Property<String> getAppVersion() {
+        return appVersion;
+    }
+
+    public void setCopyright(String copyright) {
+        this.copyright.set(copyright);
+    }
+
+    public Property<String> getCopyright() {
+        return copyright;
+    }
+
+    public void setAppDescription(String appDescription) {
+        this.appDescription.set(appDescription);
+    }
+
+    public Property<String> getAppDescription() {
+        return appDescription;
+    }
+
+    public void setIcon(String icon) {
+        this.icon.set(icon);
+    }
+
+    public Property<String> getIcon() {
+        return icon;
+    }
+
+    private static void createDirectory(Path path) throws IOException {
+        if (Files.exists(path)) {
+            Files.walkFileTree(path, new SimpleFileVisitor<>() {
+                @Override
+                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+                    Files.delete(dir);
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                    Files.delete(file);
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+            Files.deleteIfExists(path);
+        }
+        // jpackage bails out if directory is created, so we create the parent
+        Files.createDirectories(path.getParent());
+    }
+}

gradle-plugin-jlink/src/test/groovy/org/xbib/gradle/plugin/jlink/JLinkGradleBuild.groovy

@@ -6,6 +6,7 @@ import org.gradle.testkit.runner.GradleRunner
 class JLinkGradleBuild {
 
     final File projectDir
+    final File propertiesFile
     final File settingsFile
     final File appBuildFile
     final File appModuleInfoFile
@@ -16,11 +17,16 @@ class JLinkGradleBuild {
 
     JLinkGradleBuild() {
         this.projectDir = createDirectory('build/jlink-gradle-build')
+        this.propertiesFile = tapFile("gradle.properties")
         this.settingsFile = tapFile('settings.gradle')
         this.appBuildFile = tapFile('app/build.gradle')
         this.appModuleInfoFile = tapFile('app/src/main/java/module-info.java')
         this.libBuildFile = tapFile('lib/build.gradle')
         this.libModuleInfoFile = tapFile('lib/src/main/java/module-info.java')
+        propertiesFile << '''
+            group = "org.example"
+            version = 1.0
+'''
         settingsFile << '''
             dependencyResolutionManagement { repositories.mavenCentral() }
             includeBuild(".")
@@ -31,7 +37,6 @@ class JLinkGradleBuild {
             plugins {
                 id "org.xbib.gradle.plugin.jlink"
             }
-            group = "org.example"           
         '''
         tapFile("app/src/main/java/org/example/app/Main.java") << '''
             package org.example.app;            
@@ -57,7 +62,6 @@ class JLinkGradleBuild {
             plugins {
                 id("org.xbib.gradle.plugin.jlink")
             }
-            group = "org.example"
         '''
     }
 

gradle-plugin-jlink/src/test/groovy/org/xbib/gradle/plugin/jlink/JLinkTest.groovy

@@ -11,7 +11,7 @@ class JLinkTest extends Specification {
     @Delegate
     JLinkGradleBuild build = new JLinkGradleBuild()
 
-    def "can use jlink plugin"() {
+    def "can use jlink plugin with jlink task"() {
         given:
         def taskToRun = ":app:jlink"
         appBuildFile << """

gradle-plugin-jlink/src/test/groovy/org/xbib/gradle/plugin/jlink/JPackageTest.groovy

@@ -0,0 +1,45 @@
+package org.xbib.gradle.plugin.jlink
+
+import spock.lang.Specification
+
+import static org.gradle.testkit.runner.TaskOutcome.FAILED
+import static org.gradle.testkit.runner.TaskOutcome.SUCCESS
+import static org.xbib.gradle.plugin.jlink.JLinkGradleBuild.runsOnLinux
+
+class JPackageTest extends Specification {
+
+    @Delegate
+    JLinkGradleBuild build = new JLinkGradleBuild()
+
+    def "can use jlink plugin with jpackage task"() {
+        given:
+        def taskToRun = ":app:jpackage"
+        appBuildFile << """
+            dependencies {
+              api "org.junit.jupiter:junit-jupiter-engine:5.10.2"
+            }
+            jpackage {
+              addModules.set(List.of("org.example.app"))
+              module.set("org.example.app/org.example.app.Main")
+              appName.set("helloworld")
+            }
+        """
+        appModuleInfoFile << """
+            module org.example.app {
+               exports org.example.app;
+            }
+        """
+
+        when:
+        def result = success ? build(taskToRun) : fail(taskToRun)
+
+        then:
+        println result.output
+        result.task(taskToRun).outcome == (success ? SUCCESS : FAILED)
+        success
+
+        where:
+        label    | os      | success
+        'fedora' | 'linux' | runsOnLinux()
+    }
+}