From 013cfc2764e14ae0aa7f6094f74cd232dc5e0028 Mon Sep 17 00:00:00 2001 From: Kohsuke Kawaguchi Date: Wed, 30 May 2012 15:36:46 -0700 Subject: [PATCH] run all tests with some time out to avoid infinite hang --- .../org/jvnet/hudson/test/HudsonTestCase.java | 33 +++++++- .../org/jvnet/hudson/test/JenkinsRule.java | 28 +++++++ .../hudson/test/recipes/WithTimeout.java | 75 +++++++++++++++++++ 3 files changed, 134 insertions(+), 2 deletions(-) create mode 100644 test/src/main/java/org/jvnet/hudson/test/recipes/WithTimeout.java diff --git a/test/src/main/java/org/jvnet/hudson/test/HudsonTestCase.java b/test/src/main/java/org/jvnet/hudson/test/HudsonTestCase.java index aa452c53ed..fda8ee1f15 100644 --- a/test/src/main/java/org/jvnet/hudson/test/HudsonTestCase.java +++ b/test/src/main/java/org/jvnet/hudson/test/HudsonTestCase.java @@ -110,6 +110,8 @@ import java.util.Enumeration; import java.util.Iterator; import java.util.List; import java.util.Locale; +import java.util.Timer; +import java.util.TimerTask; import java.util.UUID; import java.util.concurrent.*; import java.util.jar.Manifest; @@ -253,6 +255,13 @@ public abstract class HudsonTestCase extends TestCase implements RootAction { */ public boolean useLocalPluginManager; + /** + * Number of seconds until the test times out. + */ + public int timeout = 90; + + private volatile Timer timeoutTimer; + /** * Set the plugin manager to be passed to {@link Jenkins} constructor. * @@ -288,7 +297,7 @@ public abstract class HudsonTestCase extends TestCase implements RootAction { } @Override - protected void setUp() throws Exception { + protected void setUp() throws Exception { env.pin(); recipe(); AbstractProject.WORKSPACE.toString(); @@ -335,8 +344,23 @@ public abstract class HudsonTestCase extends TestCase implements RootAction { // allow the test class to inject Jenkins components jenkins.lookup(Injector.class).injectMembers(this); + + setUpTimeout(); } + protected void setUpTimeout() { + if (timeout<=0) return; // no timeout + + final Thread testThread = Thread.currentThread(); + timeoutTimer = new Timer(); + timeoutTimer.schedule(new TimerTask() { + @Override + public void run() { + if (timeoutTimer!=null) + testThread.interrupt(); + } + }, TimeUnit.SECONDS.toMillis(timeout)); + } /** @@ -358,6 +382,11 @@ public abstract class HudsonTestCase extends TestCase implements RootAction { @Override protected void tearDown() throws Exception { try { + if (timeoutTimer!=null) { + timeoutTimer.cancel(); + timeoutTimer = null; + } + // cancel pending asynchronous operations, although this doesn't really seem to be working for (WebClient client : clients) { // unload the page to cancel asynchronous operations @@ -384,7 +413,7 @@ public abstract class HudsonTestCase extends TestCase implements RootAction { ExtensionList.clearLegacyInstances(); DescriptorExtensionList.clearLegacyInstances(); - // Hudson creates ClassLoaders for plugins that hold on to file descriptors of its jar files, + // Jenkins creates ClassLoaders for plugins that hold on to file descriptors of its jar files, // but because there's no explicit dispose method on ClassLoader, they won't get GC-ed until // at some later point, leading to possible file descriptor overflow. So encourage GC now. // see http://bugs.sun.com/view_bug.do?bug_id=4950148 diff --git a/test/src/main/java/org/jvnet/hudson/test/JenkinsRule.java b/test/src/main/java/org/jvnet/hudson/test/JenkinsRule.java index 348646e9ba..93e39106df 100644 --- a/test/src/main/java/org/jvnet/hudson/test/JenkinsRule.java +++ b/test/src/main/java/org/jvnet/hudson/test/JenkinsRule.java @@ -187,6 +187,8 @@ import java.util.Enumeration; import java.util.Iterator; import java.util.List; import java.util.Locale; +import java.util.Timer; +import java.util.TimerTask; import java.util.UUID; import java.util.concurrent.Callable; import java.util.concurrent.CountDownLatch; @@ -284,6 +286,13 @@ public class JenkinsRule implements TestRule, RootAction { */ public boolean useLocalPluginManager; + /** + * Number of seconds until the test times out. + */ + public int timeout = 90; + + private volatile Timer timeoutTimer; + /** * Set the plugin manager to be passed to {@link Jenkins} constructor. * @@ -359,11 +368,30 @@ public class JenkinsRule implements TestRule, RootAction { sites.add(new UpdateSite("default", updateCenterUrl)); } + protected void setUpTimeout() { + if (timeout<=0) return; // no timeout + + final Thread testThread = Thread.currentThread(); + timeoutTimer = new Timer(); + timeoutTimer.schedule(new TimerTask() { + @Override + public void run() { + if (timeoutTimer!=null) + testThread.interrupt(); + } + }, TimeUnit.SECONDS.toMillis(timeout)); + } + /** * Override to tear down your specific external resource. */ protected void after() { try { + if (timeoutTimer!=null) { + timeoutTimer.cancel(); + timeoutTimer = null; + } + // cancel pending asynchronous operations, although this doesn't really seem to be working for (WebClient client : clients) { // unload the page to cancel asynchronous operations diff --git a/test/src/main/java/org/jvnet/hudson/test/recipes/WithTimeout.java b/test/src/main/java/org/jvnet/hudson/test/recipes/WithTimeout.java new file mode 100644 index 0000000000..ccc513ce3c --- /dev/null +++ b/test/src/main/java/org/jvnet/hudson/test/recipes/WithTimeout.java @@ -0,0 +1,75 @@ +/* + * The MIT License + * + * Copyright (c) 2004-2009, Sun Microsystems, Inc., Kohsuke Kawaguchi + * + * 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.test.recipes; + +import org.jvnet.hudson.test.HudsonTestCase; +import org.jvnet.hudson.test.JenkinsRecipe; +import org.jvnet.hudson.test.JenkinsRule; +import org.apache.commons.io.FileUtils; + +import hudson.util.JenkinsReloadFailed; + +import java.io.File; +import java.lang.annotation.Documented; +import static java.lang.annotation.ElementType.METHOD; +import java.lang.annotation.Retention; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Target; +import java.net.URL; + +/** + * Times out the test after the specified number of seconds. + * + * All the tests time out after some number of seconds by default, but this recipe + * allows you to override that value. + * + * @author Kohsuke Kawaguchi + */ +@Documented +@Recipe(WithTimeout.RunnerImpl.class) +@JenkinsRecipe(WithTimeout.RuleRunnerImpl.class) +@Target(METHOD) +@Retention(RUNTIME) +public @interface WithTimeout { + /** + * Number of seconds. + * + * 0 to indicate the test should never time out. + */ + int value(); + + class RunnerImpl extends Recipe.Runner { + @Override + public void setup(HudsonTestCase testCase, WithTimeout recipe) throws Exception { + testCase.timeout = recipe.value(); + } + } + + class RuleRunnerImpl extends JenkinsRecipe.Runner { + @Override + public void setup(JenkinsRule jenkinsRule, WithTimeout recipe) throws Exception { + jenkinsRule.timeout = recipe.value(); + } + } +}