Examples with RB org.jreleaser.bundle.RB used on opensource projects

Example 1 with RB

use of org.jreleaser.bundle.RB in project jreleaser by jreleaser.

the class Uploaders method upload.

public static void upload(JReleaserContext context) {
    Upload upload = context.getModel().getUpload();
    if (!upload.isEnabled()) {
        context.getLogger().info(RB.$("uploaders.not.enabled"));
        return;
    }
    if (!context.getIncludedUploaderTypes().isEmpty()) {
        for (String uploaderType : context.getIncludedUploaderTypes()) {
            // check if the uploaderType is valid
            if (!Upload.supportedUploaders().contains(uploaderType)) {
                context.getLogger().warn(RB.$("ERROR_unsupported_uploader", uploaderType));
                continue;
            }
            Map<String, Uploader> uploaders = upload.findUploadersByType(uploaderType);
            if (uploaders.isEmpty()) {
                context.getLogger().debug(RB.$("uploaders.no.match"), uploaderType);
                return;
            }
            if (!context.getIncludedUploaderNames().isEmpty()) {
                for (String uploaderName : context.getIncludedUploaderNames()) {
                    if (!uploaders.containsKey(uploaderName)) {
                        context.getLogger().warn(RB.$("uploaders.uploader.not.configured"), uploaderType, uploaderName);
                        continue;
                    }
                    Uploader uploader = uploaders.get(uploaderName);
                    if (!uploader.isEnabled()) {
                        context.getLogger().info(RB.$("uploaders.uploader.disabled"), uploaderType, uploaderName);
                        continue;
                    }
                    context.getLogger().info(RB.$("uploaders.upload.with"), uploaderType, uploaderName);
                    upload(context, uploader);
                }
            } else {
                context.getLogger().info(RB.$("uploaders.upload.all.artifacts.with"), uploaderType);
                uploaders.values().forEach(uploader -> upload(context, uploader));
            }
        }
    } else if (!context.getIncludedUploaderNames().isEmpty()) {
        for (String uploaderName : context.getIncludedUploaderNames()) {
            List<Uploader> filteredUploaders = upload.findAllActiveUploaders().stream().filter(a -> uploaderName.equals(a.getName())).collect(toList());
            if (!filteredUploaders.isEmpty()) {
                context.getLogger().info(RB.$("uploaders.upload.all.artifacts.to"), uploaderName);
                filteredUploaders.forEach(uploader -> upload(context, uploader));
            } else {
                context.getLogger().warn(RB.$("uploaders.uploader.not.configured2"), uploaderName);
            }
        }
    } else {
        context.getLogger().info(RB.$("uploaders.upload.all.artifacts"));
        for (Uploader uploader : upload.findAllActiveUploaders()) {
            String uploaderType = uploader.getType();
            String uploaderName = uploader.getName();
            if (context.getExcludedUploaderTypes().contains(uploaderType) || context.getExcludedUploaderNames().contains(uploaderName)) {
                context.getLogger().info(RB.$("uploaders.uploader.excluded"), uploaderType, uploaderName);
                continue;
            }
            upload(context, uploader);
        }
    }
}

Example 2 with RB

use of org.jreleaser.bundle.RB in project jreleaser by jreleaser.

the class DistributionsValidator method validateDistribution.

private static void validateDistribution(JReleaserContext context, Distribution distribution, Errors errors) {
    context.getLogger().debug("distribution.{}", distribution.getName());
    if (!distribution.isActiveSet()) {
        distribution.setActive(Active.ALWAYS);
    }
    if (!distribution.resolveEnabled(context.getModel().getProject()))
        return;
    if (!selectArtifactsByPlatform(context, distribution)) {
        distribution.setActive(Active.NEVER);
        distribution.disable();
        return;
    }
    if (isBlank(distribution.getName())) {
        errors.configuration(RB.$("validation_must_not_be_blank", "distribution.name"));
        return;
    }
    if (null == distribution.getType()) {
        errors.configuration(RB.$("validation_must_not_be_null", "distribution." + distribution.getName() + ".type"));
        return;
    }
    if (isBlank(distribution.getExecutable().getName())) {
        distribution.getExecutable().setName(distribution.getName());
    }
    if (isBlank(distribution.getExecutable().getWindowsExtension())) {
        switch(distribution.getType()) {
            case BINARY:
            case NATIVE_IMAGE:
                distribution.getExecutable().setWindowsExtension("exe");
                break;
            default:
                distribution.getExecutable().setWindowsExtension("bat");
        }
    }
    if (Distribution.JAVA_DISTRIBUTION_TYPES.contains(distribution.getType())) {
        context.getLogger().debug("distribution.{}.java", distribution.getName());
        if (!validateJava(context, distribution, errors)) {
            return;
        }
    }
    // validate distribution type
    if (!distribution.getJava().isEnabled() && Distribution.JAVA_DISTRIBUTION_TYPES.contains(distribution.getType())) {
        errors.configuration(RB.$("validation_distributions_java", "distribution." + distribution.getName() + ".type", distribution.getType(), "distribution." + distribution.getName() + ".java", "project.java"));
        return;
    }
    if (null == distribution.getArtifacts() || distribution.getArtifacts().isEmpty()) {
        errors.configuration(RB.$("validation_is_empty", "distribution." + distribution.getName() + ".artifacts"));
        return;
    }
    List<String> tags = new ArrayList<>();
    tags.addAll(context.getModel().getProject().getTags());
    tags.addAll(distribution.getTags());
    distribution.setTags(tags);
    int i = 0;
    for (Artifact artifact : distribution.getArtifacts()) {
        if (artifact.isActive()) {
            validateArtifact(context, distribution, artifact, i++, errors);
            if (distribution.getExtraProperties().containsKey(KEY_SKIP_RELEASE_SIGNATURES) && !artifact.getExtraProperties().containsKey(KEY_SKIP_RELEASE_SIGNATURES)) {
                artifact.getExtraProperties().put(KEY_SKIP_RELEASE_SIGNATURES, distribution.getExtraProperties().get(KEY_SKIP_RELEASE_SIGNATURES));
            }
        }
    }
    // validate artifact.platform is unique
    Map<String, List<Artifact>> byPlatform = distribution.getArtifacts().stream().filter(Artifact::isActive).collect(groupingBy(artifact -> isBlank(artifact.getPlatform()) ? "<nil>" : artifact.getPlatform()));
    // check platforms by extension
    byPlatform.forEach((p, artifacts) -> {
        String platform = "<nil>".equals(p) ? "no" : p;
        artifacts.stream().collect(groupingBy(artifact -> FileType.getFileType(artifact.getPath()))).forEach((ext, matches) -> {
            if (matches.size() > 1) {
                errors.configuration(RB.$("validation_distributions_multiple", "distribution." + distribution.getName(), platform, ext));
            }
        });
    });
    validateBrew(context, distribution, distribution.getBrew(), errors);
    validateChocolatey(context, distribution, distribution.getChocolatey(), errors);
    validateDocker(context, distribution, distribution.getDocker(), errors);
    validateGofish(context, distribution, distribution.getGofish(), errors);
    validateJbang(context, distribution, distribution.getJbang(), errors);
    validateMacports(context, distribution, distribution.getMacports(), errors);
    validateScoop(context, distribution, distribution.getScoop(), errors);
    validateSdkman(context, distribution, distribution.getSdkman(), errors);
    validateSnap(context, distribution, distribution.getSnap(), errors);
    validateSpec(context, distribution, distribution.getSpec(), errors);
}

Example 3 with RB

use of org.jreleaser.bundle.RB in project jreleaser by jreleaser.

the class JpackageValidator method validateJpackage.

private static void validateJpackage(JReleaserContext context, JReleaserContext.Mode mode, Jpackage jpackage, Errors errors) {
    context.getLogger().debug("jpackage.{}", jpackage.getName());
    if (!jpackage.isActiveSet()) {
        jpackage.setActive(Active.NEVER);
    }
    Project project = context.getModel().getProject();
    if (!jpackage.resolveEnabled(project))
        return;
    Jpackage.PlatformPackager packager = jpackage.getResolvedPlatformPackager();
    Jpackage.ApplicationPackage applicationPackage = jpackage.getApplicationPackage();
    packager.enable();
    if (isNotBlank(jpackage.getJlink())) {
        Jlink jlink = context.getModel().getAssemble().findJlink(jpackage.getJlink());
        Path baseOutputDirectory = context.getAssembleDirectory().resolve(jlink.getName()).resolve(jlink.getType());
        String imageName = jlink.getResolvedImageName(context);
        List<Artifact> candidateRuntimeImages = new ArrayList<>();
        for (Artifact targetJdk : jlink.getTargetJdks()) {
            if (!context.isPlatformSelected(targetJdk))
                continue;
            String platform = targetJdk.getPlatform();
            Path path = baseOutputDirectory.resolve("work-" + platform).resolve(imageName + "-" + platform).toAbsolutePath();
            candidateRuntimeImages.add(Artifact.of(path, platform));
        }
        if (jpackage.getRuntimeImages().size() > 0 && jpackage.getRuntimeImages().size() != candidateRuntimeImages.size()) {
            errors.configuration(RB.$("validation_jpackage_jlink_application", jpackage.getName()));
        }
        int count = 0;
        for (Artifact runtimeImage : jpackage.getRuntimeImages()) {
            Path rp = runtimeImage.getResolvedPath(context, jpackage);
            Path tp = runtimeImage.getResolvedTransform(context, jpackage);
            Path path = tp != null ? tp : rp;
            if (candidateRuntimeImages.stream().anyMatch(a -> a.getPath().equals(path.toString()))) {
                count++;
            }
        }
        if (jpackage.getRuntimeImages().size() > 0 && count != candidateRuntimeImages.size()) {
            errors.configuration(RB.$("validation_jpackage_jlink_application", jpackage.getName()));
        }
        jpackage.setJava(jlink.getJava());
        jpackage.setMainJar(jlink.getMainJar());
        jpackage.setJars(jlink.getJars());
        packager.setJdk(jlink.getJdk());
        if (isBlank(jpackage.getExecutable())) {
            jpackage.setExecutable(jlink.getExecutable());
        }
        for (Artifact runtimeImage : candidateRuntimeImages) {
            runtimeImage.activate();
            jpackage.addRuntimeImage(runtimeImage);
        }
    }
    context.getLogger().debug("jpackage.{}.java", jpackage.getName());
    if (!validateJava(context, jpackage, errors)) {
        return;
    }
    if (isBlank(jpackage.getExecutable())) {
        jpackage.setExecutable(jpackage.getName());
    }
    if (jpackage.getRuntimeImages().size() == 0) {
        errors.configuration(RB.$("validation_jpackage_runtime_images_missing", jpackage.getName()));
        return;
    }
    int i = 0;
    for (Artifact runtimeImage : jpackage.getRuntimeImages()) {
        validateRuntimeImage(context, mode, jpackage, runtimeImage, i++, errors);
    }
    // validate jdks.platform is unique
    Map<String, List<Artifact>> byPlatform = jpackage.getRuntimeImages().stream().collect(groupingBy(ri -> isBlank(ri.getPlatform()) ? "<nil>" : ri.getPlatform()));
    if (byPlatform.containsKey("<nil>")) {
        errors.configuration(RB.$("validation_jpackage_runtime_image_platform", jpackage.getName()));
    }
    // check platforms
    byPlatform.forEach((p, jdks) -> {
        if (jdks.size() > 1) {
            errors.configuration(RB.$("validation_jpackage_runtime_image_multiple_platforms", jpackage.getName(), p));
        }
    });
    if (isBlank(packager.getJdk().getPath())) {
        String javaHome = System.getProperty("java.home");
        if (isBlank(javaHome)) {
            // Can only happen when running as native-image, fail for now
            // TODO: native-image
            errors.configuration(RB.$("validation_java_home_missing"));
            return;
        }
        packager.getJdk().setPath(javaHome);
        packager.getJdk().setPlatform(PlatformUtils.getCurrentFull());
    }
    if (packager.getTypes().isEmpty()) {
        packager.setTypes(singletonList(packager.getValidTypes().get(0)));
    }
    if (isBlank(applicationPackage.getAppName())) {
        applicationPackage.setAppName(jpackage.getName());
    }
    if (isBlank(applicationPackage.getAppVersion())) {
        applicationPackage.setAppVersion(project.getResolvedVersion());
    }
    // validate appVersion
    String appVersion = applicationPackage.getResolvedAppVersion(context, jpackage);
    try {
        SemVer v = SemVer.of(appVersion);
        if (isNotBlank(v.getBuild()) && isNotBlank(v.getTag()) && v.getMajor() <= 0) {
            errors.configuration(RB.$("validation_jpackage_invalid_appversion", appVersion));
        }
    } catch (IllegalArgumentException e) {
        // can't use this value
        errors.configuration(RB.$("validation_jpackage_invalid_appversion", appVersion));
    }
    if (isBlank(applicationPackage.getVendor())) {
        applicationPackage.setVendor(project.getVendor());
    }
    if (isBlank(applicationPackage.getVendor())) {
        errors.configuration(RB.$("validation_jpackage_missing_vendor", jpackage.getName()));
    }
    if (isBlank(applicationPackage.getCopyright())) {
        applicationPackage.setCopyright(project.getCopyright());
    }
    if (mode == JReleaserContext.Mode.ASSEMBLE) {
        validateTemplate(context, jpackage, errors);
    }
    if (isBlank(packager.getAppName())) {
        packager.setAppName(jpackage.getApplicationPackage().getAppName());
    }
    if (packager instanceof Jpackage.Linux) {
        validateLinux(context, jpackage, (Jpackage.Linux) packager, errors);
    }
    if (packager instanceof Jpackage.Osx) {
        validateOsx(context, jpackage, (Jpackage.Osx) packager, errors);
    }
    if (packager instanceof Jpackage.Windows) {
        validateWindows(context, jpackage, (Jpackage.Windows) packager, errors);
    }
}

Example 4 with RB

use of org.jreleaser.bundle.RB in project jreleaser by jreleaser.

the class NativeImageValidator method validateNativeImage.

private static void validateNativeImage(JReleaserContext context, JReleaserContext.Mode mode, NativeImage nativeImage, Errors errors) {
    context.getLogger().debug("nativeImage.{}", nativeImage.getName());
    if (!nativeImage.isActiveSet()) {
        nativeImage.setActive(Active.NEVER);
    }
    if (!nativeImage.resolveEnabled(context.getModel().getProject()))
        return;
    if (isBlank(nativeImage.getName())) {
        errors.configuration(RB.$("validation_must_not_be_blank", "nativeImage.name"));
        return;
    }
    if (null == nativeImage.getMainJar()) {
        errors.configuration(RB.$("validation_is_null", "nativeImage." + nativeImage.getName() + ".mainJar"));
        return;
    }
    Platform platform = nativeImage.getPlatform().merge(context.getModel().getPlatform());
    nativeImage.setPlatform(platform);
    if (isBlank(nativeImage.getExecutable())) {
        nativeImage.setExecutable(nativeImage.getName());
    }
    if (isBlank(nativeImage.getImageName())) {
        nativeImage.setImageName(nativeImage.getExecutable() + "-" + context.getModel().getProject().getResolvedVersion());
    }
    int i = 0;
    for (Artifact graalJdk : nativeImage.getGraalJdks()) {
        validateJdk(context, mode, nativeImage, graalJdk, i++, errors);
    }
    // validate jdks.platform is unique
    Map<String, List<Artifact>> byPlatform = nativeImage.getGraalJdks().stream().collect(groupingBy(jdk -> isBlank(jdk.getPlatform()) ? "<nil>" : jdk.getPlatform()));
    if (byPlatform.containsKey("<nil>")) {
        errors.configuration(RB.$("validation_nativeimage_jdk_platform", nativeImage.getName()));
    }
    // check platforms
    byPlatform.forEach((p, jdks) -> {
        if (jdks.size() > 1) {
            errors.configuration(RB.$("validation_nativeimage_jdk_multiple_platforms", nativeImage.getName(), p));
        }
    });
    if (isBlank(nativeImage.getGraal().getPath())) {
        String currentPlatform = PlatformUtils.getCurrentFull();
        String javaHome = System.getProperty("java.home");
        if (nativeImage.getGraalJdks().isEmpty()) {
            if (isBlank(javaHome)) {
                // Can only happen when running as native-image, fail for now
                // TODO: native-image
                errors.configuration(RB.$("validation_java_home_missing"));
                return;
            }
            // Use current
            nativeImage.getGraal().setPath(javaHome);
            nativeImage.getGraal().setPlatform(currentPlatform);
        } else {
            // find a compatible JDK in targets
            Optional<Artifact> jdk = nativeImage.getGraalJdks().stream().filter(j -> PlatformUtils.isCompatible(currentPlatform, j.getPlatform())).findFirst();
            if (jdk.isPresent()) {
                nativeImage.setGraal(jdk.get());
            } else {
                if (isBlank(javaHome)) {
                    // Can only happen when running as native-image, fail for now
                    // TODO: native-image
                    errors.configuration(RB.$("validation_java_home_missing"));
                    return;
                }
                // Can't tell if the current JDK will work but might as well use it
                nativeImage.getGraal().setPath(javaHome);
                nativeImage.getGraal().setPlatform(currentPlatform);
            }
        }
    }
    if (isBlank(nativeImage.getMainJar().getPath())) {
        errors.configuration(RB.$("validation_must_not_be_null", "nativeImage." + nativeImage.getName() + ".mainJar.path"));
    }
    if (null == nativeImage.getArchiveFormat()) {
        nativeImage.setArchiveFormat(Archive.Format.ZIP);
    }
    validateGlobs(context, nativeImage.getJars(), "nativeImage." + nativeImage.getName() + ".jars", errors);
    if (mode == JReleaserContext.Mode.ASSEMBLE) {
        validateTemplate(context, nativeImage, errors);
    }
    if (!nativeImage.getFileSets().isEmpty()) {
        i = 0;
        for (FileSet fileSet : nativeImage.getFileSets()) {
            validateFileSet(context, mode, nativeImage, fileSet, i++, errors);
        }
    }
    NativeImage.Upx upx = nativeImage.getUpx();
    if (!upx.isActiveSet()) {
        upx.setActive(Active.NEVER);
    }
    if (!upx.resolveEnabled(context.getModel().getProject()))
        return;
    if (isBlank(upx.getVersion())) {
        errors.configuration(RB.$("validation_is_missing", "nativeImage." + nativeImage.getName() + ".upx.version"));
    }
}

Example 5 with RB

use of org.jreleaser.bundle.RB in project jreleaser by jreleaser.

the class AbstractJavaAssemblerProcessor method copyFiles.

protected Set<Path> copyFiles(JReleaserContext context, Path destination) throws AssemblerProcessingException {
    Set<Path> paths = new LinkedHashSet<>();
    // resolve all first
    for (Glob glob : assembler.getFiles()) {
        glob.getResolvedArtifacts(context).stream().map(artifact -> artifact.getResolvedPath(context, assembler)).forEach(paths::add);
    }
    // copy all next
    try {
        Files.createDirectories(destination);
        for (Path path : paths) {
            context.getLogger().debug(RB.$("assembler.copying"), path.getFileName());
            Files.copy(path, destination.resolve(path.getFileName()), REPLACE_EXISTING);
        }
    } catch (IOException e) {
        throw new AssemblerProcessingException(RB.$("ERROR_assembler_copying_files"), e);
    }
    return paths;
}