Examples with WorkspaceList hudson.slaves.WorkspaceList used on opensource projects

Example 1 with WorkspaceList

use of hudson.slaves.WorkspaceList in project hudson-2.x by hudson.

the class AbstractProject method poll.

/**
     * Checks if there's any update in SCM, and returns true if any is found.
     *
     * <p>
     * The implementation is responsible for ensuring mutual exclusion between polling and builds
     * if necessary.
     *
     * @since 1.345
     */
public PollingResult poll(TaskListener listener) {
    SCM scm = getScm();
    if (scm == null) {
        listener.getLogger().println(Messages.AbstractProject_NoSCM());
        return NO_CHANGES;
    }
    if (isDisabled()) {
        listener.getLogger().println(Messages.AbstractProject_Disabled());
        return NO_CHANGES;
    }
    R lb = getLastBuild();
    if (lb == null) {
        listener.getLogger().println(Messages.AbstractProject_NoBuilds());
        return isInQueue() ? NO_CHANGES : BUILD_NOW;
    }
    if (pollingBaseline == null) {
        // if we have a persisted baseline, we'll find it by this
        R success = getLastSuccessfulBuild();
        for (R r = lb; r != null; r = r.getPreviousBuild()) {
            SCMRevisionState s = r.getAction(SCMRevisionState.class);
            if (s != null) {
                pollingBaseline = s;
                break;
            }
            // searched far enough
            if (r == success)
                break;
        }
    // NOTE-NO-BASELINE:
    // if we don't have baseline yet, it means the data is built by old Hudson that doesn't set the baseline
    // as action, so we need to compute it. This happens later.
    }
    try {
        if (scm.requiresWorkspaceForPolling()) {
            // lock the workspace of the last build
            FilePath ws = lb.getWorkspace();
            if (ws == null || !ws.exists()) {
                // workspace offline. build now, or nothing will ever be built
                Label label = getAssignedLabel();
                if (label != null && label.isSelfLabel()) {
                    // if the build is fixed on a node, then attempting a build will do us
                    // no good. We should just wait for the slave to come back.
                    listener.getLogger().println(Messages.AbstractProject_NoWorkspace());
                    return NO_CHANGES;
                }
                listener.getLogger().println(ws == null ? Messages.AbstractProject_WorkspaceOffline() : Messages.AbstractProject_NoWorkspace());
                if (isInQueue()) {
                    listener.getLogger().println(Messages.AbstractProject_AwaitingBuildForWorkspace());
                    return NO_CHANGES;
                } else {
                    listener.getLogger().println(Messages.AbstractProject_NewBuildForWorkspace());
                    return BUILD_NOW;
                }
            } else {
                Node node = lb.getBuiltOn();
                if (node == null || node.toComputer() == null) {
                    LOGGER.log(Level.FINE, "Node on which this job previously was built is not available now, build is started on an available node");
                    return isInQueue() ? NO_CHANGES : BUILD_NOW;
                }
                WorkspaceList l = node.toComputer().getWorkspaceList();
                // if doing non-concurrent build, acquire a workspace in a way that causes builds to block for this workspace.
                // this prevents multiple workspaces of the same job --- the behavior of Hudson < 1.319.
                //
                // OTOH, if a concurrent build is chosen, the user is willing to create a multiple workspace,
                // so better throughput is achieved over time (modulo the initial cost of creating that many workspaces)
                // by having multiple workspaces
                WorkspaceList.Lease lease = l.acquire(ws, !concurrentBuild);
                Launcher launcher = ws.createLauncher(listener);
                try {
                    LOGGER.fine("Polling SCM changes of " + getName());
                    if (// see NOTE-NO-BASELINE above
                    pollingBaseline == null)
                        calcPollingBaseline(lb, launcher, listener);
                    PollingResult r = scm.poll(this, launcher, ws, listener, pollingBaseline);
                    pollingBaseline = r.remote;
                    return r;
                } finally {
                    lease.release();
                }
            }
        } else {
            // polling without workspace
            LOGGER.fine("Polling SCM changes of " + getName());
            if (// see NOTE-NO-BASELINE above
            pollingBaseline == null)
                calcPollingBaseline(lb, null, listener);
            PollingResult r = scm.poll(this, null, null, listener, pollingBaseline);
            pollingBaseline = r.remote;
            return r;
        }
    } catch (AbortException e) {
        listener.getLogger().println(e.getMessage());
        listener.fatalError(Messages.AbstractProject_Aborted());
        LOGGER.log(Level.FINE, "Polling " + this + " aborted", e);
        return NO_CHANGES;
    } catch (IOException e) {
        e.printStackTrace(listener.fatalError(e.getMessage()));
        return NO_CHANGES;
    } catch (InterruptedException e) {
        e.printStackTrace(listener.fatalError(Messages.AbstractProject_PollingABorted()));
        return NO_CHANGES;
    }
}