hudson.model.ResourceController Maven / Gradle / Ivy
Show all versions of hudson-core Show documentation
/*******************************************************************************
*
* Copyright (c) 2004-2009 Oracle Corporation.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
*
* Kohsuke Kawaguchi
*
*
*******************************************************************************/
package hudson.model;
import hudson.util.AdaptedIterator;
import java.util.Set;
import java.util.HashSet;
import java.util.Collection;
import java.util.AbstractCollection;
import java.util.Collections;
import java.util.Iterator;
/**
* Controls mutual exclusion of {@link ResourceList}.
*
* @author Kohsuke Kawaguchi
*/
public class ResourceController {
/**
* {@link ResourceList}s that are used by activities that are in progress.
*/
private final Set inProgress = new HashSet();
/**
* View of {@link #inProgress} that exposes its {@link ResourceList}.
*/
private final Collection resourceView = new AbstractCollection() {
public Iterator iterator() {
return new AdaptedIterator(inProgress.iterator()) {
protected ResourceList adapt(ResourceActivity item) {
return item.getResourceList();
}
};
}
public int size() {
return inProgress.size();
}
};
/**
* Union of all {@link Resource}s that are currently in use. Updated as a
* task starts/completes executing.
*/
private ResourceList inUse = ResourceList.EMPTY;
/**
* Performs the task that requires the given list of resources.
*
* The execution is blocked until the resource is available.
*
* @throws InterruptedException the thread can be interrupted while waiting
* for the available resources.
*/
public void execute(Runnable task, ResourceActivity activity) throws InterruptedException {
ResourceList resources = activity.getResourceList();
synchronized (this) {
while (inUse.isCollidingWith(resources)) {
wait();
}
// we have a go
inProgress.add(activity);
inUse = ResourceList.union(inUse, resources);
}
try {
task.run();
} finally {
synchronized (this) {
inProgress.remove(activity);
inUse = ResourceList.union(resourceView);
notifyAll();
}
}
}
/**
* Checks if an activity that requires the given resource list can run
* immediately.
*
*
This method is really only useful as a hint, since another activity
* might acquire resources before the caller gets to call
* {@link #execute(Runnable, ResourceActivity)}.
*/
public synchronized boolean canRun(ResourceList resources) {
return !inUse.isCollidingWith(resources);
}
/**
* Of the resource in the given resource list, return the one that's
* currently in use.
*
*
If more than one such resource exists, one is chosen and returned.
* This method is used for reporting what's causing the blockage.
*/
public synchronized Resource getMissingResource(ResourceList resources) {
return resources.getConflict(inUse);
}
/**
* Of the activities that are in progress, return one that's blocking the
* given activity, or null if it's not blocked (and thus the given activity
* can be executed immediately.)
*/
public ResourceActivity getBlockingActivity(ResourceActivity activity) {
ResourceList res = activity.getResourceList();
Set syncInProgress = Collections.synchronizedSet(inProgress);
// Synchronize only the block (see 395879)
synchronized (syncInProgress) {
for (ResourceActivity a : syncInProgress) {
if (res.isCollidingWith(a.getResourceList())) {
return a;
}
}
}
return null;
}
}