import hudson.slaves.WorkspaceList; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected WorkspaceList.Lease decideWorkspace(Node n, WorkspaceList wsl)
    throws InterruptedException, IOException {
  final YamlProject project = YamlBuild.this.getParent();
  final WorkspaceList.Lease lease = project.shareWorkspace(n);
  return (lease != null) ? lease : super.decideWorkspace(n, wsl);
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
protected Lease getParentWorkspaceLease(final Node n, final WorkspaceList wsl) throws InterruptedException, IOException {
    final DynamicProject mp = getParent().getParent();

    final String customWorkspace = mp.getCustomWorkspace();
    if (customWorkspace != null) {
        // we allow custom workspaces to be concurrently used between
        // jobs.
        return Lease.createDummyLease(n.getRootPath().child(getEnvironment(this.listener).expand(customWorkspace)));
    }
    return wsl.allocate(n.getWorkspaceFor(mp), getParentBuild());
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
@Override
protected Lease decideWorkspace(final Node n, final WorkspaceList wsl) throws InterruptedException, IOException {
    final Lease baseLease = getParentWorkspaceLease(n, wsl);
    final FilePath baseDir = baseLease.path;
    final EnvVars env = getEnvironment(this.listener);
    env.putAll(getBuildVariables());
    final String childWs = getParent().getName();
    return Lease.createLinkedDummyLease(baseDir.child(env.expand(childWs)), baseLease);
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
private static FilePath tempDir(FilePath ws) {
    return ws.sibling(ws.getName() + System.getProperty(WorkspaceList.class.getName(), "@") + "tmp");
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
Callback(StepContext context, WorkspaceList.Lease lease) {
    this.context = context;
    this.lease = lease;
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
/**
 * This function will check if the parent project is set up to
 * construct the workspace path from a string containing assigned
 * variables, instead of a fixed path.
 * <p>
 * This means that multiple projects can share their workspace, as long
 * as they use the same parameter values. This is highly useful for
 * projects that have to check-out code from large repositories or are
 * making use of a lot of common files.
 * <p>
 * If the project does not have the property set, it falls back to the
 * native Jenkins approach.
 * <p>
 * TODO: This might be useful to be sent upstream as a Jenkins-core
 * feature!
 */
@Override
protected Lease decideWorkspace(Node n, WorkspaceList wsl) throws InterruptedException, IOException {
	//Check if a parameter itself sets the workspace path
	for (ParameterValue pv : this.getParameterValues()) {
		if (!(pv instanceof StringParameterValue)) {
			continue;
		}
		StringParameterValue spv = (StringParameterValue) pv;
		if (spv.getName().equalsIgnoreCase("WORKSPACE_REUSE_PATH")) {
			//Fetch the workspace (do not care about locking)
			return Lease.createDummyLease(
					new FilePath(n.getChannel(), spv.value)
			);
		}
	}
	
	//Check if we deal with an inheritance job
	Job<?, ?> job = this.getProject();
	if (job == null && !(job instanceof InheritanceProject)) {
		//Invalid job; fall-back
		return super.decideWorkspace(n, wsl);
	}
	InheritanceProject ip = (InheritanceProject) job;
	
	//Check if a custom workspace is demanded
	String customWorkspace = ip.getCustomWorkspace();
	if (customWorkspace != null) {
		//The parent knows what to do
		return super.decideWorkspace(n, wsl);
	}
	
	//Calling the static workspace path finder
	FilePath ws = InheritanceBuild.getWorkspacePathFor(
			n, ip,
			this.getBuild().getEnvironment(this.getListener())
	);
	if (ws == null) {
		return super.decideWorkspace(n, wsl);
	}
	
	//We have the path; create a variable Lease
	return wsl.allocate(ws, getBuild());
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
/**
 * Projects that delegate often have a largely cosmetic workspace,
 * based on which logic/control decisions are made, e.g. how to build
 * up a DSL project from its checked in code.  To minimize the impact
 * of these read-only workspaces in the presence of composition, attempt
 * to share our workspace with a parent job, if it has a workspace on
 * the node on which we have been scheduled.  This should be called from
 * {@code decideWorkspace}.
 * <p>
 * NOTE: public so that it is accessible to builds.
 *
 * @param onNode The Node we've been scheduled on.
 * @return A lease on the workspace to share, or null if no such workspace
 * exists on this node.
 */
@Nullable
public WorkspaceList.Lease shareWorkspace(Node onNode) {
  final FilePath workspace = _shareWorkspace(onNode);
  return workspace == null ? null :
      WorkspaceList.Lease.createDummyLease(workspace);
}
 

import hudson.slaves.WorkspaceList; //导入依赖的package包/类
/**
 * Calculates a temporary dir path
 *
 * @param ws current workspace
 * @return the temporary dir
 */
private static FilePath tempDir(FilePath ws) {
    return WorkspaceList.tempDir(ws);
}