Add remote host binding for JenkinsRule

The reason for this change is that the JenkinRule based tests were all running
inside a docker container and i needed a way to bind it a non localhost address
in order to access it from outside the running container.

The host binding for the JenkinsRule is configurable with the `host`
property. The default value is `localhost` this keeps the backward
compatibility.

The following code snippet shows how to bind the JenkinsRule instance
```
@rule public JenkinsRule j = new JenkinsRule() {{
    host = null;
  }
};
```
to all network interfaces. This is similar to set the `host` value to `0.0.0.0`.

The test case `JenkinsRuleHostIPTest` validates that the assignment to a specific
host ip address is working correctly.

The test case `JenkinsRuleAllHostInterfaceTest` validates that the assignment to all
network interfaces is working correctly.

Author: fr123k

src/main/java/jenkins/benchmark/jmh/JmhBenchmarkState.java

@@ -6,6 +6,7 @@
 import jenkins.model.Jenkins;
 import jenkins.model.JenkinsLocationConfiguration;
 import org.apache.commons.lang3.mutable.MutableInt;
+import org.apache.commons.lang3.mutable.MutableObject;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.eclipse.jetty.server.Server;
 import org.jvnet.hudson.test.JenkinsRule;
@@ -43,6 +44,7 @@ public abstract class JmhBenchmarkState implements RootAction {
 
     private final TemporaryDirectoryAllocator temporaryDirectoryAllocator = new TemporaryDirectoryAllocator();
     private final MutableInt localPort = new MutableInt();
+    private final MutableObject<String> host = new MutableObject<String>("localhost");
 
     private Jenkins jenkins = null;
     private Server server = null;
@@ -87,8 +89,8 @@ public final void terminateJenkins() {
     }
 
     private void launchInstance() throws Exception {
-        ImmutablePair<Server, ServletContext> results = JenkinsRule._createWebServer(contextPath, localPort::setValue,
-                getClass().getClassLoader(), localPort.getValue(), JenkinsRule::_configureUserRealm);
+        ImmutablePair<Server, ServletContext> results = JenkinsRule._createWebServer(contextPath, host::setValue, localPort::setValue,
+                getClass().getClassLoader(), host.getValue(), localPort.getValue(),JenkinsRule::_configureUserRealm);
 
         server = results.left;
         ServletContext webServer = results.right;
@@ -104,7 +106,7 @@ private void launchInstance() throws Exception {
     }
 
     private URL getJenkinsURL() throws MalformedURLException {
-        return new URL("http://localhost:" + localPort.getValue() + contextPath + "/");
+        return new URL("http://"+host.getValue()+":" + localPort.getValue() + contextPath + "/");
     }
 
     /**

src/main/java/org/jvnet/hudson/test/JenkinsRule.java

@@ -280,6 +280,10 @@ public class JenkinsRule implements TestRule, MethodRule, RootAction {
      * TCP/IP port that the server is listening on.
      */
     protected int localPort;
+    /**
+     * If null or 0.0.0.0, then bind to all interfaces.
+     */
+    protected String host = "localhost";
     protected Server server;
 
     /**
@@ -740,7 +744,7 @@ protected ServletContext createWebServer() throws Exception {
      */
     protected ServletContext createWebServer(@CheckForNull BiConsumer<WebAppContext, Server> contextAndServerConsumer) throws Exception {
         ImmutablePair<Server,  ServletContext> results = _createWebServer(contextPath,
-                (x) -> localPort = x, getClass().getClassLoader(), localPort, this::configureUserRealm, contextAndServerConsumer);
+                (x) -> host = x, (x) -> localPort = x, getClass().getClassLoader(), host, localPort, this::configureUserRealm, contextAndServerConsumer);
         server = results.left;
         LOGGER.log(Level.INFO, "Running on {0}", getURL());
         return results.right;
@@ -757,11 +761,11 @@ protected ServletContext createWebServer(@CheckForNull BiConsumer<WebAppContext,
      * @return ImmutablePair consisting of the {@link Server} and the {@link ServletContext}
      * @since 2.50
      */
-    public static ImmutablePair<Server, ServletContext> _createWebServer(String contextPath, Consumer<Integer> portSetter,
-                                                                         ClassLoader classLoader, int localPort,
+    public static ImmutablePair<Server, ServletContext> _createWebServer(String contextPath, Consumer<String> hostSetter, Consumer<Integer> portSetter,
+                                                                         ClassLoader classLoader, String host, int localPort,
                                                                          Supplier<LoginService> loginServiceSupplier)
             throws Exception {
-        return _createWebServer(contextPath, portSetter, classLoader, localPort, loginServiceSupplier, null);
+        return _createWebServer(contextPath, hostSetter, portSetter, classLoader, host, localPort, loginServiceSupplier, null);
     }
     /**
      * Creates a web server on which Jenkins can run
@@ -775,8 +779,8 @@ public static ImmutablePair<Server, ServletContext> _createWebServer(String cont
      * @return ImmutablePair consisting of the {@link Server} and the {@link ServletContext}
      * @since 2.50
      */
-    public static ImmutablePair<Server, ServletContext> _createWebServer(String contextPath, Consumer<Integer> portSetter,
-                                                                         ClassLoader classLoader, int localPort,
+    public static ImmutablePair<Server, ServletContext> _createWebServer(String contextPath, Consumer<String> hostSetter, Consumer<Integer> portSetter,
+                                                                         ClassLoader classLoader, String host, int localPort,
                                                                          Supplier<LoginService> loginServiceSupplier,
                                                                          @CheckForNull BiConsumer<WebAppContext, Server> contextAndServerConsumer)
             throws Exception {
@@ -797,7 +801,7 @@ public static ImmutablePair<Server, ServletContext> _createWebServer(String cont
         HttpConfiguration config = connector.getConnectionFactory(HttpConnectionFactory.class).getHttpConfiguration();
         // use a bigger buffer as Stapler traces can get pretty large on deeply nested URL
         config.setRequestHeaderSize(12 * 1024);
-        connector.setHost("localhost");
+        connector.setHost(host);
         if (System.getProperty("port") != null) {
             connector.setPort(Integer.parseInt(System.getProperty("port")));
         } else if (localPort != 0) {
@@ -810,6 +814,7 @@ public static ImmutablePair<Server, ServletContext> _createWebServer(String cont
         }
         server.start();
 
+        hostSetter.accept(connector.getHost());
         portSetter.accept(connector.getLocalPort());
 
         ServletContext servletContext =  context.getServletContext();
@@ -1003,7 +1008,14 @@ public void addGroups(String username, String... groups) {
      * URL ends with '/'.
      */
     public URL getURL() throws IOException {
-        return new URL("http://localhost:"+localPort+contextPath+"/");
+        return new URL(String.format("http://%s:%d%s/", getHost(), localPort, contextPath));
+    }
+
+    public String getHost() {
+        if (host == null) {
+            return "localhost";
+        }
+        return host;
     }
 
     public DumbSlave createSlave(EnvVars env) throws Exception {

src/test/java/org/jvnet/hudson/main/AppTest.java

@@ -23,50 +23,25 @@
  */
 package org.jvnet.hudson.main;
 
-import static org.junit.Assert.assertTrue;
-
-import hudson.model.FreeStyleBuild;
-import hudson.model.FreeStyleProject;
-import hudson.tasks.Shell;
-import hudson.tasks.BatchFile;
-import org.apache.commons.io.FileUtils;
 import org.junit.Rule;
 import org.junit.Test;
 import org.jvnet.hudson.test.JenkinsRule;
 
-import java.io.IOException;
-import java.util.concurrent.ExecutionException;
-
 /**
  * Experimenting with Hudson test suite.
  */
-public class AppTest  {
+public class AppTest extends BasicTestCase {
 
     @Rule
     public JenkinsRule j = new JenkinsRule();
 
     @Test
     public void test1() throws Exception {
-        meat();
+        meat(j);
     }
 
     @Test
     public void test2() throws Exception {
-        meat();
-    }
-
-    private void meat() throws IOException, InterruptedException, ExecutionException {
-        FreeStyleProject project = j.createFreeStyleProject();
-        if(System.getProperty("os.name").contains("Windows")) {
-            project.getBuildersList().add(new BatchFile("echo hello"));
-        } else {
-            project.getBuildersList().add(new Shell("echo hello"));
-        }
-
-        FreeStyleBuild build = project.scheduleBuild2(0).get();
-        System.out.println(build.getDisplayName()+" completed");
-
-        String s = FileUtils.readFileToString(build.getLogFile());
-        assertTrue(s,s.contains("echo hello"));
+        meat(j);
     }
 }

src/test/java/org/jvnet/hudson/main/BasicTestCase.java

@@ -0,0 +1,57 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2004-2009, Sun Microsystems, Inc., Kohsuke Kawaguchi, Bruce Chapman
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.jvnet.hudson.main;
+
+import static org.junit.Assert.assertTrue;
+
+import hudson.model.FreeStyleBuild;
+import hudson.model.FreeStyleProject;
+import hudson.tasks.Shell;
+import hudson.tasks.BatchFile;
+import org.apache.commons.io.FileUtils;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Experimenting with Hudson test suite.
+ */
+public class BasicTestCase {
+
+    protected void meat(JenkinsRule jenkinsRule) throws IOException, InterruptedException, ExecutionException {
+        FreeStyleProject project = jenkinsRule.createFreeStyleProject();
+        if(System.getProperty("os.name").contains("Windows")) {
+            project.getBuildersList().add(new BatchFile("echo hello"));
+        } else {
+            project.getBuildersList().add(new Shell("echo hello"));
+        }
+
+        FreeStyleBuild build = project.scheduleBuild2(0).get();
+        System.out.println(build.getDisplayName()+" completed");
+
+        String s = FileUtils.readFileToString(build.getLogFile());
+        assertTrue(s,s.contains("echo hello"));
+    }
+}

src/test/java/org/jvnet/hudson/main/JenkinsRuleAllHostInterfaceTest.java

@@ -0,0 +1,32 @@
+package org.jvnet.hudson.main;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.net.URL;
+import java.util.List;
+
+public class JenkinsRuleAllHostInterfaceTest extends BasicTestCase {
+
+    @Rule public JenkinsRule j = new JenkinsRule() {
+        {
+            host = null;
+        }
+    };
+
+    @Test 
+    public void allInterfaceJenkins() throws Throwable {
+        System.out.println("running in: " + j.jenkins.getRootUrl());
+        URL jenkinsURL = new URL(j.jenkins.getRootUrl());
+
+        assertEquals("localhost", jenkinsURL.getHost());
+    }
+
+    @Test
+    public void allInterfaceJenkinsBuild() throws Throwable {
+        meat(j);
+    }
+}

src/test/java/org/jvnet/hudson/main/JenkinsRuleHostIPTest.java

@@ -0,0 +1,44 @@
+package org.jvnet.hudson.main;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.JenkinsRule;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.net.URL;
+import java.util.List;
+
+public class JenkinsRuleHostIPTest extends BasicTestCase {
+
+    private static String HOST_IP = getHostAddress();
+
+    private static String getHostAddress() {
+        try {
+            return InetAddress.getLocalHost().getHostAddress();
+        } catch (UnknownHostException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Rule public JenkinsRule j = new JenkinsRule() {
+        {
+            host = HOST_IP;
+        }
+    };
+
+    @Test 
+    public void hostIpJenkins() throws Throwable {
+        System.out.println("running in: " + j.jenkins.getRootUrl());
+        URL jenkinsURL = new URL(j.jenkins.getRootUrl());
+
+        assertEquals(HOST_IP, jenkinsURL.getHost());
+    }
+
+    @Test
+    public void hostIpJenkinsBuild() throws Throwable {
+        meat(j);
+    }
+}