diff --git a/changelog.html b/changelog.html
index 6f14a5d434..36335a10b5 100644
--- a/changelog.html
+++ b/changelog.html
@@ -67,6 +67,9 @@ Upcoming changes
f:combobox is narrow.
(issue 21612)
+
+ The workspace cleanup thread failed to handle the modern workspace location on master, and mishandled folders.
+ (issue 21023)
Fixed missing help items on "Configure Global Security" page
(issue 19832)
diff --git a/core/src/main/java/hudson/model/Node.java b/core/src/main/java/hudson/model/Node.java
index f542b78411..d92f684208 100644
--- a/core/src/main/java/hudson/model/Node.java
+++ b/core/src/main/java/hudson/model/Node.java
@@ -371,7 +371,7 @@ public abstract class Node extends AbstractModelObject implements Reconfigurable
* null if this node is not connected hence the path is not available
*/
// TODO: should this be modified now that getWorkspace is moved from AbstractProject to AbstractBuild?
- public abstract FilePath getWorkspaceFor(TopLevelItem item);
+ public abstract @CheckForNull FilePath getWorkspaceFor(TopLevelItem item);
/**
* Gets the root directory of this node.
@@ -384,7 +384,7 @@ public abstract class Node extends AbstractModelObject implements Reconfigurable
* null if the node is offline and hence the {@link FilePath}
* object is not available.
*/
- public abstract FilePath getRootPath();
+ public abstract @CheckForNull FilePath getRootPath();
/**
* Gets the {@link FilePath} on this node.
diff --git a/core/src/main/java/hudson/model/Slave.java b/core/src/main/java/hudson/model/Slave.java
index 46b4849596..5e9204f0a0 100644
--- a/core/src/main/java/hudson/model/Slave.java
+++ b/core/src/main/java/hudson/model/Slave.java
@@ -57,6 +57,7 @@ import java.util.Set;
import javax.servlet.ServletException;
import hudson.util.TimeUnit2;
+import javax.annotation.CheckForNull;
import jenkins.model.Jenkins;
import jenkins.slaves.WorkspaceLocator;
@@ -284,7 +285,7 @@ public abstract class Slave extends Node implements Serializable {
* @return
* null if not connected.
*/
- public FilePath getWorkspaceRoot() {
+ public @CheckForNull FilePath getWorkspaceRoot() {
FilePath r = getRootPath();
if(r==null) return null;
return r.child(WORKSPACE_ROOT);
diff --git a/core/src/main/java/hudson/model/WorkspaceCleanupThread.java b/core/src/main/java/hudson/model/WorkspaceCleanupThread.java
index 52bf53daea..e0d0f7b13f 100644
--- a/core/src/main/java/hudson/model/WorkspaceCleanupThread.java
+++ b/core/src/main/java/hudson/model/WorkspaceCleanupThread.java
@@ -23,18 +23,18 @@
*/
package hudson.model;
+import hudson.Extension;
import hudson.FilePath;
import hudson.Util;
-import hudson.Extension;
-import jenkins.model.Jenkins;
-
-import java.io.File;
-import java.io.FileFilter;
import java.io.IOException;
-import java.io.Serializable;
+import java.util.ArrayList;
import java.util.Date;
import java.util.List;
+import java.util.logging.Level;
import java.util.logging.Logger;
+import javax.annotation.Nonnull;
+import jenkins.model.Jenkins;
+import jenkins.model.ModifiableTopLevelItemGroup;
/**
* Clean up old left-over workspaces from slaves.
@@ -47,7 +47,7 @@ public class WorkspaceCleanupThread extends AsyncPeriodicWork {
super("Workspace clean-up");
}
- public long getRecurrencePeriod() {
+ @Override public long getRecurrencePeriod() {
return DAY;
}
@@ -55,121 +55,87 @@ public class WorkspaceCleanupThread extends AsyncPeriodicWork {
Jenkins.getInstance().getExtensionList(AsyncPeriodicWork.class).get(WorkspaceCleanupThread.class).run();
}
- // so that this can be easily accessed from sub-routine.
- private TaskListener listener;
-
- protected void execute(TaskListener listener) throws InterruptedException, IOException {
- try {
- if(disabled) {
- LOGGER.fine("Disabled. Skipping execution");
- return;
- }
-
- this.listener = listener;
-
- Jenkins h = Jenkins.getInstance();
- for (Node n : h.getNodes())
- if (n instanceof Slave) process((Slave)n);
-
- process(h);
- } finally {
- this.listener = null;
+ @Override protected void execute(TaskListener listener) throws InterruptedException, IOException {
+ if (disabled) {
+ LOGGER.fine("Disabled. Skipping execution");
+ return;
}
- }
-
- private void process(Jenkins h) throws IOException, InterruptedException {
- File jobs = new File(h.getRootDir(), "jobs");
- File[] dirs = jobs.listFiles(DIR_FILTER);
- if(dirs==null) return;
- for (File dir : dirs) {
- FilePath ws = new FilePath(new File(dir, "workspace"));
- if(shouldBeDeleted(dir.getName(),ws,h)) {
- delete(ws);
+ List nodes = new ArrayList();
+ Jenkins j = Jenkins.getInstance();
+ nodes.add(j);
+ nodes.addAll(j.getNodes());
+ for (TopLevelItem item : j.getAllItems(TopLevelItem.class)) {
+ if (item instanceof ModifiableTopLevelItemGroup) { // no such thing as TopLevelItemGroup, and ItemGroup offers no access to its type parameter
+ continue; // children will typically have their own workspaces as subdirectories; probably no real workspace of its own
+ }
+ listener.getLogger().println("Checking " + item.getFullDisplayName());
+ for (Node node : nodes) {
+ FilePath ws = node.getWorkspaceFor(item);
+ if (ws == null) {
+ continue; // offline, fine
+ }
+ boolean check;
+ try {
+ check = shouldBeDeleted(item, ws, node);
+ } catch (IOException x) {
+ x.printStackTrace(listener.error("Failed to check " + node.getDisplayName()));
+ continue;
+ } catch (InterruptedException x) {
+ x.printStackTrace(listener.error("Failed to check " + node.getDisplayName()));
+ continue;
+ }
+ if (check) {
+ listener.getLogger().println("Deleting " + ws + " on " + node.getDisplayName());
+ try {
+ ws.deleteRecursive();
+ } catch (IOException x) {
+ x.printStackTrace(listener.error("Failed to delete " + ws + " on " + node.getDisplayName()));
+ } catch (InterruptedException x) {
+ x.printStackTrace(listener.error("Failed to delete " + ws + " on " + node.getDisplayName()));
+ }
+ }
}
}
}
- private boolean shouldBeDeleted(String workspaceDirectoryName, FilePath dir, Node n) throws IOException, InterruptedException {
+ private boolean shouldBeDeleted(@Nonnull TopLevelItem item, FilePath dir, Node n) throws IOException, InterruptedException {
// TODO: the use of remoting is not optimal.
// One remoting can execute "exists", "lastModified", and "delete" all at once.
- TopLevelItem item = Jenkins.getInstance().getItem(workspaceDirectoryName);
-
- if(!dir.exists())
+ // (Could even invert master loop so that one FileCallable takes care of all known items.)
+ if(!dir.exists()) {
+ LOGGER.log(Level.FINE, "Directory {0} does not exist", dir);
return false;
+ }
// if younger than a month, keep it
long now = new Date().getTime();
if(dir.lastModified() + 30 * DAY > now) {
- LOGGER.fine("Directory "+dir+" is only "+ Util.getTimeSpanString(now-dir.lastModified())+" old, so not deleting");
+ LOGGER.log(Level.FINE, "Directory {0} is only {1} old, so not deleting", new Object[] {dir, Util.getTimeSpanString(now-dir.lastModified())});
return false;
}
- // Could mean that directory doesn't belong to a job. But can also mean that it's a custom workspace belonging to a job.
- // So better leave it alone - will still be deleted after 30 days - until we have a proper check for custom workspaces.
- // TODO: implement proper check for custom workspaces.
- // TODO: If we do the above, could also be good to add checkbox that lets users configure a workspace to never be auto-cleaned.
- if(item==null) {
- return false;
- }
+ // TODO could also be good to add checkbox that lets users configure a workspace to never be auto-cleaned.
if (item instanceof AbstractProject,?>) {
AbstractProject,?> p = (AbstractProject,?>) item;
Node lb = p.getLastBuiltOn();
- LOGGER.finer("Directory "+dir+" is last built on "+lb);
+ LOGGER.log(Level.FINER, "Directory {0} is last built on {1}", new Object[] {dir, lb});
if(lb!=null && lb.equals(n)) {
// this is the active workspace. keep it.
- LOGGER.fine("Directory "+dir+" is the last workspace for "+p);
+ LOGGER.log(Level.FINE, "Directory {0} is the last workspace for {1}", new Object[] {dir, p});
return false;
}
if(!p.getScm().processWorkspaceBeforeDeletion(p,dir,n)) {
- LOGGER.fine("Directory deletion of "+dir+" is vetoed by SCM");
+ LOGGER.log(Level.FINE, "Directory deletion of {0} is vetoed by SCM", dir);
return false;
}
}
- LOGGER.finer("Going to delete directory "+dir);
+ LOGGER.log(Level.FINER, "Going to delete directory {0}", dir);
return true;
}
- private void process(Slave s) throws InterruptedException {
- listener.getLogger().println("Scanning "+s.getNodeName());
-
- try {
- FilePath path = s.getWorkspaceRoot();
- if(path==null) return;
-
- List dirs = path.list(DIR_FILTER);
- if(dirs ==null) return;
- for (FilePath dir : dirs) {
- if(shouldBeDeleted(dir.getName(),dir,s))
- delete(dir);
- }
- } catch (IOException e) {
- e.printStackTrace(listener.error("Failed on "+s.getNodeName()));
- }
- }
-
- private void delete(FilePath dir) throws InterruptedException {
- try {
- listener.getLogger().println("Deleting "+dir);
- dir.deleteRecursive();
- } catch (IOException e) {
- e.printStackTrace(listener.error("Failed to delete "+dir));
- }
- }
-
-
- private static class DirectoryFilter implements FileFilter, Serializable {
- public boolean accept(File f) {
- return f.isDirectory();
- }
- private static final long serialVersionUID = 1L;
- }
- private static final FileFilter DIR_FILTER = new DirectoryFilter();
-
- private static final long DAY = 1000*60*60*24;
-
private static final Logger LOGGER = Logger.getLogger(WorkspaceCleanupThread.class.getName());
/**
diff --git a/test/src/test/java/hudson/model/WorkspaceCleanupThreadTest.java b/test/src/test/java/hudson/model/WorkspaceCleanupThreadTest.java
new file mode 100644
index 0000000000..3e31815e44
--- /dev/null
+++ b/test/src/test/java/hudson/model/WorkspaceCleanupThreadTest.java
@@ -0,0 +1,155 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2014 Jesse Glick.
+ *
+ * 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 hudson.model;
+
+import hudson.FilePath;
+import hudson.FilePath.FileCallable;
+import hudson.remoting.VirtualChannel;
+import hudson.slaves.DumbSlave;
+import hudson.util.StreamTaskListener;
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import static org.junit.Assert.*;
+import org.junit.Assume;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.jvnet.hudson.test.Bug;
+import org.jvnet.hudson.test.JenkinsRule;
+import org.jvnet.hudson.test.MockFolder;
+
+public class WorkspaceCleanupThreadTest {
+
+ // TODO test that new workspaces are skipped
+ // TODO test that SCM.processWorkspaceBeforeDeletion can reject
+
+ @Rule public JenkinsRule r = new JenkinsRule();
+
+ private static final Logger logger = Logger.getLogger(WorkspaceCleanupThread.class.getName());
+ @BeforeClass public static void logging() {
+ logger.setLevel(Level.ALL);
+ Handler handler = new ConsoleHandler();
+ handler.setLevel(Level.ALL);
+ logger.addHandler(handler);
+ }
+
+ @Test public void cleanUpSlaves() throws Exception {
+ DumbSlave s1 = r.createOnlineSlave();
+ FreeStyleProject p = r.createFreeStyleProject();
+ p.setAssignedNode(s1);
+ FreeStyleBuild b1 = r.assertBuildStatusSuccess(p.scheduleBuild2(0));
+ assertEquals(s1, b1.getBuiltOn());
+ FilePath ws1 = b1.getWorkspace();
+ assertNotNull(ws1);
+ ws1.act(new Detouch());
+ DumbSlave s2 = r.createOnlineSlave();
+ p.setAssignedNode(s2);
+ FreeStyleBuild b2 = r.assertBuildStatusSuccess(p.scheduleBuild2(0));
+ assertEquals(s2, b2.getBuiltOn());
+ FilePath ws2 = b2.getWorkspace();
+ assertNotNull(ws2);
+ ws2.act(new Detouch());
+ p.setAssignedNode(r.jenkins);
+ FreeStyleBuild b3 = r.assertBuildStatusSuccess(p.scheduleBuild2(0));
+ assertEquals(r.jenkins, b3.getBuiltOn());
+ assertEquals(r.jenkins, p.getLastBuiltOn());
+ new WorkspaceCleanupThread().execute(StreamTaskListener.fromStdout());
+ assertFalse(ws1.exists());
+ assertFalse(ws2.exists());
+ }
+
+ @Bug(21023)
+ @Test public void modernMasterWorkspaceLocation() throws Exception {
+ FreeStyleProject p = r.createFreeStyleProject();
+ FreeStyleBuild b1 = r.assertBuildStatusSuccess(p.scheduleBuild2(0));
+ assertEquals(r.jenkins, b1.getBuiltOn());
+ FilePath ws1 = b1.getWorkspace();
+ assertNotNull(ws1);
+ ws1.act(new Detouch());
+ DumbSlave s = r.createOnlineSlave();
+ p.setAssignedNode(s);
+ FreeStyleBuild b2 = r.assertBuildStatusSuccess(p.scheduleBuild2(0));
+ assertEquals(s, b2.getBuiltOn());
+ FilePath ws2 = b2.getWorkspace();
+ assertNotNull(ws2);
+ ws2.act(new Detouch());
+ assertEquals(s, p.getLastBuiltOn());
+ new WorkspaceCleanupThread().execute(StreamTaskListener.fromStdout());
+ assertFalse(ws1.exists());
+ assertTrue(ws2.exists());
+ }
+
+ @Bug(21023)
+ @Test public void jobInFolder() throws Exception {
+ MockFolder d = r.createFolder("d");
+ FreeStyleProject p1 = d.createProject(FreeStyleProject.class, "p");
+ FreeStyleBuild b1 = r.assertBuildStatusSuccess(p1.scheduleBuild2(0));
+ assertEquals(r.jenkins, b1.getBuiltOn());
+ FilePath ws1 = b1.getWorkspace();
+ assertNotNull(ws1);
+ ws1.act(new Detouch());
+ DumbSlave s1 = r.createOnlineSlave();
+ p1.setAssignedNode(s1);
+ FreeStyleBuild b2 = r.assertBuildStatusSuccess(p1.scheduleBuild2(0));
+ assertEquals(s1, b2.getBuiltOn());
+ FilePath ws2 = b2.getWorkspace();
+ assertNotNull(ws2);
+ ws2.act(new Detouch());
+ DumbSlave s2 = r.createOnlineSlave();
+ p1.setAssignedNode(s2);
+ FreeStyleBuild b3 = r.assertBuildStatusSuccess(p1.scheduleBuild2(0));
+ assertEquals(s2, b3.getBuiltOn());
+ FilePath ws3 = b3.getWorkspace();
+ assertNotNull(ws3);
+ ws3.act(new Detouch());
+ assertEquals(s2, p1.getLastBuiltOn());
+ FreeStyleProject p2 = d.createProject(FreeStyleProject.class, "p2");
+ p2.setAssignedNode(s1);
+ FreeStyleBuild b4 = r.assertBuildStatusSuccess(p2.scheduleBuild2(0));
+ assertEquals(s1, b4.getBuiltOn());
+ FilePath ws4 = b4.getWorkspace();
+ assertNotNull(ws4);
+ ws4.act(new Detouch());
+ assertEquals(s1, p2.getLastBuiltOn());
+ ws2.getParent().act(new Detouch()); // ${s1.rootPath}/workspace/d/
+ new WorkspaceCleanupThread().execute(StreamTaskListener.fromStdout());
+ assertFalse(ws1.exists());
+ assertFalse(ws2.exists());
+ assertTrue(ws3.exists());
+ assertTrue(ws4.exists());
+ }
+
+ private static final class Detouch implements FileCallable {
+ @Override public Void invoke(File f, VirtualChannel channel) throws IOException, InterruptedException {
+ Assume.assumeTrue("failed to reset lastModified on " + f, f.setLastModified(0));
+ return null;
+ }
+ }
+
+}