hudson.slaves.AbstractCloudComputer Java Examples

/**
 * 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;
}
 

@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;
}
 

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);
}
 

@SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_BAD_PRACTICE")
protected void done(final AbstractCloudComputer<?> c) {
    c.setAcceptingTasks(false); // just in case
    synchronized (this) {
        if (terminating) {
            return;
        }
        terminating = true;
    }

    Computer.threadPoolForRemoting.submit(() -> {
            try {
                AbstractCloudSlave node = c.getNode();
                if (node != null) {
                    node.terminate();
                }
            } catch (InterruptedException | IOException e) {
                LOG.warn("Failed to terminate " + c.getName(), e);
                synchronized (DockerOnceRetentionStrategy.this) {
                    terminating = false;
                }
            }
        }
    );
}
 

@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);
}
 

@Override
public AbstractCloudComputer createComputer() {
    return null;
}
 

@Override
public AbstractCloudComputer createComputer()
{
	return new ParallelsDesktopVMSlaveComputer(this);
}
 

@Override
public AbstractCloudComputer createComputer()
{
	return new ParallelsDesktopConnectorSlaveComputer(this);
}
 

@Override
public AbstractCloudComputer createComputer() {
    return new DockerComputerSingle(this, activityId);
}
 

/**
 * Try to connect to it ASAP.
 */
@Override
public void start(AbstractCloudComputer c) {
    c.connect(false);
}
 

@Override
public AbstractCloudComputer<ECSSlave> createComputer() {
    return new ECSComputer(this);
}