#537

Committed 25 Sep 2025 02:50PM UTC coverage: 48.299% (-0.7%) from 48.959%

Build # #537

Build Type

push

github

Committed by

web-flow

Commit Message

fix: check snapshot version for '-SNAPSHOT' tag

Fixe #1971

Coverage Stats

2 of 2 new or added lines in 1 file covered. (100.0%)

362 existing lines in 31 files now uncovered.

25821 of 53461 relevant lines covered (48.3%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.36

/core/jreleaser-engine/src/main/java/org/jreleaser/assemblers/JpackageAssemblerProcessor.java

/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * Copyright 2020-2025 The JReleaser authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jreleaser.assemblers;

import org.apache.commons.io.IOUtils;
import org.jreleaser.bundle.RB;
import org.jreleaser.model.Constants;
import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.assemble.JlinkAssembler;
import org.jreleaser.model.internal.assemble.JpackageAssembler;
import org.jreleaser.model.internal.common.Artifact;
import org.jreleaser.model.spi.assemble.AssemblerProcessingException;
import org.jreleaser.mustache.TemplateContext;
import org.jreleaser.sdk.command.Command;
import org.jreleaser.templates.TemplateResource;
import org.jreleaser.templates.TemplateUtils;
import org.jreleaser.util.FileUtils;
import org.jreleaser.util.PlatformUtils;
import org.jreleaser.version.SemanticVersion;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Optional;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
import static org.jreleaser.assemblers.AssemblerUtils.copyJars;
import static org.jreleaser.assemblers.AssemblerUtils.readJavaVersion;
import static org.jreleaser.mustache.Templates.resolveTemplate;
import static org.jreleaser.util.FileType.JAR;
import static org.jreleaser.util.FileUtils.listFilesAndProcess;
import static org.jreleaser.util.PlatformUtils.isWindows;
import static org.jreleaser.util.StringUtils.isBlank;
import static org.jreleaser.util.StringUtils.isNotBlank;

/**
 * @author Andres Almiray
 * @since 0.10.0
 */
public class JpackageAssemblerProcessor extends AbstractAssemblerProcessor<org.jreleaser.model.api.assemble.JpackageAssembler, JpackageAssembler> {
    private static final String FILES_DIRECTORY = "files";

    public JpackageAssemblerProcessor(JReleaserContext context) {
        super(context);
    }

    @Override
    protected void doAssemble(TemplateContext props) throws AssemblerProcessingException {
        JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();

        if (!packager.getJdk().isActiveAndSelected()) return;

        // verify jdk
        Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);
        SemanticVersion jdkVersion = SemanticVersion.of(readJavaVersion(jdkPath));
        context.getLogger().debug(RB.$("assembler.jpackage.jdk"), jdkVersion, jdkPath.toAbsolutePath().toString());
        if (jdkVersion.getMajor() < 16) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_minimum_jdk_required", jdkVersion.toString()));
        }

        String platform = packager.getJdk().getPlatform();
        String platformReplaced = assembler.getPlatform().applyReplacements(platform);

        Path assembleDirectory = props.get(Constants.KEY_DISTRIBUTION_ASSEMBLE_DIRECTORY);
        Path workDirectory = assembleDirectory.resolve(WORK_DIRECTORY + "-" + platformReplaced);
        Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);
        Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);

        // copy files to inputs
        copyTemplates(context, props, filesDirectory);
        copyArtifacts(context, filesDirectory, platform, true);
        copyFiles(context, filesDirectory);
        copyFileSets(context, filesDirectory);

        // copy jars to inputs
        context.getLogger().debug(RB.$("assembler.copy.jars"), context.relativizeToBasedir(filesDirectory));
        if (isBlank(assembler.getJava().getMainModule())) {
            if (isNotBlank(assembler.getJlink())) {
                JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());
                if (jlink.getJavaArchive().isSet()) {
                    String configuredPath = jlink.getJavaArchive().getPath();
                    String archiveFile = resolveTemplate(configuredPath, props);
                    Path archivePath = context.getBasedir().resolve(Paths.get(archiveFile));
                    if (!Files.exists(archivePath)) {
                        throw new AssemblerProcessingException(RB.$("ERROR_path_does_not_exist_2", configuredPath, archivePath));
                    }

                    Path archiveDirectory = inputsDirectory.resolve(ARCHIVE_DIRECTORY);
                    try {
                        FileUtils.unpackArchive(archivePath, archiveDirectory, true);
                    } catch (IOException e) {
                        throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
                    }

                    String libDirectoryName = resolveTemplate(jlink.getJavaArchive().getLibDirectoryName(), props);
                    Path libPath = inputsDirectory.resolve(ARCHIVE_DIRECTORY).resolve(libDirectoryName);
                    try {
                        FileUtils.copyFiles(context.getLogger(), libPath, filesDirectory);
                    } catch (IOException e) {
                        throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
                    }
                }
            }

            copyJars(context, assembler, filesDirectory, "");
            copyJars(context, assembler, filesDirectory, platform);
        }

        // copy icon to inputs
        copyIcon(context, assembler, packager, inputsDirectory, platform, props);

        // adjust runtime image
        if (isNotBlank(assembler.getJlink())) {
            adjustRuntimeImage(context, assembler, workDirectory, platform);
        }

        for (String type : packager.getTypes()) {
            context.getLogger().info("- " + RB.$("assembler.jpackage.type"), type);
            jpackage(context, type, workDirectory, props);
        }
    }

    private void copyIcon(JReleaserContext context, JpackageAssembler assembler,
                          JpackageAssembler.PlatformPackager packager, Path inputsDirectory,
                          String platform, TemplateContext props) throws AssemblerProcessingException {
        String p = "linux";
        String ext = ".png";

        if (isWindows(platform)) {
            p = "windows";
            ext = ".ico";
        } else if (PlatformUtils.isMac(platform)) {
            p = "osx";
            ext = ".icns";
        }

        String icon = resolveTemplate(packager.getIcon(), props);
        try {
            if (isNotBlank(icon) && Files.exists(context.getBasedir().resolve(icon)) && icon.endsWith(ext)) {
                Path iconPath = context.getBasedir().resolve(icon);
                Files.copy(iconPath, inputsDirectory.resolve(assembler.getName() + ext), REPLACE_EXISTING);
            } else {
                String iconResource = "META-INF/jreleaser/icons/" + p + "/duke" + ext;
                try (TemplateResource templateResource = TemplateUtils.resolveResource(context.getLogger(), iconResource)) {
                    writeFile(IOUtils.toByteArray(templateResource.getInputStream()), inputsDirectory.resolve(assembler.getName() + ext));
                }
            }
        } catch (Exception e) {
            throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
        }
    }

    @SuppressWarnings("UnnecessaryParentheses")
    private void adjustRuntimeImage(JReleaserContext context, JpackageAssembler assembler, Path workDirectory, String platform) throws AssemblerProcessingException {
        Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);
        if (!runtimeImageByPlatform.isPresent()) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));
        }

        Path originalImage = runtimeImageByPlatform.get().getEffectivePath(context, assembler);
        Path adjustedImage = workDirectory.resolve("runtime-image");

        try {
            if (!FileUtils.copyFilesRecursive(context.getLogger(), originalImage, adjustedImage, path -> {
                String fileName = path.getFileName().toString();
                boolean pathIsJar = fileName.endsWith(JAR.extension()) && path.getParent().getFileName().toString().equals(JARS_DIRECTORY);
                boolean pathIsExecutable = fileName.equals(context.getModel().getAssemble().findJlink(assembler.getJlink()).getExecutable());
                return pathIsJar || pathIsExecutable;
            })) {
                throw new IOException(RB.$("ERROR_assembler_adjusting_image", adjustedImage));
            }
        } catch (IOException e) {
            throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
        }

        runtimeImageByPlatform.get().setPath(adjustedImage.toAbsolutePath().toString());
    }

    private void jpackage(JReleaserContext context, String type, Path workDirectory, TemplateContext props) throws AssemblerProcessingException {
        JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();
        Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);
        String platform = packager.getJdk().getPlatform();
        String platformReplaced = assembler.getPlatform().applyReplacements(platform);

        Path assembleDirectory = workDirectory.getParent();
        Path packagerDirectory = workDirectory.resolve(type).toAbsolutePath();
        try {
            FileUtils.deleteFiles(packagerDirectory);
        } catch (IOException e) {
            throw new AssemblerProcessingException(RB.$("ERROR_assembler_delete_dir",
                context.relativizeToBasedir(packagerDirectory)), e);
        }

        Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);

        Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);
        if (!runtimeImageByPlatform.isPresent()) {
            throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));
        }

        String moduleName = assembler.getJava().getMainModule();
        String appName = packager.getResolvedAppName(context, assembler);
        String appVersion = assembler.getApplicationPackage().getResolvedAppVersion(context, assembler);
        String vendor = assembler.getApplicationPackage().getVendor();
        String copyright = assembler.getApplicationPackage().getCopyright();

        Path jpackageExecutable = jdkPath
            .resolve(BIN_DIRECTORY)
            .resolve(isWindows() ? "jpackage.exe" : "jpackage")
            .toAbsolutePath();

        Command cmd = new Command(jpackageExecutable.toAbsolutePath().toString(), true)
            .arg("--type")
            .arg(type)
            .arg("--dest")
            .arg(assembleDirectory.toAbsolutePath().toString())
            .arg("--input")
            .arg(inputsDirectory.resolve(FILES_DIRECTORY).toAbsolutePath().toString())
            .arg("--name")
            .arg(maybeQuote(appName))
            .arg("--runtime-image")
            .arg(maybeQuote(runtimeImageByPlatform.get().getEffectivePath(context, assembler).toAbsolutePath().toString()))
            .arg("--app-version")
            .arg(appVersion)
            .arg("--vendor")
            .arg(maybeQuote(vendor))
            .arg("--copyright")
            .arg(maybeQuote(copyright))
            .arg("--description")
            .arg(maybeQuote(context.getModel().getProject().getDescription()));

        if (assembler.isVerbose()) {
            cmd.arg("--verbose");
        }

        if (isNotBlank(moduleName)) {
            cmd.arg("--module")
                .arg(moduleName + "/" + assembler.getJava().getMainClass());
        } else {
            String mainJarPath = "";

            if (isNotBlank(assembler.getMainJar().getPath())) {
                mainJarPath = assembler.getMainJar().getResolvedPath().getFileName().toString();
            }

            if (isNotBlank(assembler.getJlink())) {
                JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());
                if (jlink.getJavaArchive().isSet()) {
                    String mainJarName = resolveTemplate(jlink.getJavaArchive().getMainJarName(), props);
                    Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);
                    mainJarPath = filesDirectory.resolve(mainJarName).getFileName().toString();
                }
            }

            cmd.arg("--main-class")
                .arg(assembler.getJava().getMainClass())
                .arg("--main-jar")
                .arg(maybeQuote(mainJarPath));
        }

        // Launcher
        for (String argument : assembler.getLauncher().getArguments()) {
            cmd.arg("--arguments")
                .arg(maybeQuote(argument));
        }
        for (String javaOption : assembler.getLauncher().getJavaOptions()) {
            cmd.arg("--java-options")
                .arg(maybeQuote(javaOption));
        }
        for (String launcher : assembler.getLauncher().getLaunchers()) {
            cmd.arg("--add-launcher")
                .arg(maybeQuote(launcher));
        }

        // ApplicationPackage
        String licenseFile = resolveTemplate(assembler.getApplicationPackage().getLicenseFile(), props);
        if (isNotBlank(licenseFile)) {
            Path licenseFilePath = context.getBasedir().resolve(licenseFile);
            if (Files.exists(licenseFilePath)) {
                cmd.arg("--license-file")
                    .arg(maybeQuote(licenseFilePath.toAbsolutePath().toString()));
            }
        }

        if (!assembler.getApplicationPackage().getFileAssociations().isEmpty()) {
            for (String filename : assembler.getApplicationPackage().getFileAssociations()) {
                Path path = context.getBasedir().resolve(resolveTemplate(filename, props));
                if (Files.exists(path)) {
                    cmd.arg("--file-associations")
                        .arg(maybeQuote(path.toAbsolutePath().toString()));
                }
            }
        }

        customize(type, packager, inputsDirectory, cmd, props);

        context.getLogger().debug(String.join(" ", cmd.getArgs()));
        Command.Result result = executeCommand(cmd);
        if (assembler.isVerbose()) {
            context.getLogger().debug(result.getOut());
        }

        // replace only if not linux
        if (!PlatformUtils.isLinux(platform) && assembler.isAttachPlatform()) {
            try {
                Optional<Path> artifact = listFilesAndProcess(assembleDirectory, files ->
                    files.filter(path -> path.getFileName().toString().endsWith(type))
                        .findFirst().orElse(null));

                if (artifact.isPresent()) {
                    String dest = artifact.get().getFileName().toString()
                        .replace("." + type, "-" + platformReplaced + "." + type);
                    Files.move(
                        assembleDirectory.resolve(artifact.get().getFileName()),
                        assembleDirectory.resolve(dest), REPLACE_EXISTING);
                }
            } catch (IOException e) {
                throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);
            }
        }
    }

    private void customize(String type, JpackageAssembler.PlatformPackager packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        String installDir = resolveTemplate(packager.getInstallDir(), props);
        if (isNotBlank(installDir)) {
            cmd.arg("--install-dir")
                .arg(maybeQuote(installDir));
        }

        String resourceDir = resolveTemplate(packager.getResourceDir(), props);
        if (isNotBlank(resourceDir)) {
            Path resourceDirPath = context.getBasedir().resolve(resourceDir);
            if (Files.exists(resourceDirPath)) {
                cmd.arg("--resource-dir")
                    .arg(maybeQuote(resourceDirPath.toAbsolutePath().toString()));
            }
        }

        if (packager instanceof JpackageAssembler.Osx) {
            customizeOsx((JpackageAssembler.Osx) packager, inputsDirectory, cmd, props);
        } else if (packager instanceof JpackageAssembler.Linux) {
            customizeLinux(type, (JpackageAssembler.Linux) packager, inputsDirectory, cmd);
        } else if (packager instanceof JpackageAssembler.Windows) {
            customizeWindows((JpackageAssembler.Windows) packager, inputsDirectory, cmd, props);
        }
    }

    private void customizeOsx(JpackageAssembler.Osx packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        if (isNotBlank(packager.getPackageName())) {
            cmd.arg("--mac-package-name")
                .arg(packager.getPackageName());
        }
        if (isNotBlank(packager.getPackageSigningPrefix())) {
            cmd.arg("--mac-package-signing-prefix")
                .arg(packager.getPackageSigningPrefix());
        }
        if (packager.isSign()) {
            cmd.arg("--mac-sign");
        }

        String signingKeychain = resolveTemplate(packager.getSigningKeychain(), props);
        if (isNotBlank(signingKeychain)) {
            Path path = context.getBasedir().resolve(resolveTemplate(signingKeychain, props));
            if (Files.exists(path)) {
                cmd.arg("--mac-signing-keychain")
                    .arg(path.toAbsolutePath().toString());
            }
        }
        if (isNotBlank(packager.getSigningKeyUsername())) {
            cmd.arg("--mac-signing-key-user-name")
                .arg(packager.getSigningKeyUsername());
        }

        cmd.arg("--icon")
            .arg(inputsDirectory.resolve(assembler.getName() + ".icns").toAbsolutePath().toString());
    }

    private void customizeLinux(String type, JpackageAssembler.Linux packager, Path inputsDirectory, Command cmd) {
        if (isNotBlank(packager.getPackageName())) {
            cmd.arg("--linux-package-name")
                .arg(packager.getPackageName());
        }
        if (isNotBlank(packager.getMenuGroup())) {
            cmd.arg("--linux-menu-group")
                .arg(packager.getMenuGroup());
        }
        if (isNotBlank(packager.getAppRelease())) {
            cmd.arg("--linux-app-release")
                .arg(packager.getAppRelease());
        }
        if (isNotBlank(packager.getAppCategory())) {
            cmd.arg("--linux-app-category")
                .arg(packager.getAppCategory());
        }
        if (packager.isShortcut()) {
            cmd.arg("--linux-shortcut");
        }
        if (!packager.getPackageDeps().isEmpty()) {
            cmd.arg("--linux-package-deps")
                .arg(String.join(",", packager.getPackageDeps()));
        }

        if ("deb".equals(type)) {
            if (isNotBlank(packager.getMaintainer())) {
                cmd.arg("--linux-deb-maintainer")
                    .arg(packager.getMaintainer());
            }
        } else if ("rpm".equals(type)) {
            if (isNotBlank(packager.getLicense())) {
                cmd.arg("--linux-rpm-license-type")
                    .arg(packager.getLicense());
            }
        }

        cmd.arg("--icon")
            .arg(inputsDirectory.resolve(assembler.getName() + ".png").toAbsolutePath().toString());
    }

    private void customizeWindows(JpackageAssembler.Windows packager, Path inputsDirectory, Command cmd, TemplateContext props) {
        if (packager.isConsole()) {
            cmd.arg("--win-console");
        }
        if (packager.isDirChooser()) {
            cmd.arg("--win-dir-chooser");
        }
        if (packager.isMenu()) {
            cmd.arg("--win-menu");
        }
        if (packager.isPerUserInstall()) {
            cmd.arg("--win-per-user-install");
        }
        if (packager.isShortcut()) {
            cmd.arg("--win-shortcut");
        }
        if (packager.isShortcutPrompt()) {
            cmd.arg("--win-shortcut-prompt");
        }
        if (isNotBlank(packager.getMenuGroup())) {
            cmd.arg("--win-menu-group")
                .arg(maybeQuote(packager.getMenuGroup()));
        }
        if (isNotBlank(packager.getUpgradeUuid())) {
            cmd.arg("--win-upgrade-uuid")
                .arg(packager.getUpgradeUuid());
        }
        if (isNotBlank(packager.getHelpUrl())) {
            cmd.arg("--win-help-url")
                .arg(resolveTemplate(packager.getHelpUrl(), props));
        }
        if (isNotBlank(packager.getUpdateUrl())) {
            cmd.arg("--win-update-url")
                .arg(resolveTemplate(packager.getUpdateUrl(), props));
        }

        cmd.arg("--icon")
            .arg(maybeQuote(inputsDirectory.resolve(assembler.getName() + ".ico").toAbsolutePath().toString()));
    }
}

1	/*
2	* SPDX-License-Identifier: Apache-2.0
3	*
4	* Copyright 2020-2025 The JReleaser authors.
5	*
6	* Licensed under the Apache License, Version 2.0 (the "License");
7	* you may not use this file except in compliance with the License.
8	* You may obtain a copy of the License at
9	*
10	* https://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing, software
13	* distributed under the License is distributed on an "AS IS" BASIS,
14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	* See the License for the specific language governing permissions and
16	* limitations under the License.
17	*/
18	package org.jreleaser.assemblers;
19
20	import org.apache.commons.io.IOUtils;
21	import org.jreleaser.bundle.RB;
22	import org.jreleaser.model.Constants;
23	import org.jreleaser.model.internal.JReleaserContext;
24	import org.jreleaser.model.internal.assemble.JlinkAssembler;
25	import org.jreleaser.model.internal.assemble.JpackageAssembler;
26	import org.jreleaser.model.internal.common.Artifact;
27	import org.jreleaser.model.spi.assemble.AssemblerProcessingException;
28	import org.jreleaser.mustache.TemplateContext;
29	import org.jreleaser.sdk.command.Command;
30	import org.jreleaser.templates.TemplateResource;
31	import org.jreleaser.templates.TemplateUtils;
32	import org.jreleaser.util.FileUtils;
33	import org.jreleaser.util.PlatformUtils;
34	import org.jreleaser.version.SemanticVersion;
35
36	import java.io.IOException;
37	import java.nio.file.Files;
38	import java.nio.file.Path;
39	import java.nio.file.Paths;
40	import java.util.Optional;
41
42	import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
43	import static org.jreleaser.assemblers.AssemblerUtils.copyJars;
44	import static org.jreleaser.assemblers.AssemblerUtils.readJavaVersion;
45	import static org.jreleaser.mustache.Templates.resolveTemplate;
46	import static org.jreleaser.util.FileType.JAR;
47	import static org.jreleaser.util.FileUtils.listFilesAndProcess;
48	import static org.jreleaser.util.PlatformUtils.isWindows;
49	import static org.jreleaser.util.StringUtils.isBlank;
50	import static org.jreleaser.util.StringUtils.isNotBlank;
51
52	/**
53	* @author Andres Almiray
54	* @since 0.10.0
55	*/
56	public class JpackageAssemblerProcessor extends AbstractAssemblerProcessor<org.jreleaser.model.api.assemble.JpackageAssembler, JpackageAssembler> {
57	private static final String FILES_DIRECTORY = "files";
58
59	public JpackageAssemblerProcessor(JReleaserContext context) {
60	super(context);	1✔
61	}	1✔
62
63	@Override
64	protected void doAssemble(TemplateContext props) throws AssemblerProcessingException {
65	JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();	1✔
66
67	if (!packager.getJdk().isActiveAndSelected()) return;	1✔
68
69	// verify jdk
70	Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);	1✔
71	SemanticVersion jdkVersion = SemanticVersion.of(readJavaVersion(jdkPath));	1✔
72	context.getLogger().debug(RB.$("assembler.jpackage.jdk"), jdkVersion, jdkPath.toAbsolutePath().toString());	1✔
73	if (jdkVersion.getMajor() < 16) {	1✔
74	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_minimum_jdk_required", jdkVersion.toString()));	×
75	}
76
77	String platform = packager.getJdk().getPlatform();	1✔
78	String platformReplaced = assembler.getPlatform().applyReplacements(platform);	1✔
79
80	Path assembleDirectory = props.get(Constants.KEY_DISTRIBUTION_ASSEMBLE_DIRECTORY);	1✔
81	Path workDirectory = assembleDirectory.resolve(WORK_DIRECTORY + "-" + platformReplaced);	1✔
82	Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);	1✔
83	Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);	1✔
84
85	// copy files to inputs
86	copyTemplates(context, props, filesDirectory);	1✔
87	copyArtifacts(context, filesDirectory, platform, true);	1✔
88	copyFiles(context, filesDirectory);	1✔
89	copyFileSets(context, filesDirectory);	1✔
90
91	// copy jars to inputs
92	context.getLogger().debug(RB.$("assembler.copy.jars"), context.relativizeToBasedir(filesDirectory));	1✔
93	if (isBlank(assembler.getJava().getMainModule())) {	1✔
94	if (isNotBlank(assembler.getJlink())) {	1✔
95	JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());	1✔
96	if (jlink.getJavaArchive().isSet()) {	1✔
97	String configuredPath = jlink.getJavaArchive().getPath();	×
98	String archiveFile = resolveTemplate(configuredPath, props);	×
99	Path archivePath = context.getBasedir().resolve(Paths.get(archiveFile));	×
100	if (!Files.exists(archivePath)) {	×
101	throw new AssemblerProcessingException(RB.$("ERROR_path_does_not_exist_2", configuredPath, archivePath));	×
102	}
103
104	Path archiveDirectory = inputsDirectory.resolve(ARCHIVE_DIRECTORY);	×
105	try {
106	FileUtils.unpackArchive(archivePath, archiveDirectory, true);	×
107	} catch (IOException e) {	×
108	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
109	}	×
110
111	String libDirectoryName = resolveTemplate(jlink.getJavaArchive().getLibDirectoryName(), props);	×
112	Path libPath = inputsDirectory.resolve(ARCHIVE_DIRECTORY).resolve(libDirectoryName);	×
113	try {
114	FileUtils.copyFiles(context.getLogger(), libPath, filesDirectory);	×
115	} catch (IOException e) {	×
116	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
117	}	×
118	}
119	}
120
121	copyJars(context, assembler, filesDirectory, "");	1✔
122	copyJars(context, assembler, filesDirectory, platform);	1✔
123	}
124
125	// copy icon to inputs
126	copyIcon(context, assembler, packager, inputsDirectory, platform, props);	1✔
127
128	// adjust runtime image
129	if (isNotBlank(assembler.getJlink())) {	1✔
130	adjustRuntimeImage(context, assembler, workDirectory, platform);	1✔
131	}
132
133	for (String type : packager.getTypes()) {	1✔
134	context.getLogger().info("- " + RB.$("assembler.jpackage.type"), type);	1✔
135	jpackage(context, type, workDirectory, props);	1✔
136	}	1✔
137	}	1✔
138
139	private void copyIcon(JReleaserContext context, JpackageAssembler assembler,
140	JpackageAssembler.PlatformPackager packager, Path inputsDirectory,
141	String platform, TemplateContext props) throws AssemblerProcessingException {
142	String p = "linux";	1✔
143	String ext = ".png";	1✔
144
145	if (isWindows(platform)) {	1✔
146	p = "windows";	×
147	ext = ".ico";	×
148	} else if (PlatformUtils.isMac(platform)) {	1✔
149	p = "osx";	1✔
150	ext = ".icns";	1✔
151	}
152
153	String icon = resolveTemplate(packager.getIcon(), props);	1✔
154	try {
155	if (isNotBlank(icon) && Files.exists(context.getBasedir().resolve(icon)) && icon.endsWith(ext)) {	1✔
156	Path iconPath = context.getBasedir().resolve(icon);	1✔
157	Files.copy(iconPath, inputsDirectory.resolve(assembler.getName() + ext), REPLACE_EXISTING);	1✔
158	} else {	1✔
159	String iconResource = "META-INF/jreleaser/icons/" + p + "/duke" + ext;	×
160	try (TemplateResource templateResource = TemplateUtils.resolveResource(context.getLogger(), iconResource)) {	×
161	writeFile(IOUtils.toByteArray(templateResource.getInputStream()), inputsDirectory.resolve(assembler.getName() + ext));	×
162	}
163	}
164	} catch (Exception e) {	×
165	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
166	}	1✔
167	}	1✔
168
169	@SuppressWarnings("UnnecessaryParentheses")
170	private void adjustRuntimeImage(JReleaserContext context, JpackageAssembler assembler, Path workDirectory, String platform) throws AssemblerProcessingException {
171	Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);	1✔
172	if (!runtimeImageByPlatform.isPresent()) {	1✔
173	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));	×
174	}
175
176	Path originalImage = runtimeImageByPlatform.get().getEffectivePath(context, assembler);	1✔
177	Path adjustedImage = workDirectory.resolve("runtime-image");	1✔
178
179	try {
180	if (!FileUtils.copyFilesRecursive(context.getLogger(), originalImage, adjustedImage, path -> {	1✔
181	String fileName = path.getFileName().toString();	1✔
182	boolean pathIsJar = fileName.endsWith(JAR.extension()) && path.getParent().getFileName().toString().equals(JARS_DIRECTORY);	1✔
183	boolean pathIsExecutable = fileName.equals(context.getModel().getAssemble().findJlink(assembler.getJlink()).getExecutable());	1✔
184	return pathIsJar \|\| pathIsExecutable;	1✔
185	})) {
186	throw new IOException(RB.$("ERROR_assembler_adjusting_image", adjustedImage));	×
187	}
188	} catch (IOException e) {	×
189	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
190	}	1✔
191
192	runtimeImageByPlatform.get().setPath(adjustedImage.toAbsolutePath().toString());	1✔
193	}	1✔
194
195	private void jpackage(JReleaserContext context, String type, Path workDirectory, TemplateContext props) throws AssemblerProcessingException {
196	JpackageAssembler.PlatformPackager packager = assembler.getResolvedPlatformPackager();	1✔
197	Path jdkPath = packager.getJdk().getEffectivePath(context, assembler);	1✔
198	String platform = packager.getJdk().getPlatform();	1✔
199	String platformReplaced = assembler.getPlatform().applyReplacements(platform);	1✔
200
201	Path assembleDirectory = workDirectory.getParent();	1✔
202	Path packagerDirectory = workDirectory.resolve(type).toAbsolutePath();	1✔
203	try {
204	FileUtils.deleteFiles(packagerDirectory);	1✔
205	} catch (IOException e) {	×
206	throw new AssemblerProcessingException(RB.$("ERROR_assembler_delete_dir",	×
207	context.relativizeToBasedir(packagerDirectory)), e);	×
208	}	1✔
209
210	Path inputsDirectory = workDirectory.resolve(INPUTS_DIRECTORY);	1✔
211
212	Optional<Artifact> runtimeImageByPlatform = assembler.findRuntimeImageByPlatform(platform);	1✔
213	if (!runtimeImageByPlatform.isPresent()) {	1✔
214	throw new AssemblerProcessingException(RB.$("ERROR_jpackage_runtime_image_not_found", platform));	×
215	}
216
217	String moduleName = assembler.getJava().getMainModule();	1✔
218	String appName = packager.getResolvedAppName(context, assembler);	1✔
219	String appVersion = assembler.getApplicationPackage().getResolvedAppVersion(context, assembler);	1✔
220	String vendor = assembler.getApplicationPackage().getVendor();	1✔
221	String copyright = assembler.getApplicationPackage().getCopyright();	1✔
222
223	Path jpackageExecutable = jdkPath	1✔
224	.resolve(BIN_DIRECTORY)	1✔
225	.resolve(isWindows() ? "jpackage.exe" : "jpackage")	1✔
226	.toAbsolutePath();	1✔
227
228	Command cmd = new Command(jpackageExecutable.toAbsolutePath().toString(), true)	1✔
229	.arg("--type")	1✔
230	.arg(type)	1✔
231	.arg("--dest")	1✔
232	.arg(assembleDirectory.toAbsolutePath().toString())	1✔
233	.arg("--input")	1✔
234	.arg(inputsDirectory.resolve(FILES_DIRECTORY).toAbsolutePath().toString())	1✔
235	.arg("--name")	1✔
236	.arg(maybeQuote(appName))	1✔
237	.arg("--runtime-image")	1✔
238	.arg(maybeQuote(runtimeImageByPlatform.get().getEffectivePath(context, assembler).toAbsolutePath().toString()))	1✔
239	.arg("--app-version")	1✔
240	.arg(appVersion)	1✔
241	.arg("--vendor")	1✔
242	.arg(maybeQuote(vendor))	1✔
243	.arg("--copyright")	1✔
244	.arg(maybeQuote(copyright))	1✔
245	.arg("--description")	1✔
246	.arg(maybeQuote(context.getModel().getProject().getDescription()));	1✔
247
248	if (assembler.isVerbose()) {	1✔
249	cmd.arg("--verbose");	×
250	}
251
252	if (isNotBlank(moduleName)) {	1✔
253	cmd.arg("--module")	×
254	.arg(moduleName + "/" + assembler.getJava().getMainClass());	×
255	} else {
256	String mainJarPath = "";	1✔
257
258	if (isNotBlank(assembler.getMainJar().getPath())) {	1✔
259	mainJarPath = assembler.getMainJar().getResolvedPath().getFileName().toString();	1✔
260	}
261
262	if (isNotBlank(assembler.getJlink())) {	1✔
263	JlinkAssembler jlink = context.getModel().getAssemble().findJlink(assembler.getJlink());	1✔
264	if (jlink.getJavaArchive().isSet()) {	1✔
265	String mainJarName = resolveTemplate(jlink.getJavaArchive().getMainJarName(), props);	×
266	Path filesDirectory = inputsDirectory.resolve(FILES_DIRECTORY);	×
267	mainJarPath = filesDirectory.resolve(mainJarName).getFileName().toString();	×
268	}
269	}
270
271	cmd.arg("--main-class")	1✔
272	.arg(assembler.getJava().getMainClass())	1✔
273	.arg("--main-jar")	1✔
274	.arg(maybeQuote(mainJarPath));	1✔
275	}
276
277	// Launcher
278	for (String argument : assembler.getLauncher().getArguments()) {	1✔
279	cmd.arg("--arguments")	×
280	.arg(maybeQuote(argument));	×
281	}	×
282	for (String javaOption : assembler.getLauncher().getJavaOptions()) {	1✔
283	cmd.arg("--java-options")	×
284	.arg(maybeQuote(javaOption));	×
285	}	×
286	for (String launcher : assembler.getLauncher().getLaunchers()) {	1✔
287	cmd.arg("--add-launcher")	×
288	.arg(maybeQuote(launcher));	×
289	}	×
290
291	// ApplicationPackage
292	String licenseFile = resolveTemplate(assembler.getApplicationPackage().getLicenseFile(), props);	1✔
293	if (isNotBlank(licenseFile)) {	1✔
294	Path licenseFilePath = context.getBasedir().resolve(licenseFile);	×
295	if (Files.exists(licenseFilePath)) {	×
296	cmd.arg("--license-file")	×
297	.arg(maybeQuote(licenseFilePath.toAbsolutePath().toString()));	×
298	}
299	}
300
301	if (!assembler.getApplicationPackage().getFileAssociations().isEmpty()) {	1✔
302	for (String filename : assembler.getApplicationPackage().getFileAssociations()) {	×
303	Path path = context.getBasedir().resolve(resolveTemplate(filename, props));	×
304	if (Files.exists(path)) {	×
305	cmd.arg("--file-associations")	×
306	.arg(maybeQuote(path.toAbsolutePath().toString()));	×
307	}
308	}	×
309	}
310
311	customize(type, packager, inputsDirectory, cmd, props);	1✔
312
313	context.getLogger().debug(String.join(" ", cmd.getArgs()));	1✔
314	Command.Result result = executeCommand(cmd);	1✔
315	if (assembler.isVerbose()) {	1✔
316	context.getLogger().debug(result.getOut());	×
317	}
318
319	// replace only if not linux
320	if (!PlatformUtils.isLinux(platform) && assembler.isAttachPlatform()) {	1✔
321	try {
322	Optional<Path> artifact = listFilesAndProcess(assembleDirectory, files ->	1✔
323	files.filter(path -> path.getFileName().toString().endsWith(type))	1✔
324	.findFirst().orElse(null));	1✔
325
326	if (artifact.isPresent()) {	1✔
327	String dest = artifact.get().getFileName().toString()	1✔
328	.replace("." + type, "-" + platformReplaced + "." + type);	1✔
329	Files.move(	1✔
330	assembleDirectory.resolve(artifact.get().getFileName()),	1✔
331	assembleDirectory.resolve(dest), REPLACE_EXISTING);	1✔
332	}
333	} catch (IOException e) {	×
334	throw new AssemblerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
335	}	1✔
336	}
337	}	1✔
338
339	private void customize(String type, JpackageAssembler.PlatformPackager packager, Path inputsDirectory, Command cmd, TemplateContext props) {
340	String installDir = resolveTemplate(packager.getInstallDir(), props);	1✔
341	if (isNotBlank(installDir)) {	1✔
342	cmd.arg("--install-dir")	×
343	.arg(maybeQuote(installDir));	×
344	}
345
346	String resourceDir = resolveTemplate(packager.getResourceDir(), props);	1✔
347	if (isNotBlank(resourceDir)) {	1✔
348	Path resourceDirPath = context.getBasedir().resolve(resourceDir);	1✔
349	if (Files.exists(resourceDirPath)) {	1✔
350	cmd.arg("--resource-dir")	×
351	.arg(maybeQuote(resourceDirPath.toAbsolutePath().toString()));	×
352	}
353	}
354
355	if (packager instanceof JpackageAssembler.Osx) {	1✔
356	customizeOsx((JpackageAssembler.Osx) packager, inputsDirectory, cmd, props);	1✔
UNCOV 357	} else if (packager instanceof JpackageAssembler.Linux) {	×
UNCOV 358	customizeLinux(type, (JpackageAssembler.Linux) packager, inputsDirectory, cmd);	×
359	} else if (packager instanceof JpackageAssembler.Windows) {	×
360	customizeWindows((JpackageAssembler.Windows) packager, inputsDirectory, cmd, props);	×
361	}
362	}	1✔
363
364	private void customizeOsx(JpackageAssembler.Osx packager, Path inputsDirectory, Command cmd, TemplateContext props) {
365	if (isNotBlank(packager.getPackageName())) {	1✔
366	cmd.arg("--mac-package-name")	1✔
367	.arg(packager.getPackageName());	1✔
368	}
369	if (isNotBlank(packager.getPackageSigningPrefix())) {	1✔
370	cmd.arg("--mac-package-signing-prefix")	×
371	.arg(packager.getPackageSigningPrefix());	×
372	}
373	if (packager.isSign()) {	1✔
374	cmd.arg("--mac-sign");	×
375	}
376
377	String signingKeychain = resolveTemplate(packager.getSigningKeychain(), props);	1✔
378	if (isNotBlank(signingKeychain)) {	1✔
379	Path path = context.getBasedir().resolve(resolveTemplate(signingKeychain, props));	×
380	if (Files.exists(path)) {	×
381	cmd.arg("--mac-signing-keychain")	×
382	.arg(path.toAbsolutePath().toString());	×
383	}
384	}
385	if (isNotBlank(packager.getSigningKeyUsername())) {	1✔
386	cmd.arg("--mac-signing-key-user-name")	×
387	.arg(packager.getSigningKeyUsername());	×
388	}
389
390	cmd.arg("--icon")	1✔
391	.arg(inputsDirectory.resolve(assembler.getName() + ".icns").toAbsolutePath().toString());	1✔
392	}	1✔
393
394	private void customizeLinux(String type, JpackageAssembler.Linux packager, Path inputsDirectory, Command cmd) {
UNCOV 395	if (isNotBlank(packager.getPackageName())) {	×
396	cmd.arg("--linux-package-name")	×
397	.arg(packager.getPackageName());	×
398	}
UNCOV 399	if (isNotBlank(packager.getMenuGroup())) {	×
400	cmd.arg("--linux-menu-group")	×
401	.arg(packager.getMenuGroup());	×
402	}
UNCOV 403	if (isNotBlank(packager.getAppRelease())) {	×
404	cmd.arg("--linux-app-release")	×
405	.arg(packager.getAppRelease());	×
406	}
UNCOV 407	if (isNotBlank(packager.getAppCategory())) {	×
408	cmd.arg("--linux-app-category")	×
409	.arg(packager.getAppCategory());	×
410	}
UNCOV 411	if (packager.isShortcut()) {	×
412	cmd.arg("--linux-shortcut");	×
413	}
UNCOV 414	if (!packager.getPackageDeps().isEmpty()) {	×
415	cmd.arg("--linux-package-deps")	×
416	.arg(String.join(",", packager.getPackageDeps()));	×
417	}
418
UNCOV 419	if ("deb".equals(type)) {	×
UNCOV 420	if (isNotBlank(packager.getMaintainer())) {	×
UNCOV 421	cmd.arg("--linux-deb-maintainer")	×
UNCOV 422	.arg(packager.getMaintainer());	×
423	}
UNCOV 424	} else if ("rpm".equals(type)) {	×
UNCOV 425	if (isNotBlank(packager.getLicense())) {	×
UNCOV 426	cmd.arg("--linux-rpm-license-type")	×
UNCOV 427	.arg(packager.getLicense());	×
428	}
429	}
430
UNCOV 431	cmd.arg("--icon")	×
UNCOV 432	.arg(inputsDirectory.resolve(assembler.getName() + ".png").toAbsolutePath().toString());	×
UNCOV 433	}	×
434
435	private void customizeWindows(JpackageAssembler.Windows packager, Path inputsDirectory, Command cmd, TemplateContext props) {
436	if (packager.isConsole()) {	×
437	cmd.arg("--win-console");	×
438	}
439	if (packager.isDirChooser()) {	×
440	cmd.arg("--win-dir-chooser");	×
441	}
442	if (packager.isMenu()) {	×
443	cmd.arg("--win-menu");	×
444	}
445	if (packager.isPerUserInstall()) {	×
446	cmd.arg("--win-per-user-install");	×
447	}
448	if (packager.isShortcut()) {	×
449	cmd.arg("--win-shortcut");	×
450	}
451	if (packager.isShortcutPrompt()) {	×
452	cmd.arg("--win-shortcut-prompt");	×
453	}
454	if (isNotBlank(packager.getMenuGroup())) {	×
455	cmd.arg("--win-menu-group")	×
456	.arg(maybeQuote(packager.getMenuGroup()));	×
457	}
458	if (isNotBlank(packager.getUpgradeUuid())) {	×
459	cmd.arg("--win-upgrade-uuid")	×
460	.arg(packager.getUpgradeUuid());	×
461	}
462	if (isNotBlank(packager.getHelpUrl())) {	×
463	cmd.arg("--win-help-url")	×
464	.arg(resolveTemplate(packager.getHelpUrl(), props));	×
465	}
466	if (isNotBlank(packager.getUpdateUrl())) {	×
467	cmd.arg("--win-update-url")	×
468	.arg(resolveTemplate(packager.getUpdateUrl(), props));	×
469	}
470
471	cmd.arg("--icon")	×
472	.arg(maybeQuote(inputsDirectory.resolve(assembler.getName() + ".ico").toAbsolutePath().toString()));	×
473	}	×
474	}

jreleaser / jreleaser / #537

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous