def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
reasons: List[str] = []
xor_result: Optional[SatisfiedResult] = None
for n, c in enumerate(self.constraints):
expr_result = c.satisfied_by_node(node)
if expr_result:
# true ^ true == false
if xor_result:
msg = "Multiple expressions evaluated as true. See below:\n\t{}\n\t{}".format(
xor_result.message, expr_result.message)
return SatisfiedResult(
"XORFailed",
self,
node,
[msg] + reasons,
)
# assign the first true expression as the final result
xor_result = expr_result
elif hasattr(expr_result, "reasons"):
# if this does end up failing for all expressions, keep
# track of the set of reasons
reasons.extend(expr_result.reasons)
if xor_result:
return xor_result
return SatisfiedResult("CompoundFailure", self, node, reasons)
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
if node.memory / node.vcpu_count > 8:
return SatisfiedResult("success", self, node)
return SatisfiedResult(
"failed", self, node, reasons=["Not enough memory per core"],
)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
if self.resource_name not in node.resources:
return SatisfiedResult(
"MissingResourceForAlias",
self,
node,
reasons=[
"{} does not have resource {}".format(
node, self.resource_name)
],
)
return SatisfiedResult("success", self, node)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
# TODO clean up
if node.assignments or node.closed:
if self.job_exclusive or self.assignment_id not in node.assignments:
msg = "[name={} hostname={}] already has an exclusive job: {}".format(
node.name, node.hostname, node.assignments)
return SatisfiedResult(
"ExclusiveRequirementFailed",
self,
node,
[msg],
)
return SatisfiedResult("success", self, node)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
if node.placement_group:
return SatisfiedResult(
"success",
self,
node,
)
msg = "Node[name={} hostname={}] is not in a placement group".format(
node.name, node.hostname)
return SatisfiedResult(
"NotInAPlacementGroup",
self,
node,
[msg],
)
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
user_list = node.resources.get("owner")
if user_list is None:
user_list = self.user_list
if self.user in user_list:
return SatisfiedResult("success", self, node)
msg = "{} does not include user {} in its user list {}".format(
node, self.user, self.user_list)
return SatisfiedResult(
"InvalidUser",
self,
node,
reasons=[msg],
)
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
project_list = node.resources.get("project")
if project_list is None:
project_list = self.project_list
if self.project in project_list:
return SatisfiedResult("success", self, node)
msg = "{} does not include project {} in its project list {}".format(
node, self.project, project_list)
return SatisfiedResult(
"InvalidUser",
self,
node,
reasons=[msg],
)
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
xproject_list = node.resources.get("xproject")
if xproject_list is None:
xproject_list = self.xproject_list
# it is not excluded
if self.project not in xproject_list:
return SatisfiedResult("success", self, node)
msg = "{} has project {} in its xproject list {}".format(
node, self.project, xproject_list)
return SatisfiedResult(
"ExcludedProject",
self,
node,
reasons=[msg],
)
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
xuser_list = node.resources.get("xowner")
if xuser_list is None:
xuser_list = self.xuser_list
# it is not excluded
if self.user not in xuser_list:
return SatisfiedResult("success", self, node)
msg = "{} has user {} in its xuser list {}".format(
node, self.user, xuser_list)
return SatisfiedResult(
"ExcludedUser",
self,
node,
reasons=[msg],
)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
for c in self.constraints:
result = c.satisfied_by_node(node)
if not result:
return result
return SatisfiedResult("success", self, node)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
reasons: List[str] = []
for n, c in enumerate(self.constraints):
result = c.satisfied_by_node(node)
if result:
return SatisfiedResult(
"success",
self,
node,
score=len(self.constraints) - n,
)
if hasattr(result, "reasons"):
reasons.extend(result.reasons)
return SatisfiedResult("CompoundFailure", self, node, reasons)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
err_msg = self._satisfied(node)
if err_msg:
return SatisfiedResult(
"InvalidOption",
self,
node,
[err_msg],
)
# our score is our inverted index - i.e. the first element is the highest score
target = getattr(node, self.attr)
score = len(self.values) - self.values.index(target)
return SatisfiedResult(
"success",
self,
node,
score=score,
)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
if self.attr not in node.available:
# TODO log
msg = "Resource[name={}] is not defined for Node[name={}]".format(
self.attr, node.name)
return SatisfiedResult(
"UndefinedResource",
self,
node,
[msg],
)
try:
if node.available[self.attr] >= self.value:
return SatisfiedResult(
"success",
self,
node,
)
except TypeError as e:
logging.warning(
"For attribute %s: Could not evaluate %s >= %s because they are different types: %s",
self.attr,
node.available[self.attr],
self.value,
e,
)
msg = "Resource[name={} value={}] < Node[name={} value={}]".format(
self.attr,
self.value,
node.name,
node.available[self.attr],
)
return SatisfiedResult(
"InsufficientResource",
self,
node,
reasons=[msg],
)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
if self.attr not in node.available:
return SatisfiedResult(
"UndefinedResource",
self,
node,
[
"Resource[name={}] not defined for Node[name={} hostname={}]"
.format(self.attr, node.name, node.hostname)
],
)
target = node.available[self.attr]
if target not in self.values:
if len(self.values) > 1:
msg = "Resource[name={} value={}] is not one of the options {} for node[name={} attr={}]".format(
self.attr,
target,
self.values,
node.name,
self.attr,
)
else:
msg = "Resource[name={} value={}] != node[name={} {}={}]".format(
self.attr, target, node.name, self.attr, self.values[0])
return SatisfiedResult(
"InvalidOption",
self,
node,
[msg],
)
# so we want
score = len(self.values) - self.values.index(target) + 1
return SatisfiedResult(
"success",
self,
node,
score=score,
)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
if node._allocated:
return SatisfiedResult("AlreadyAllocated", self, node)
return SatisfiedResult("success", self, node)
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
result = self.condition.satisfied_by_node(node)
# TODO ugly
status = "success" if not result else "not(success)"
return SatisfiedResult(status, self, node, [str(self)])
def satisfied_by_node(self, node: Node) -> SatisfiedResult:
return SatisfiedResult("success")
def satisfied_by_node(self, node: "Node") -> SatisfiedResult:
return SatisfiedResult("Never", self, node, reasons=[self.message])
