From f68f5fb24f0fe69b45bf7286b222f448d26b2fac Mon Sep 17 00:00:00 2001
From: Stephen Connolly <stephen.alan.connolly@gmail.com>
Date: Tue, 8 Mar 2016 23:05:00 +0000
Subject: [PATCH] [FIXED JENKINS-33414] Added an API to allow identification of
 the Jenkins JVM

- Fix the ProxyConfiguration code to not require Jenkins class to be loaded in remote JVMs
---
 .../main/java/hudson/ProxyConfiguration.java  | 35 +++++++--
 core/src/main/java/hudson/WebAppMain.java     | 35 ++++++---
 .../main/java/jenkins/util/JenkinsJVM.java    | 73 +++++++++++++++++++
 .../java/jenkins/util/JenkinsJVMTest.java     | 36 +++++++++
 4 files changed, 159 insertions(+), 20 deletions(-)
 create mode 100644 core/src/main/java/jenkins/util/JenkinsJVM.java
 create mode 100644 core/src/test/java/jenkins/util/JenkinsJVMTest.java

diff --git a/core/src/main/java/hudson/ProxyConfiguration.java b/core/src/main/java/hudson/ProxyConfiguration.java
index 9b51990925..e3c42b09f5 100644
--- a/core/src/main/java/hudson/ProxyConfiguration.java
+++ b/core/src/main/java/hudson/ProxyConfiguration.java
@@ -47,7 +47,9 @@ import java.net.URLConnection;
 import java.util.Collections;
 import java.util.List;
 import java.util.regex.Pattern;
+import javax.annotation.CheckForNull;
 import jenkins.model.Jenkins;
+import jenkins.util.JenkinsJVM;
 import org.apache.commons.httpclient.Credentials;
 import org.apache.commons.httpclient.HttpClient;
 import org.apache.commons.httpclient.UsernamePasswordCredentials;
@@ -215,8 +217,7 @@ public final class ProxyConfiguration extends AbstractDescribableImpl<ProxyConfi
      * This method should be used wherever {@link URL#openConnection()} to internet URLs is invoked directly.
      */
     public static URLConnection open(URL url) throws IOException {
-        Jenkins h = Jenkins.getInstance(); // this code might run on slaves
-        ProxyConfiguration p = h!=null ? h.proxy : null;
+        final ProxyConfiguration p = get();
         if(p==null)
             return url.openConnection();
 
@@ -227,22 +228,21 @@ public final class ProxyConfiguration extends AbstractDescribableImpl<ProxyConfi
                 @Override
                 public PasswordAuthentication getPasswordAuthentication() {
                     if (getRequestorType()!=RequestorType.PROXY)    return null;
-                    ProxyConfiguration p = Jenkins.getInstance().proxy;
                     return new PasswordAuthentication(p.getUserName(),
                             p.getPassword().toCharArray());
                 }
             });
         }
 
-        for (URLConnectionDecorator d : URLConnectionDecorator.all())
-            d.decorate(con);
+        if (JenkinsJVM.isJenkinsJVM()) { // this code may run on a slave
+            decorate(con);
+        }
 
         return con;
     }
-    
+
     public static InputStream getInputStream(URL url) throws IOException {
-        Jenkins h = Jenkins.getInstance(); // this code might run on slaves
-        final ProxyConfiguration p = (h != null) ? h.proxy : null;
+        final ProxyConfiguration p = get();
         if (p == null) 
             return new RetryableHttpStream(url);
 
@@ -264,6 +264,25 @@ public final class ProxyConfiguration extends AbstractDescribableImpl<ProxyConfi
         return is;
     }
 
+    @CheckForNull
+    private static ProxyConfiguration get() {
+        if (JenkinsJVM.isJenkinsJVM()) {
+            return _get();
+        }
+        return null;
+    }
+
+    @CheckForNull
+    private static ProxyConfiguration _get() {
+        JenkinsJVM.checkJenkinsJVM();
+        return Jenkins.getInstance().proxy;
+    }
+
+    private static void decorate(URLConnection con) throws IOException {
+        for (URLConnectionDecorator d : URLConnectionDecorator.all())
+            d.decorate(con);
+    }
+
     private static final XStream XSTREAM = new XStream2();
 
     private static final long serialVersionUID = 1L;
diff --git a/core/src/main/java/hudson/WebAppMain.java b/core/src/main/java/hudson/WebAppMain.java
index d3375be646..ca3fccbda6 100644
--- a/core/src/main/java/hudson/WebAppMain.java
+++ b/core/src/main/java/hudson/WebAppMain.java
@@ -40,6 +40,7 @@ import hudson.util.IncompatibleAntVersionDetected;
 import hudson.util.HudsonFailedToLoad;
 import hudson.util.ChartUtil;
 import hudson.util.AWTProblem;
+import jenkins.util.JenkinsJVM;
 import org.jvnet.localizer.LocaleProvider;
 import org.kohsuke.stapler.jelly.JellyFacet;
 import org.apache.tools.ant.types.FileSet;
@@ -89,6 +90,7 @@ public class WebAppMain implements ServletContextListener {
      * Creates the sole instance of {@link jenkins.model.Jenkins} and register it to the {@link ServletContext}.
      */
     public void contextInitialized(ServletContextEvent event) {
+        JenkinsJVMAccess._setJenkinsJVM(true);
         final ServletContext context = event.getServletContext();
         File home=null;
         try {
@@ -391,23 +393,32 @@ public class WebAppMain implements ServletContextListener {
     }
 
     public void contextDestroyed(ServletContextEvent event) {
-        terminated = true;
-        Jenkins instance = Jenkins.getInstance();
-        if(instance!=null)
-            instance.cleanUp();
-        Thread t = initThread;
-        if (t != null && t.isAlive()) {
-            LOGGER.log(Level.INFO, "Shutting down a Jenkins instance that was still starting up", new Throwable("reason"));
-            t.interrupt();
-        }
+        try {
+            terminated = true;
+            Jenkins instance = Jenkins.getInstance();
+            if(instance!=null)
+                instance.cleanUp();
+            Thread t = initThread;
+            if (t != null && t.isAlive()) {
+                LOGGER.log(Level.INFO, "Shutting down a Jenkins instance that was still starting up", new Throwable("reason"));
+                t.interrupt();
+            }
 
-        // Logger is in the system classloader, so if we don't do this
-        // the whole web app will never be undepoyed.
-        Logger.getLogger("").removeHandler(handler);
+            // Logger is in the system classloader, so if we don't do this
+            // the whole web app will never be undepoyed.
+            Logger.getLogger("").removeHandler(handler);
+        } finally {
+            JenkinsJVMAccess._setJenkinsJVM(false);
+        }
     }
 
     private static final Logger LOGGER = Logger.getLogger(WebAppMain.class.getName());
 
+    private static final class JenkinsJVMAccess extends JenkinsJVM {
+        private static void _setJenkinsJVM(boolean jenkinsJVM) {
+            JenkinsJVM.setJenkinsJVM(jenkinsJVM);
+        }
+    }
 
     private static final String[] HOME_NAMES = {"JENKINS_HOME","HUDSON_HOME"};
 }
diff --git a/core/src/main/java/jenkins/util/JenkinsJVM.java b/core/src/main/java/jenkins/util/JenkinsJVM.java
new file mode 100644
index 0000000000..6479e9b70d
--- /dev/null
+++ b/core/src/main/java/jenkins/util/JenkinsJVM.java
@@ -0,0 +1,73 @@
+package jenkins.util;
+
+import hudson.WebAppMain;
+import javax.servlet.ServletContextEvent;
+import jenkins.model.Jenkins;
+import org.kohsuke.accmod.Restricted;
+import org.kohsuke.accmod.restrictions.NoExternalUse;
+
+/**
+ * A utility class to identify if the current JVM is the one that is running {@link Jenkins}
+ *
+ * @since TODO
+ */
+public class JenkinsJVM {
+    /**
+     * Flag to identify the JVM running {@link Jenkins}.
+     */
+    private static boolean jenkinsJVM;
+
+    /**
+     * Protect against people instantiating this class.
+     */
+    @Restricted(NoExternalUse.class)
+    protected JenkinsJVM() {
+        throw new IllegalAccessError("Utility class");
+    }
+
+    /**
+     * Identify whether the classloader that loaded this class is the classloader from which {@link Jenkins} has been
+     * started.
+     *
+     * @return {@code true} if this is the classloader on the JVM that started {@link Jenkins} otherwise {@code false}
+     */
+    public static boolean isJenkinsJVM() {
+        return jenkinsJVM;
+    }
+
+    /**
+     * Verify that the classloader that loaded this class is the classloader from which {@link Jenkins} has been
+     * started.
+     *
+     * @throws IllegalArgumentException if this is not the classloader on the JVM that started {@link Jenkins}.
+     */
+    public static void checkJenkinsJVM() {
+        if (!isJenkinsJVM()) {
+            throw new IllegalStateException("Not running on the Jenkins master JVM");
+        }
+    }
+
+    /**
+     * Verify that the classloader that loaded this class is not the classloader from which {@link Jenkins} has been
+     * started.
+     *
+     * @throws IllegalArgumentException if this is the classloader on the JVM that started {@link Jenkins}.
+     */
+    public static void checkNotJenkinsJVM() {
+        if (isJenkinsJVM()) {
+            throw new IllegalStateException("Running on the Jenkins master JVM");
+        }
+    }
+
+    /**
+     * Used by {@link WebAppMain#contextInitialized(ServletContextEvent)} and
+     * {@link WebAppMain#contextDestroyed(ServletContextEvent)} to identify the classloader and JVM which started
+     * {@link Jenkins}
+     *
+     * @param jenkinsJVM {@code true} if and only if this is the classloader and JVM that started {@link Jenkins}.
+     */
+    @Restricted(NoExternalUse.class)
+    protected static void setJenkinsJVM(boolean jenkinsJVM) {
+        JenkinsJVM.jenkinsJVM = jenkinsJVM;
+    }
+}
diff --git a/core/src/test/java/jenkins/util/JenkinsJVMTest.java b/core/src/test/java/jenkins/util/JenkinsJVMTest.java
new file mode 100644
index 0000000000..8921deb661
--- /dev/null
+++ b/core/src/test/java/jenkins/util/JenkinsJVMTest.java
@@ -0,0 +1,36 @@
+package jenkins.util;
+
+import org.junit.Test;
+
+public class JenkinsJVMTest {
+
+    @Test
+    public void checkNotJenkinsJVM_WhenNotInAJenkinsJVM() {
+        JenkinsJVM.checkNotJenkinsJVM();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void checkJenkinsJVM_WhenNotInAJenkinsJVM() {
+        JenkinsJVM.checkJenkinsJVM();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void checkNotJenkinsJVM_WhenInAJenkinsJVM() {
+        JenkinsJVM.setJenkinsJVM(true);
+        try {
+            JenkinsJVM.checkNotJenkinsJVM();
+        } finally {
+            JenkinsJVM.setJenkinsJVM(false);
+        }
+    }
+
+    @Test
+    public void checkJenkinsJVM_WhenInAJenkinsJVM() {
+        JenkinsJVM.setJenkinsJVM(true);
+        try {
+            JenkinsJVM.checkJenkinsJVM();
+        } finally {
+            JenkinsJVM.setJenkinsJVM(false);
+        }
+    }
+}