#558

Committed 08 Dec 2025 02:56PM UTC coverage: 48.239% (+0.02%) from 48.215%

Build # #558

Build Type

push

github

Committed by

aalmiray

Commit Message

feat(core): warn when a name template cannot be resolved

Closes #1960

Closes #1961

Run Details

299 of 573 new or added lines in 133 files covered. (52.18%)

4 existing lines in 4 files now uncovered.

26047 of 53996 relevant lines covered (48.24%)

0.48 hits per line

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

1.08

/core/jreleaser-engine/src/main/java/org/jreleaser/packagers/JibPackagerProcessor.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.packagers;

import org.jreleaser.bundle.RB;
import org.jreleaser.model.internal.JReleaserContext;
import org.jreleaser.model.internal.common.Artifact;
import org.jreleaser.model.internal.distributions.Distribution;
import org.jreleaser.model.internal.packagers.JibConfiguration;
import org.jreleaser.model.internal.packagers.JibPackager;
import org.jreleaser.model.internal.packagers.JibSpec;
import org.jreleaser.model.spi.packagers.PackagerProcessingException;
import org.jreleaser.mustache.TemplateContext;
import org.jreleaser.sdk.command.CommandException;
import org.jreleaser.sdk.tool.Jib;
import org.jreleaser.sdk.tool.ToolException;
import org.jreleaser.util.FileUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
import static java.util.Collections.singletonList;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_CLASS;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_MODULE;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_PACKAGE_DIRECTORY;
import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_PREPARE_DIRECTORY;
import static org.jreleaser.model.Constants.KEY_JIB_BASE_IMAGE;
import static org.jreleaser.model.Constants.KEY_JIB_CREATION_TIME;
import static org.jreleaser.model.Constants.KEY_JIB_ENVIRONMENT;
import static org.jreleaser.model.Constants.KEY_JIB_EXPOSED_PORTS;
import static org.jreleaser.model.Constants.KEY_JIB_FORMAT;
import static org.jreleaser.model.Constants.KEY_JIB_HAS_ENVIRONMENT;
import static org.jreleaser.model.Constants.KEY_JIB_HAS_EXPOSED_PORTS;
import static org.jreleaser.model.Constants.KEY_JIB_HAS_VOLUMES;
import static org.jreleaser.model.Constants.KEY_JIB_LABELS;
import static org.jreleaser.model.Constants.KEY_JIB_SPEC_NAME;
import static org.jreleaser.model.Constants.KEY_JIB_USER;
import static org.jreleaser.model.Constants.KEY_JIB_VOLUMES;
import static org.jreleaser.model.Constants.KEY_JIB_WORKING_DIRECTORY;
import static org.jreleaser.mustache.MustacheUtils.passThrough;
import static org.jreleaser.mustache.Templates.resolveTemplate;
import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
import static org.jreleaser.util.StringUtils.isNotBlank;

/**
 * @author Andres Almiray
 * @since 1.6.0
 */
public class JibPackagerProcessor extends AbstractRepositoryPackagerProcessor<JibPackager> {
    private static final String ROOT = "ROOT";

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

    @Override
    protected void doPrepareDistribution(Distribution distribution,
                                         TemplateContext props,
                                         String distributionName,
                                         Path prepareDirectory,
                                         String templateDirectory,
                                         String packagerName,
                                         boolean copyLicense) throws IOException, PackagerProcessingException {
        if (packager.getActiveSpecs().isEmpty()) {
            super.doPrepareDistribution(distribution, props, distributionName,
                prepareDirectory, templateDirectory, packagerName, true);
            return;
        }

        // copy root files
        String rootTemplateDirectory = getPackager().getTemplateDirectory() + File.separator + ROOT;
        super.doPrepareDistribution(distribution, props, distributionName,
            prepareDirectory.resolve(ROOT),
            rootTemplateDirectory,
            packager.getType(),
            false);
        Files.deleteIfExists(prepareDirectory.resolve(ROOT).resolve("build.yml"));

        for (JibSpec spec : packager.getActiveSpecs()) {
            prepareSpec(distribution, props, distributionName, prepareDirectory, spec);
        }
    }

    private void prepareSpec(Distribution distribution,
                             TemplateContext props,
                             String distributionName,
                             Path prepareDirectory,
                             JibSpec spec) throws IOException, PackagerProcessingException {
        TemplateContext newProps = fillSpecProps(distribution, props, spec);
        context.getLogger().debug(RB.$("distributions.action.preparing") + " {} spec", spec.getName());
        super.doPrepareDistribution(distribution, newProps, distributionName,
            prepareDirectory.resolve(spec.getName()),
            spec.getTemplateDirectory(),
            spec.getName() + "/" + packager.getType(),
            false);
    }

    private TemplateContext fillSpecProps(Distribution distribution, TemplateContext props, JibSpec spec) {
        List<Artifact> artifacts = singletonList(spec.getArtifact());
        TemplateContext newProps = fillProps(distribution, props);
        newProps.set(KEY_JIB_SPEC_NAME, spec.getName());
        fillJibProperties(newProps, spec);
        verifyAndAddArtifacts(newProps, distribution, artifacts);
        Path prepareDirectory = newProps.get(KEY_DISTRIBUTION_PREPARE_DIRECTORY);
        newProps.set(KEY_DISTRIBUTION_PREPARE_DIRECTORY, prepareDirectory.resolve(spec.getName()));
        Path packageDirectory = newProps.get(KEY_DISTRIBUTION_PACKAGE_DIRECTORY);
        newProps.set(KEY_DISTRIBUTION_PACKAGE_DIRECTORY, packageDirectory.resolve(spec.getName()));
        return newProps;
    }

    @Override
    protected boolean verifyAndAddArtifacts(TemplateContext props, Distribution distribution) {
        if (packager.getActiveSpecs().isEmpty()) {
            return super.verifyAndAddArtifacts(props, distribution);
        }
        return true;
    }

    @Override
    protected void doPackageDistribution(Distribution distribution,
                                         TemplateContext props,
                                         Path packageDirectory) throws PackagerProcessingException {
        if (packager.getActiveSpecs().isEmpty()) {
            List<Artifact> artifacts = packager.resolveArtifacts(context, distribution);
            packageJib(distribution, props, packageDirectory, artifacts);
            return;
        }

        Path rootPrepareDirectory = getPrepareDirectory(props).resolve(ROOT);
        Path rootPackageDirectory = getPackageDirectory(props).resolve(ROOT);
        copyFiles(rootPrepareDirectory, rootPackageDirectory);

        for (JibSpec spec : packager.getActiveSpecs()) {
            context.getLogger().debug(RB.$("distributions.action.packaging") + " {} spec", spec.getName());
            TemplateContext newProps = fillSpecProps(distribution, props, spec);
            packageJib(distribution, newProps, packageDirectory.resolve(spec.getName()), singletonList(spec.getArtifact()));
        }
    }

    protected void packageJib(Distribution distribution,
                              TemplateContext props,
                              Path packageDirectory,
                              List<Artifact> artifacts) throws PackagerProcessingException {
        super.doPackageDistribution(distribution, props, packageDirectory);

        try {
            copyPreparedFiles(props);
            Path assemblyDirectory = packageDirectory.resolve("assembly");

            Files.createDirectories(assemblyDirectory);

            for (Artifact artifact : artifacts) {
                Path artifactPath = artifact.getEffectivePath(context, distribution);
                if (distribution.getType() == org.jreleaser.model.Distribution.DistributionType.FLAT_BINARY) {
                    Files.copy(artifactPath, assemblyDirectory.resolve(artifactPath.getFileName()), REPLACE_EXISTING);
                } else {
                    FileUtils.unpackArchive(artifactPath, assemblyDirectory);
                }
            }
        } catch (IOException e) {
            throw new PackagerProcessingException(e);
        }
    }

    @Override
    public void publishDistribution(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
        if (packager.getActiveSpecs().isEmpty()) {
            publishToRepository(distribution, props);
            super.publishDistribution(distribution, props);
            return;
        }

        publishToRepository(distribution, props);
        for (JibSpec spec : packager.getActiveSpecs()) {
            context.getLogger().debug(RB.$("distributions.action.publishing") + " {} spec", spec.getName());
            TemplateContext newProps = fillSpecProps(distribution, props, spec);
            publishJib(newProps, spec);
        }
    }

    private void publishToRepository(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
        super.doPublishDistribution(distribution, fillProps(distribution, props));
    }

    @Override
    protected void doPublishDistribution(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
        publishJib(props, getPackager());
    }

    protected void publishJib(TemplateContext props, JibConfiguration jibc) throws PackagerProcessingException {
        if (context.isDryrun()) {
            for (JibConfiguration.Registry registry : jibc.getRegistries()) {
                for (String imageName : jibc.getImageNames()) {
                    imageName = registry.getServer() + "/" + resolveTemplate(context.getLogger(), imageName, props);
                    context.getLogger().info(" - {}", imageName);
                }
            }
            return;
        }

        if (packager.isSkipPublishing()) {
            context.getLogger().info(RB.$("packager.skip.publishing"));
            return;
        }

        Jib jib = new Jib(context.asImmutable(), packager.getVersion());
        try {
            if (!jib.setup()) {
                throw new PackagerProcessingException(RB.$("tool_unavailable", "jib"));
            }
        } catch (ToolException e) {
            throw new PackagerProcessingException(RB.$("tool_unavailable", "jib"));
        }

        Path packageDirectory = getPackageDirectory(props);

        for (JibConfiguration.Registry registry : jibc.getRegistries()) {
            List<String> args = new ArrayList<>();
            args.add("build");
            args.add("--console");
            args.add("plain");
            args.add("--verbosity");
            args.add("error");
            args.add("-c");
            args.add(packageDirectory.toAbsolutePath().toString());
            args.add("-b");
            args.add(packageDirectory.resolve("build.yml").toAbsolutePath().toString());

            if (isNotBlank(registry.getUsername())) {
                args.add("--username=" + registry.getUsername());
            }
            if (isNotBlank(registry.getFromUsername())) {
                args.add("--from-username=" + registry.getFromUsername());
            }
            if (isNotBlank(registry.getToUsername())) {
                args.add("--to-username=" + registry.getToUsername());
            }

            if (isNotBlank(registry.getPassword())) {
                args.add("--password=" + registry.getPassword());
            }
            if (isNotBlank(registry.getFromPassword())) {
                args.add("--from-password=" + registry.getFromPassword());
            }
            if (isNotBlank(registry.getToPassword())) {
                args.add("--to-password=" + registry.getToPassword());
            }

            for (String imageName : jibc.getImageNames()) {
                imageName = registry.getServer() + "/" + resolveTemplate(context.getLogger(), imageName, props);
                List<String> argsCopy = new ArrayList<>(args);
                argsCopy.add("-t");
                argsCopy.add(imageName);

                try {
                    context.getLogger().info(" - {}", imageName);
                    jib.invoke(context.getBasedir(), argsCopy);
                } catch (CommandException e) {
                    throw new PackagerProcessingException(RB.$("ERROR_unexpected_error"), e);
                }
            }
        }
    }

    @Override
    protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
        props.set(KEY_DISTRIBUTION_JAVA_MAIN_CLASS, distribution.getJava().getMainClass());
        props.set(KEY_DISTRIBUTION_JAVA_MAIN_MODULE, distribution.getJava().getMainModule());
        fillJibProperties(props, getPackager());
    }

    protected void fillJibProperties(TemplateContext props, JibConfiguration jib) {
        props.set(KEY_JIB_BASE_IMAGE, jib.getBaseImage());
        props.set(KEY_JIB_CREATION_TIME, jib.getCreationTime());
        props.set(KEY_JIB_FORMAT, jib.getFormat().formatted());
        props.set(KEY_JIB_USER, jib.getUser());
        props.set(KEY_JIB_WORKING_DIRECTORY, jib.getWorkingDirectory());
        props.set(KEY_JIB_HAS_VOLUMES, !jib.getVolumes().isEmpty());
        props.set(KEY_JIB_VOLUMES, jib.getVolumes());
        props.set(KEY_JIB_HAS_EXPOSED_PORTS, !jib.getExposedPorts().isEmpty());
        props.set(KEY_JIB_EXPOSED_PORTS, jib.getExposedPorts());
        props.set(KEY_JIB_HAS_ENVIRONMENT, !jib.getEnvironment().isEmpty());

        Set<String> env = new TreeSet<>();
        jib.getEnvironment().forEach((key, value) -> env.add(passThrough("\"" + key + "\": \"" +
            resolveTemplate(context.getLogger(), value, props) + "\"")));
        props.set(KEY_JIB_ENVIRONMENT, env);

        Set<String> labels = new TreeSet<>();
        jib.getLabels().forEach((key, value) -> labels.add(passThrough("\"" + key + "\": \"" +
            resolveTemplate(context.getLogger(), value, props) + "\"")));
        props.set(KEY_JIB_LABELS, labels);
    }

    @Override
    protected void writeFile(Distribution distribution,
                             String content,
                             TemplateContext props,
                             Path outputDirectory,
                             String fileName) throws PackagerProcessingException {
        fileName = trimTplExtension(fileName);

        Path outputFile = "executable".equals(fileName) ?
            outputDirectory.resolve("assembly").resolve(distribution.getExecutable().getName()) :
            outputDirectory.resolve(fileName);

        writeFile(content, outputFile);
    }

    @Override
    protected void prepareWorkingCopy(TemplateContext props, Path directory, Distribution distribution) throws IOException {
        Path packageDirectory = props.get(KEY_DISTRIBUTION_PACKAGE_DIRECTORY);

        List<JibSpec> activeSpecs = packager.getActiveSpecs();

        if (activeSpecs.isEmpty()) {
            for (String imageName : packager.getImageNames()) {
                copyJibfiles(packageDirectory, resolveTemplate(context.getLogger(), imageName, props), directory, false);
            }
        } else {
            // copy files that do not belong to specs
            prepareWorkingCopy(packageDirectory.resolve(ROOT), directory);

            for (JibSpec spec : activeSpecs) {
                TemplateContext newProps = fillSpecProps(distribution, props, spec);
                for (String imageName : spec.getImageNames()) {
                    copyJibfiles(packageDirectory.resolve(spec.getName()), resolveTemplate(context.getLogger(), imageName, newProps), directory, true);
                }
            }
        }
    }

    private void copyJibfiles(Path source, String imageName, Path directory, boolean isSpec) throws IOException {
        Path destination = directory;

        String[] parts = imageName.split("/");
        parts = parts[parts.length - 1].split(":");
        if (isSpec) {
            destination = directory.resolve(parts[0]);
        }

        if (packager.getPackagerRepository().isVersionedSubfolders()) {
            destination = directory.resolve(parts[1]);
        }

        Path assembly = destination.resolve("assembly");
        FileUtils.deleteFiles(assembly);

        Files.createDirectories(destination);
        prepareWorkingCopy(source, destination, path -> "assembly".equals(path.getFileName().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.packagers;
19
20	import org.jreleaser.bundle.RB;
21	import org.jreleaser.model.internal.JReleaserContext;
22	import org.jreleaser.model.internal.common.Artifact;
23	import org.jreleaser.model.internal.distributions.Distribution;
24	import org.jreleaser.model.internal.packagers.JibConfiguration;
25	import org.jreleaser.model.internal.packagers.JibPackager;
26	import org.jreleaser.model.internal.packagers.JibSpec;
27	import org.jreleaser.model.spi.packagers.PackagerProcessingException;
28	import org.jreleaser.mustache.TemplateContext;
29	import org.jreleaser.sdk.command.CommandException;
30	import org.jreleaser.sdk.tool.Jib;
31	import org.jreleaser.sdk.tool.ToolException;
32	import org.jreleaser.util.FileUtils;
33
34	import java.io.File;
35	import java.io.IOException;
36	import java.nio.file.Files;
37	import java.nio.file.Path;
38	import java.util.ArrayList;
39	import java.util.List;
40	import java.util.Set;
41	import java.util.TreeSet;
42
43	import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
44	import static java.util.Collections.singletonList;
45	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_CLASS;
46	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_JAVA_MAIN_MODULE;
47	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_PACKAGE_DIRECTORY;
48	import static org.jreleaser.model.Constants.KEY_DISTRIBUTION_PREPARE_DIRECTORY;
49	import static org.jreleaser.model.Constants.KEY_JIB_BASE_IMAGE;
50	import static org.jreleaser.model.Constants.KEY_JIB_CREATION_TIME;
51	import static org.jreleaser.model.Constants.KEY_JIB_ENVIRONMENT;
52	import static org.jreleaser.model.Constants.KEY_JIB_EXPOSED_PORTS;
53	import static org.jreleaser.model.Constants.KEY_JIB_FORMAT;
54	import static org.jreleaser.model.Constants.KEY_JIB_HAS_ENVIRONMENT;
55	import static org.jreleaser.model.Constants.KEY_JIB_HAS_EXPOSED_PORTS;
56	import static org.jreleaser.model.Constants.KEY_JIB_HAS_VOLUMES;
57	import static org.jreleaser.model.Constants.KEY_JIB_LABELS;
58	import static org.jreleaser.model.Constants.KEY_JIB_SPEC_NAME;
59	import static org.jreleaser.model.Constants.KEY_JIB_USER;
60	import static org.jreleaser.model.Constants.KEY_JIB_VOLUMES;
61	import static org.jreleaser.model.Constants.KEY_JIB_WORKING_DIRECTORY;
62	import static org.jreleaser.mustache.MustacheUtils.passThrough;
63	import static org.jreleaser.mustache.Templates.resolveTemplate;
64	import static org.jreleaser.templates.TemplateUtils.trimTplExtension;
65	import static org.jreleaser.util.StringUtils.isNotBlank;
66
67	/**
68	* @author Andres Almiray
69	* @since 1.6.0
70	*/
71	public class JibPackagerProcessor extends AbstractRepositoryPackagerProcessor<JibPackager> {
72	private static final String ROOT = "ROOT";
73
74	public JibPackagerProcessor(JReleaserContext context) {
75	super(context);	1✔
76	}	1✔
77
78	@Override
79	protected void doPrepareDistribution(Distribution distribution,
80	TemplateContext props,
81	String distributionName,
82	Path prepareDirectory,
83	String templateDirectory,
84	String packagerName,
85	boolean copyLicense) throws IOException, PackagerProcessingException {
86	if (packager.getActiveSpecs().isEmpty()) {	×
87	super.doPrepareDistribution(distribution, props, distributionName,	×
88	prepareDirectory, templateDirectory, packagerName, true);
89	return;	×
90	}
91
92	// copy root files
93	String rootTemplateDirectory = getPackager().getTemplateDirectory() + File.separator + ROOT;	×
94	super.doPrepareDistribution(distribution, props, distributionName,	×
95	prepareDirectory.resolve(ROOT),	×
96	rootTemplateDirectory,
97	packager.getType(),	×
98	false);
99	Files.deleteIfExists(prepareDirectory.resolve(ROOT).resolve("build.yml"));	×
100
101	for (JibSpec spec : packager.getActiveSpecs()) {	×
102	prepareSpec(distribution, props, distributionName, prepareDirectory, spec);	×
103	}	×
104	}	×
105
106	private void prepareSpec(Distribution distribution,
107	TemplateContext props,
108	String distributionName,
109	Path prepareDirectory,
110	JibSpec spec) throws IOException, PackagerProcessingException {
111	TemplateContext newProps = fillSpecProps(distribution, props, spec);	×
112	context.getLogger().debug(RB.$("distributions.action.preparing") + " {} spec", spec.getName());	×
113	super.doPrepareDistribution(distribution, newProps, distributionName,	×
114	prepareDirectory.resolve(spec.getName()),	×
115	spec.getTemplateDirectory(),	×
116	spec.getName() + "/" + packager.getType(),	×
117	false);
118	}	×
119
120	private TemplateContext fillSpecProps(Distribution distribution, TemplateContext props, JibSpec spec) {
121	List<Artifact> artifacts = singletonList(spec.getArtifact());	×
122	TemplateContext newProps = fillProps(distribution, props);	×
123	newProps.set(KEY_JIB_SPEC_NAME, spec.getName());	×
124	fillJibProperties(newProps, spec);	×
125	verifyAndAddArtifacts(newProps, distribution, artifacts);	×
126	Path prepareDirectory = newProps.get(KEY_DISTRIBUTION_PREPARE_DIRECTORY);	×
127	newProps.set(KEY_DISTRIBUTION_PREPARE_DIRECTORY, prepareDirectory.resolve(spec.getName()));	×
128	Path packageDirectory = newProps.get(KEY_DISTRIBUTION_PACKAGE_DIRECTORY);	×
129	newProps.set(KEY_DISTRIBUTION_PACKAGE_DIRECTORY, packageDirectory.resolve(spec.getName()));	×
130	return newProps;	×
131	}
132
133	@Override
134	protected boolean verifyAndAddArtifacts(TemplateContext props, Distribution distribution) {
135	if (packager.getActiveSpecs().isEmpty()) {	×
136	return super.verifyAndAddArtifacts(props, distribution);	×
137	}
138	return true;	×
139	}
140
141	@Override
142	protected void doPackageDistribution(Distribution distribution,
143	TemplateContext props,
144	Path packageDirectory) throws PackagerProcessingException {
145	if (packager.getActiveSpecs().isEmpty()) {	×
146	List<Artifact> artifacts = packager.resolveArtifacts(context, distribution);	×
147	packageJib(distribution, props, packageDirectory, artifacts);	×
148	return;	×
149	}
150
151	Path rootPrepareDirectory = getPrepareDirectory(props).resolve(ROOT);	×
152	Path rootPackageDirectory = getPackageDirectory(props).resolve(ROOT);	×
153	copyFiles(rootPrepareDirectory, rootPackageDirectory);	×
154
155	for (JibSpec spec : packager.getActiveSpecs()) {	×
156	context.getLogger().debug(RB.$("distributions.action.packaging") + " {} spec", spec.getName());	×
157	TemplateContext newProps = fillSpecProps(distribution, props, spec);	×
158	packageJib(distribution, newProps, packageDirectory.resolve(spec.getName()), singletonList(spec.getArtifact()));	×
159	}	×
160	}	×
161
162	protected void packageJib(Distribution distribution,
163	TemplateContext props,
164	Path packageDirectory,
165	List<Artifact> artifacts) throws PackagerProcessingException {
166	super.doPackageDistribution(distribution, props, packageDirectory);	×
167
168	try {
169	copyPreparedFiles(props);	×
170	Path assemblyDirectory = packageDirectory.resolve("assembly");	×
171
172	Files.createDirectories(assemblyDirectory);	×
173
174	for (Artifact artifact : artifacts) {	×
175	Path artifactPath = artifact.getEffectivePath(context, distribution);	×
176	if (distribution.getType() == org.jreleaser.model.Distribution.DistributionType.FLAT_BINARY) {	×
177	Files.copy(artifactPath, assemblyDirectory.resolve(artifactPath.getFileName()), REPLACE_EXISTING);	×
178	} else {
179	FileUtils.unpackArchive(artifactPath, assemblyDirectory);	×
180	}
181	}	×
182	} catch (IOException e) {	×
183	throw new PackagerProcessingException(e);	×
184	}	×
185	}	×
186
187	@Override
188	public void publishDistribution(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
189	if (packager.getActiveSpecs().isEmpty()) {	×
190	publishToRepository(distribution, props);	×
191	super.publishDistribution(distribution, props);	×
192	return;	×
193	}
194
195	publishToRepository(distribution, props);	×
196	for (JibSpec spec : packager.getActiveSpecs()) {	×
197	context.getLogger().debug(RB.$("distributions.action.publishing") + " {} spec", spec.getName());	×
198	TemplateContext newProps = fillSpecProps(distribution, props, spec);	×
199	publishJib(newProps, spec);	×
200	}	×
201	}	×
202
203	private void publishToRepository(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
204	super.doPublishDistribution(distribution, fillProps(distribution, props));	×
205	}	×
206
207	@Override
208	protected void doPublishDistribution(Distribution distribution, TemplateContext props) throws PackagerProcessingException {
209	publishJib(props, getPackager());	×
210	}	×
211
212	protected void publishJib(TemplateContext props, JibConfiguration jibc) throws PackagerProcessingException {
213	if (context.isDryrun()) {	×
214	for (JibConfiguration.Registry registry : jibc.getRegistries()) {	×
215	for (String imageName : jibc.getImageNames()) {	×
NEW 216	imageName = registry.getServer() + "/" + resolveTemplate(context.getLogger(), imageName, props);	×
217	context.getLogger().info(" - {}", imageName);	×
218	}	×
219	}	×
220	return;	×
221	}
222
223	if (packager.isSkipPublishing()) {	×
224	context.getLogger().info(RB.$("packager.skip.publishing"));	×
225	return;	×
226	}
227
228	Jib jib = new Jib(context.asImmutable(), packager.getVersion());	×
229	try {
230	if (!jib.setup()) {	×
231	throw new PackagerProcessingException(RB.$("tool_unavailable", "jib"));	×
232	}
233	} catch (ToolException e) {	×
234	throw new PackagerProcessingException(RB.$("tool_unavailable", "jib"));	×
235	}	×
236
237	Path packageDirectory = getPackageDirectory(props);	×
238
239	for (JibConfiguration.Registry registry : jibc.getRegistries()) {	×
240	List<String> args = new ArrayList<>();	×
241	args.add("build");	×
242	args.add("--console");	×
243	args.add("plain");	×
244	args.add("--verbosity");	×
245	args.add("error");	×
246	args.add("-c");	×
247	args.add(packageDirectory.toAbsolutePath().toString());	×
248	args.add("-b");	×
249	args.add(packageDirectory.resolve("build.yml").toAbsolutePath().toString());	×
250
251	if (isNotBlank(registry.getUsername())) {	×
252	args.add("--username=" + registry.getUsername());	×
253	}
254	if (isNotBlank(registry.getFromUsername())) {	×
255	args.add("--from-username=" + registry.getFromUsername());	×
256	}
257	if (isNotBlank(registry.getToUsername())) {	×
258	args.add("--to-username=" + registry.getToUsername());	×
259	}
260
261	if (isNotBlank(registry.getPassword())) {	×
262	args.add("--password=" + registry.getPassword());	×
263	}
264	if (isNotBlank(registry.getFromPassword())) {	×
265	args.add("--from-password=" + registry.getFromPassword());	×
266	}
267	if (isNotBlank(registry.getToPassword())) {	×
268	args.add("--to-password=" + registry.getToPassword());	×
269	}
270
271	for (String imageName : jibc.getImageNames()) {	×
NEW 272	imageName = registry.getServer() + "/" + resolveTemplate(context.getLogger(), imageName, props);	×
273	List<String> argsCopy = new ArrayList<>(args);	×
274	argsCopy.add("-t");	×
275	argsCopy.add(imageName);	×
276
277	try {
278	context.getLogger().info(" - {}", imageName);	×
279	jib.invoke(context.getBasedir(), argsCopy);	×
280	} catch (CommandException e) {	×
281	throw new PackagerProcessingException(RB.$("ERROR_unexpected_error"), e);	×
282	}	×
283	}	×
284	}	×
285	}	×
286
287	@Override
288	protected void fillPackagerProperties(TemplateContext props, Distribution distribution) {
289	props.set(KEY_DISTRIBUTION_JAVA_MAIN_CLASS, distribution.getJava().getMainClass());	×
290	props.set(KEY_DISTRIBUTION_JAVA_MAIN_MODULE, distribution.getJava().getMainModule());	×
291	fillJibProperties(props, getPackager());	×
292	}	×
293
294	protected void fillJibProperties(TemplateContext props, JibConfiguration jib) {
295	props.set(KEY_JIB_BASE_IMAGE, jib.getBaseImage());	×
296	props.set(KEY_JIB_CREATION_TIME, jib.getCreationTime());	×
297	props.set(KEY_JIB_FORMAT, jib.getFormat().formatted());	×
298	props.set(KEY_JIB_USER, jib.getUser());	×
299	props.set(KEY_JIB_WORKING_DIRECTORY, jib.getWorkingDirectory());	×
300	props.set(KEY_JIB_HAS_VOLUMES, !jib.getVolumes().isEmpty());	×
301	props.set(KEY_JIB_VOLUMES, jib.getVolumes());	×
302	props.set(KEY_JIB_HAS_EXPOSED_PORTS, !jib.getExposedPorts().isEmpty());	×
303	props.set(KEY_JIB_EXPOSED_PORTS, jib.getExposedPorts());	×
304	props.set(KEY_JIB_HAS_ENVIRONMENT, !jib.getEnvironment().isEmpty());	×
305
306	Set<String> env = new TreeSet<>();	×
307	jib.getEnvironment().forEach((key, value) -> env.add(passThrough("\"" + key + "\": \"" +	×
NEW 308	resolveTemplate(context.getLogger(), value, props) + "\"")));	×
309	props.set(KEY_JIB_ENVIRONMENT, env);	×
310
311	Set<String> labels = new TreeSet<>();	×
312	jib.getLabels().forEach((key, value) -> labels.add(passThrough("\"" + key + "\": \"" +	×
NEW 313	resolveTemplate(context.getLogger(), value, props) + "\"")));	×
314	props.set(KEY_JIB_LABELS, labels);	×
315	}	×
316
317	@Override
318	protected void writeFile(Distribution distribution,
319	String content,
320	TemplateContext props,
321	Path outputDirectory,
322	String fileName) throws PackagerProcessingException {
323	fileName = trimTplExtension(fileName);	×
324
325	Path outputFile = "executable".equals(fileName) ?	×
326	outputDirectory.resolve("assembly").resolve(distribution.getExecutable().getName()) :	×
327	outputDirectory.resolve(fileName);	×
328
329	writeFile(content, outputFile);	×
330	}	×
331
332	@Override
333	protected void prepareWorkingCopy(TemplateContext props, Path directory, Distribution distribution) throws IOException {
334	Path packageDirectory = props.get(KEY_DISTRIBUTION_PACKAGE_DIRECTORY);	×
335
336	List<JibSpec> activeSpecs = packager.getActiveSpecs();	×
337
338	if (activeSpecs.isEmpty()) {	×
339	for (String imageName : packager.getImageNames()) {	×
NEW 340	copyJibfiles(packageDirectory, resolveTemplate(context.getLogger(), imageName, props), directory, false);	×
341	}	×
342	} else {
343	// copy files that do not belong to specs
344	prepareWorkingCopy(packageDirectory.resolve(ROOT), directory);	×
345
346	for (JibSpec spec : activeSpecs) {	×
347	TemplateContext newProps = fillSpecProps(distribution, props, spec);	×
348	for (String imageName : spec.getImageNames()) {	×
NEW 349	copyJibfiles(packageDirectory.resolve(spec.getName()), resolveTemplate(context.getLogger(), imageName, newProps), directory, true);	×
350	}	×
351	}	×
352	}
353	}	×
354
355	private void copyJibfiles(Path source, String imageName, Path directory, boolean isSpec) throws IOException {
356	Path destination = directory;	×
357
358	String[] parts = imageName.split("/");	×
359	parts = parts[parts.length - 1].split(":");	×
360	if (isSpec) {	×
361	destination = directory.resolve(parts[0]);	×
362	}
363
364	if (packager.getPackagerRepository().isVersionedSubfolders()) {	×
365	destination = directory.resolve(parts[1]);	×
366	}
367
368	Path assembly = destination.resolve("assembly");	×
369	FileUtils.deleteFiles(assembly);	×
370
371	Files.createDirectories(destination);	×
372	prepareWorkingCopy(source, destination, path -> "assembly".equals(path.getFileName().toString()));	×
373	}	×
374	}

jreleaser / jreleaser / #558

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