/** Gets {@link SlaveTemplate} that has the matching {@link Label}. */
public SlaveTemplate getTemplate(Label label) {
for (SlaveTemplate t : templates) {
if (t.getMode() == Node.Mode.NORMAL) {
if (label == null || label.matches(t.getLabelSet())) {
return t;
}
} else if (t.getMode() == Node.Mode.EXCLUSIVE) {
if (label != null && label.matches(t.getLabelSet())) {
return t;
}
}
}
return null;
}
/** Returns slave template associated with the label */
public AzureSlaveTemplate getAzureSlaveTemplate(Label label) {
for (AzureSlaveTemplate slaveTemplate : instTemplates) {
if (slaveTemplate.getUseSlaveAlwaysIfAvail() == Node.Mode.NORMAL) {
if (label == null || label.matches(slaveTemplate.getLabelDataSet())) {
return slaveTemplate;
}
} else if (slaveTemplate.getUseSlaveAlwaysIfAvail() == Node.Mode.EXCLUSIVE) {
if (label != null && label.matches(slaveTemplate.getLabelDataSet())) {
return slaveTemplate;
}
}
}
return null;
}
public MesosSlaveInfo getMesosSlaveInfoForLabel(Label label) {
if (!matchesLabel(label)) {
return null;
}
if (label == null) {
if (getLabelString() == null) {
return this;
} else {
return null;
}
}
if (label.matches(Label.parse(getLabelString()))) {
return this;
}
if (!containerInfo.getDockerImageCustomizable()) {
return null;
}
String customImage = getCustomImage(label);
if (customImage == null) {
return null;
}
return copyWithDockerImage(label.toString(), customImage);
}
private ECSTaskTemplate getTemplate(Label label) {
for (ECSTaskTemplate t : templates) {
if (label == null || label.matches(t.getLabelSet())) {
return t;
}
}
return null;
}
/**
* Determines whether the AMI of the given instance matches the AMI of template and has the
* required label (if requiredLabel is non-null)
*/
private boolean checkInstance(
PrintStream logger,
Instance existingInstance,
Label requiredLabel,
EC2AbstractSlave[] returnNode) {
logProvision(logger, "checkInstance: " + existingInstance);
if (StringUtils.isNotBlank(getIamInstanceProfile())) {
if (existingInstance.getIamInstanceProfile() != null) {
if (!existingInstance.getIamInstanceProfile().getArn().equals(getIamInstanceProfile())) {
logProvision(logger, " false - IAM Instance profile does not match");
return false;
}
// Match, fall through
} else {
logProvision(logger, " false - Null IAM Instance profile");
return false;
}
}
if (existingInstance
.getState()
.getName()
.equalsIgnoreCase(InstanceStateName.Terminated.toString())
|| existingInstance
.getState()
.getName()
.equalsIgnoreCase(InstanceStateName.ShuttingDown.toString())) {
logProvision(logger, " false - Instance is terminated or shutting down");
return false;
}
// See if we know about this and it has capacity
for (EC2AbstractSlave node : NodeIterator.nodes(EC2AbstractSlave.class)) {
if (node.getInstanceId().equals(existingInstance.getInstanceId())) {
logProvision(logger, "Found existing corresponding Jenkins slave: " + node.getInstanceId());
if (!node.toComputer().isPartiallyIdle()) {
logProvision(logger, " false - Node is not partially idle");
return false;
}
// REMOVEME - this was added to force provision to work, but might not allow
// stopped instances to be found - need to investigate further
else if (false && node.toComputer().isOffline()) {
logProvision(logger, " false - Node is offline");
return false;
} else if (requiredLabel != null && !requiredLabel.matches(node.getAssignedLabels())) {
logProvision(logger, " false - we need a Node having label " + requiredLabel);
return false;
} else {
logProvision(logger, " true - Node has capacity - can use it");
returnNode[0] = node;
return true;
}
}
}
logProvision(logger, " true - Instance has no node, but can be used");
return true;
}
public EcsTaskTemplate getTemplate(Label label) {
if (label == null && templates.size() > 0) {
return templates.get(0);
}
for (EcsTaskTemplate t : templates) {
if (label.matches(t.getLabelSet())) {
return t;
}
}
return null;
}
/**
* Check if the label in the slave matches the provided label, either both are null or are the
* same.
*
* @param label
* @return Whether the slave label matches.
*/
public boolean matchesLabel(@CheckForNull Label label) {
if (label == null || getLabelString() == null) {
return label == null && getLabelString() == null;
}
if (label.matches(Label.parse(getLabelString()))) {
return true;
}
if (containerInfo == null || !containerInfo.getDockerImageCustomizable()) {
return false;
}
String customImage = getCustomImage(label);
return customImage != null
&& getLabelWithoutCustomImage(label, customImage).matches(Label.parse(getLabelString()));
}
@Override
public Collection<PlannedNode> provision(Label label, int excessWorkload) {
try {
// Count number of pending executors from spot requests
for (EC2SpotSlave n : NodeIterator.nodes(EC2SpotSlave.class)) {
// If the slave is online then it is already counted by Jenkins
// We only want to count potential additional Spot instance
// slaves
if (n.getComputer().isOffline() && label.matches(n.getAssignedLabels())) {
DescribeSpotInstanceRequestsRequest dsir =
new DescribeSpotInstanceRequestsRequest()
.withSpotInstanceRequestIds(n.getSpotInstanceRequestId());
for (SpotInstanceRequest sir :
connect().describeSpotInstanceRequests(dsir).getSpotInstanceRequests()) {
// Count Spot requests that are open and still have a
// chance to be active
// A request can be active and not yet registered as a
// slave. We check above
// to ensure only unregistered slaves get counted
if (sir.getState().equals("open") || sir.getState().equals("active")) {
excessWorkload -= n.getNumExecutors();
}
}
}
}
LOGGER.log(Level.INFO, "Excess workload after pending Spot instances: " + excessWorkload);
List<PlannedNode> r = new ArrayList<PlannedNode>();
final SlaveTemplate t = getTemplate(label);
int amiCap = t.getInstanceCap();
while (excessWorkload > 0) {
if (!addProvisionedSlave(t.ami, amiCap, t.description)) {
break;
}
r.add(
new PlannedNode(
t.getDisplayName(),
Computer.threadPoolForRemoting.submit(
new Callable<Node>() {
public Node call() throws Exception {
// TODO: record the output somewhere
try {
EC2AbstractSlave s = t.provision(StreamTaskListener.fromStdout());
Hudson.getInstance().addNode(s);
// EC2 instances may have a long init script. If we
// declare
// the provisioning complete by returning without
// the connect
// operation, NodeProvisioner may decide that it
// still wants
// one more instance, because it sees that (1) all
// the slaves
// are offline (because it's still being launched)
// and
// (2) there's no capacity provisioned yet.
//
// deferring the completion of provisioning until
// the launch
// goes successful prevents this problem.
s.toComputer().connect(false).get();
return s;
} finally {
decrementAmiSlaveProvision(t.ami);
}
}
}),
t.getNumExecutors()));
excessWorkload -= t.getNumExecutors();
}
return r;
} catch (AmazonClientException e) {
LOGGER.log(Level.WARNING, "Failed to count the # of live instances on EC2", e);
return Collections.emptyList();
}
}