[JENKINS-48766] - Make the RemotingVersionInfo API publicly available

core/src/main/java/jenkins/MasterToSlaveFileCallable.java

@@ -1,12 +1,19 @@
package jenkins;

import hudson.FilePath.FileCallable;
import hudson.remoting.VirtualChannel;
import jenkins.security.Roles;
import jenkins.slaves.RemotingVersionInfo;
import org.jenkinsci.remoting.RoleChecker;

import java.io.File;

/**
 * {@link FileCallable}s that are meant to be only used on the master.
 *
 * Note that the logic within {@link #invoke(File, VirtualChannel)} should use API of a minimum supported Remoting version.
 * See {@link RemotingVersionInfo#getMinimumSupportedVersion()}.
 *
 * @since 1.587 / 1.580.1
 * @param <T> the return type; note that this must either be defined in your plugin or included in the stock JEP-200 whitelist
 */

core/src/main/java/jenkins/security/MasterToSlaveCallable.java

@@ -3,6 +3,7 @@
import hudson.remoting.Callable;
import hudson.remoting.Channel;
import hudson.remoting.ChannelClosedException;
import jenkins.slaves.RemotingVersionInfo;
import org.jenkinsci.remoting.RoleChecker;
import org.kohsuke.accmod.Restricted;
import org.kohsuke.accmod.restrictions.NoExternalUse;
@@ -11,6 +12,9 @@
/**
 * Convenient {@link Callable} meant to be run on agent.
 *
 * Note that the logic within {@link #call()} should use API of a minimum supported Remoting version.
 * See {@link RemotingVersionInfo#getMinimumSupportedVersion()}.
 *
 * @author Kohsuke Kawaguchi
 * @since 1.587 / 1.580.1
 * @param <V> the return type; note that this must either be defined in your plugin or included in the stock JEP-200 whitelist

core/src/main/java/jenkins/slaves/RemotingVersionInfo.java

@@ -24,10 +24,7 @@
package jenkins.slaves;

import hudson.util.VersionNumber;
import org.kohsuke.accmod.Restricted;
import org.kohsuke.accmod.restrictions.NoExternalUse;

import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
import java.io.IOException;
import java.io.InputStream;
@@ -39,17 +36,17 @@
/**
 * Provides information about Remoting versions used within the core.
 * @author Oleg Nenashev
 * @since TODO
 */
@Restricted(NoExternalUse.class)
public class RemotingVersionInfo {

    private static final Logger LOGGER = Logger.getLogger(RemotingVersionInfo.class.getName());
    private static final String RESOURCE_NAME="remoting-info.properties";

    @CheckForNull
    @Nonnull
    private static VersionNumber EMBEDDED_VERSION;

    @CheckForNull
    @Nonnull
    private static VersionNumber MINIMUM_SUPPORTED_VERSION;

    private RemotingVersionInfo() {}
@@ -64,39 +61,53 @@ private RemotingVersionInfo() {}
            LOGGER.log(Level.WARNING, "Failed to load Remoting Info from " + RESOURCE_NAME, e);
        }

        EMBEDDED_VERSION = tryExtractVersion(props, "remoting.embedded.version");
        MINIMUM_SUPPORTED_VERSION = tryExtractVersion(props, "remoting.minimum.supported.version");
        EMBEDDED_VERSION = extractVersion(props, "remoting.embedded.version");
        MINIMUM_SUPPORTED_VERSION = extractVersion(props, "remoting.minimum.supported.version");
    }

    @CheckForNull
    private static VersionNumber tryExtractVersion(@Nonnull Properties props, @Nonnull String propertyName) {
    @Nonnull
    private static VersionNumber extractVersion(@Nonnull Properties props, @Nonnull String propertyName)
            throws ExceptionInInitializerError {
        String prop = props.getProperty(propertyName);
        if (prop == null) {
            LOGGER.log(Level.FINE, "Property {0} is not defined in {1}", new Object[] {propertyName, RESOURCE_NAME});
            return null;
            throw new ExceptionInInitializerError(String.format(
                    "Property %s is not defined in %s", propertyName, RESOURCE_NAME));
        }

        if(prop.contains("${")) { // Due to whatever reason, Maven does not nullify them
            LOGGER.log(Level.WARNING, "Property {0} in {1} has unresolved variable(s). Raw value: {2}",
                    new Object[] {propertyName, RESOURCE_NAME, prop});
            return null;
            throw new ExceptionInInitializerError(String.format(
                    "Property %s in %s has unresolved variable(s). Raw value: %s",
                    propertyName, RESOURCE_NAME, prop));
        }

        try {
            return new VersionNumber(prop);
        } catch (RuntimeException ex) {
            LOGGER.log(Level.WARNING, String.format("Failed to parse version for for property %s in %s. Raw Value: %s",
                    propertyName, RESOURCE_NAME, prop), ex);
            return null;
            throw new ExceptionInInitializerError(new IOException(
                    String.format("Failed to parse version for for property %s in %s. Raw Value: %s",
                    propertyName, RESOURCE_NAME, prop), ex));
        }
    }

    @CheckForNull
    /**
     * Returns a version which is embedded into the Jenkins core.
     * Note that this version <b>may</b> differ from one which is being really used in Jenkins.
     * @return Remoting version
     */
    @Nonnull
    public static VersionNumber getEmbeddedVersion() {
        return EMBEDDED_VERSION;
    }

    @CheckForNull
    /**
     * Gets Remoting version which is supported by the core.
     * Jenkins core and plugins make invoke operations on agents (e.g. {@link jenkins.security.MasterToSlaveCallable})
     * and use Remoting-internal API within them.
     * In such case this API should be present on the remote side.
     * This method defines a minimum expected version, so that all calls should use a compatible API.
     * @return Minimal Remoting version for API calls.
     */
    @Nonnull
    public static VersionNumber getMinimumSupportedVersion() {
        return MINIMUM_SUPPORTED_VERSION;
    }