import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
/**
 * While x-stream serialisation buggy, copy implementation.
 */
@Override
@GuardedBy("hudson.model.Queue.lock")
public long check(final AbstractCloudComputer c) {
    final AbstractCloudSlave computerNode = c.getNode();
    if (c.isIdle() && computerNode != null) {
        final long idleMilliseconds = System.currentTimeMillis() - c.getIdleStartMilliseconds();
        if (idleMilliseconds > MINUTES.toMillis(idleMinutes)) {
            LOG.info("Disconnecting {}, after {} min timeout.", c.getName(), idleMinutes);
            try {
                computerNode.terminate();
            } catch (InterruptedException | IOException e) {
                LOG.warn("Failed to terminate {}", c.getName(), e);
            }
        }
    }
    return 1;
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
@GuardedBy("hudson.model.Queue.lock")
public long check(final AbstractCloudComputer acc) {
    // When the slave is idle we should disable accepting tasks and check to see if it is already trying to
    // terminate. If it's not already trying to terminate then lets terminate manually.
    if (acc.isIdle() && !disabled) {
        final long idleMilliseconds = System.currentTimeMillis() - acc.getIdleStartMilliseconds();
        if (idleMilliseconds > TimeUnit2.MINUTES.toMillis(idleMinutes)) {
            LOG.debug("Disconnecting {}", acc.getName());
            done(acc);
        }
    }

    // Return one because we want to check every minute if idle.
    return 1;
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
protected void done(Executor executor) {
    final AbstractCloudComputer<?> c = (AbstractCloudComputer) executor.getOwner();
    Queue.Executable exec = executor.getCurrentExecutable();
    if (executor instanceof OneOffExecutor) {
        LOG.debug("Not terminating {} because {} was a flyweight task", c.getName(), exec);
        return;
    }

    if (exec instanceof ContinuableExecutable && ((ContinuableExecutable) exec).willContinue()) {
        LOG.debug("not terminating {} because {} says it will be continued", c.getName(), exec);
        return;
    }

    LOG.debug("terminating {} since {} seems to be finished", c.getName(), exec);
    done(c);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
private static @CheckForNull ProvisioningActivity.Id getIdFor(Computer computer) {
    if (computer instanceof Jenkins.MasterComputer) return null;
    if (!(computer instanceof AbstractCloudComputer)) return null;

    if (!(computer instanceof TrackedItem)) {
        logTypeNotSupported(computer.getClass());
        return null;
    }

    return ((TrackedItem) computer).getId();
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public void start(AbstractCloudComputer c) {
    if (c.getNode() instanceof EphemeralNode) {
        throw new IllegalStateException("May not use OnceRetentionStrategy on an EphemeralNode: " + c);
    }
    super.start(c);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public AbstractCloudComputer createComputer() {
    return new TrackedComputer(this, id);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public AbstractCloudComputer createComputer()
{
	return new ParallelsDesktopVMSlaveComputer(this);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public AbstractCloudComputer createComputer()
{
	return new ParallelsDesktopConnectorSlaveComputer(this);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public AbstractCloudComputer createComputer() {
    return new ECSComputer(this);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
@Override
public AbstractCloudComputer createComputer() {
    return new DockerComputerSingle(this, activityId);
}
 

import hudson.slaves.AbstractCloudComputer; //导入依赖的package包/类
/**
 * Try to connect to it ASAP.
 */
@Override
public void start(AbstractCloudComputer c) {
    c.connect(false);
}