def location_show(lib, argv, modifiers):
"""
Options:
* --all - print expired constraints
* --full - print all details
* -f - CIB file
"""
del lib
modifiers.ensure_only_supported("-f", "--full", "--all")
by_node = False
if argv and argv[0] == "nodes":
by_node = True
if len(argv) > 1:
if by_node:
valid_noderes = argv[1:]
else:
valid_noderes = [
parse_args.parse_typed_arg(
arg, [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE) for arg in argv[1:]
]
else:
valid_noderes = []
(dummy_dom, constraintsElement) = getCurrentConstraints()
print("\n".join(
location_lines(
constraintsElement,
showDetail=modifiers.get("--full"),
byNode=by_node,
valid_noderes=valid_noderes,
show_expired=modifiers.get("--all"),
)))
def stonith_level_parse_node(arg):
target_type_candidate, target_value_candidate = parse_args.parse_typed_arg(
arg, target_type_map_cli_to_lib.keys(), "node")
target_type = target_type_map_cli_to_lib[target_type_candidate]
if target_type == TARGET_TYPE_ATTRIBUTE:
target_value = parse_args.split_option(target_value_candidate)
else:
target_value = target_value_candidate
return target_type, target_value
def stonith_level_parse_node(arg):
target_type_candidate, target_value_candidate = parse_args.parse_typed_arg(
arg,
target_type_map_cli_to_lib.keys(),
"node"
)
target_type = target_type_map_cli_to_lib[target_type_candidate]
if target_type == TARGET_TYPE_ATTRIBUTE:
target_value = parse_args.split_option(target_value_candidate)
else:
target_value = target_value_candidate
return target_type, target_value
def location_prefer(lib, argv, modifiers):
"""
Options:
* --force - allow unknown options, allow constraint for any resource type
* -f - CIB file
"""
modifiers.ensure_only_supported("--force", "-f")
rsc = argv.pop(0)
prefer_option = argv.pop(0)
dummy_rsc_type, rsc_value = parse_args.parse_typed_arg(
rsc, [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE)
if prefer_option == "prefers":
prefer = True
elif prefer_option == "avoids":
prefer = False
else:
raise CmdLineInputError()
for nodeconf in argv:
nodeconf_a = nodeconf.split("=", 1)
if len(nodeconf_a) == 1:
node = nodeconf_a[0]
if prefer:
score = "INFINITY"
else:
score = "-INFINITY"
else:
score = nodeconf_a[1]
if not utils.is_score(score):
utils.err(
"invalid score '%s', use integer or INFINITY or -INFINITY"
% score)
if not prefer:
if score[0] == "-":
score = score[1:]
else:
score = "-" + score
node = nodeconf_a[0]
location_add(lib, [
sanitize_id("location-{0}-{1}-{2}".format(rsc_value, node, score)),
rsc, node, score
], modifiers.get_subset("--force", "-f"))
def location_prefer(argv):
rsc = argv.pop(0)
prefer_option = argv.pop(0)
dummy_rsc_type, rsc_value = parse_args.parse_typed_arg(
rsc,
[RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE
)
if prefer_option == "prefers":
prefer = True
elif prefer_option == "avoids":
prefer = False
else:
usage.constraint()
sys.exit(1)
for nodeconf in argv:
nodeconf_a = nodeconf.split("=",1)
if len(nodeconf_a) == 1:
node = nodeconf_a[0]
if prefer:
score = "INFINITY"
else:
score = "-INFINITY"
else:
score = nodeconf_a[1]
if not utils.is_score(score):
utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" % score)
if not prefer:
if score[0] == "-":
score = score[1:]
else:
score = "-" + score
node = nodeconf_a[0]
location_add([
sanitize_id("location-{0}-{1}-{2}".format(rsc_value, node, score)),
rsc,
node,
score
])
def assert_parse(self, arg, parsed):
self.assertEqual(parse_typed_arg(arg, ["t0", "t1", "t2"], "t0"),
parsed)
def location_rule(lib, argv, modifiers):
"""
Options:
* -f - CIB file
* --force - allow constraint on any resource type, allow duplicate
constraints
"""
del lib
modifiers.ensure_only_supported("-f", "--force")
if len(argv) < 3:
usage.constraint(["location", "rule"])
sys.exit(1)
rsc_type, rsc_value = parse_args.parse_typed_arg(
argv.pop(0), [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE)
argv.pop(0) # pop "rule"
options, rule_argv = rule_utils.parse_argv(argv, {
"constraint-id": None,
"resource-discovery": None,
})
resource_discovery = ("resource-discovery" in options
and options["resource-discovery"])
required_version = None
if resource_discovery:
required_version = 2, 2, 0
if rsc_type == RESOURCE_TYPE_REGEXP:
required_version = 2, 6, 0
if required_version:
dom = utils.cluster_upgrade_to_version(required_version)
else:
dom = utils.get_cib_dom()
if rsc_type == RESOURCE_TYPE_RESOURCE:
rsc_valid, rsc_error, dummy_correct_id = (
utils.validate_constraint_resource(dom, rsc_value))
if not rsc_valid:
utils.err(rsc_error)
cib, constraints = getCurrentConstraints(dom)
lc = cib.createElement("rsc_location")
# If resource-discovery is specified, we use it with the rsc_location
# element not the rule
if resource_discovery:
lc.setAttribute("resource-discovery",
options.pop("resource-discovery"))
constraints.appendChild(lc)
if options.get("constraint-id"):
id_valid, id_error = utils.validate_xml_id(options["constraint-id"],
'constraint id')
if not id_valid:
utils.err(id_error)
if utils.does_id_exist(dom, options["constraint-id"]):
utils.err("id '%s' is already in use, please specify another one" %
options["constraint-id"])
lc.setAttribute("id", options["constraint-id"])
del options["constraint-id"]
else:
lc.setAttribute(
"id",
utils.find_unique_id(dom, sanitize_id("location-" + rsc_value)))
if rsc_type == RESOURCE_TYPE_RESOURCE:
lc.setAttribute("rsc", rsc_value)
elif rsc_type == RESOURCE_TYPE_REGEXP:
lc.setAttribute("rsc-pattern", rsc_value)
rule_utils.dom_rule_add(lc, options, rule_argv)
location_rule_check_duplicates(constraints, lc, modifiers.get("--force"))
utils.replace_cib_configuration(cib)
def location_add(lib, argv, modifiers):
"""
Options:
* --force - allow unknown options, allow constraint for any resource type
* -f - CIB file
"""
del lib
modifiers.ensure_only_supported("--force", "-f")
if len(argv) < 4:
raise CmdLineInputError()
constraint_id = argv.pop(0)
rsc_type, rsc_value = parse_args.parse_typed_arg(
argv.pop(0), [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE)
node = argv.pop(0)
score = argv.pop(0)
options = []
# For now we only allow setting resource-discovery
if argv:
for arg in argv:
if '=' in arg:
options.append(arg.split('=', 1))
else:
raise CmdLineInputError(f"bad option '{arg}'")
if (options[-1][0] != "resource-discovery"
and not modifiers.get("--force")):
utils.err("bad option '%s', use --force to override" %
options[-1][0])
id_valid, id_error = utils.validate_xml_id(constraint_id, 'constraint id')
if not id_valid:
utils.err(id_error)
if not utils.is_score(score):
utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" %
score)
required_version = None
if [x for x in options if x[0] == "resource-discovery"]:
required_version = 2, 2, 0
if rsc_type == RESOURCE_TYPE_REGEXP:
required_version = 2, 6, 0
if required_version:
dom = utils.cluster_upgrade_to_version(required_version)
else:
dom = utils.get_cib_dom()
if rsc_type == RESOURCE_TYPE_RESOURCE:
rsc_valid, rsc_error, dummy_correct_id = (
utils.validate_constraint_resource(dom, rsc_value))
if not rsc_valid:
utils.err(rsc_error)
# Verify that specified node exists in the cluster
if not (modifiers.is_specified("-f") or modifiers.get("--force")):
lib_env = utils.get_lib_env()
existing_nodes = get_existing_nodes_names(
corosync_conf=lib_env.get_corosync_conf(),
cib=lib_env.get_cib(),
)
if node not in existing_nodes:
raise error(f"Node '{node}' does not seem to be in the cluster"
", use --force to override")
else:
warn(LOCATION_NODE_VALIDATION_SKIP_MSG)
# Verify current constraint doesn't already exist
# If it does we replace it with the new constraint
dummy_dom, constraintsElement = getCurrentConstraints(dom)
elementsToRemove = []
# If the id matches, or the rsc & node match, then we replace/remove
for rsc_loc in constraintsElement.getElementsByTagName('rsc_location'):
# pylint: disable=too-many-boolean-expressions
if (rsc_loc.getAttribute("id") == constraint_id
or (rsc_loc.getAttribute("node") == node and
((RESOURCE_TYPE_RESOURCE == rsc_type
and rsc_loc.getAttribute("rsc") == rsc_value) or
(RESOURCE_TYPE_REGEXP == rsc_type
and rsc_loc.getAttribute("rsc-pattern") == rsc_value)))):
elementsToRemove.append(rsc_loc)
for etr in elementsToRemove:
constraintsElement.removeChild(etr)
element = dom.createElement("rsc_location")
element.setAttribute("id", constraint_id)
if rsc_type == RESOURCE_TYPE_RESOURCE:
element.setAttribute("rsc", rsc_value)
elif rsc_type == RESOURCE_TYPE_REGEXP:
element.setAttribute("rsc-pattern", rsc_value)
element.setAttribute("node", node)
element.setAttribute("score", score)
for option in options:
element.setAttribute(option[0], option[1])
constraintsElement.appendChild(element)
utils.replace_cib_configuration(dom)
def assert_parse(self, arg, parsed):
self.assertEqual(
parse_typed_arg(arg, ["t0", "t1", "t2"], "t0"),
parsed
)
def location_add(argv, rm=False):
if rm:
location_remove(argv)
return
if len(argv) < 4:
usage.constraint(["location add"])
sys.exit(1)
constraint_id = argv.pop(0)
rsc_type, rsc_value = parse_args.parse_typed_arg(
argv.pop(0), [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE)
node = argv.pop(0)
score = argv.pop(0)
options = []
# For now we only allow setting resource-discovery
if len(argv) > 0:
for arg in argv:
if '=' in arg:
options.append(arg.split('=', 1))
else:
print("Error: bad option '%s'" % arg)
usage.constraint(["location add"])
sys.exit(1)
if options[-1][
0] != "resource-discovery" and "--force" not in utils.pcs_options:
utils.err("bad option '%s', use --force to override" %
options[-1][0])
id_valid, id_error = utils.validate_xml_id(constraint_id, 'constraint id')
if not id_valid:
utils.err(id_error)
if not utils.is_score(score):
utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" %
score)
required_version = None
if [x for x in options if x[0] == "resource-discovery"]:
required_version = 2, 2, 0
if rsc_type == RESOURCE_TYPE_REGEXP:
required_version = 2, 6, 0
if required_version:
dom = utils.cluster_upgrade_to_version(required_version)
else:
dom = utils.get_cib_dom()
if rsc_type == RESOURCE_TYPE_RESOURCE:
rsc_valid, rsc_error, correct_id = utils.validate_constraint_resource(
dom, rsc_value)
if "--autocorrect" in utils.pcs_options and correct_id:
rsc_value = correct_id
elif not rsc_valid:
utils.err(rsc_error)
# Verify current constraint doesn't already exist
# If it does we replace it with the new constraint
dummy_dom, constraintsElement = getCurrentConstraints(dom)
elementsToRemove = []
# If the id matches, or the rsc & node match, then we replace/remove
for rsc_loc in constraintsElement.getElementsByTagName('rsc_location'):
if (rsc_loc.getAttribute("id") == constraint_id
or (rsc_loc.getAttribute("node") == node and
((RESOURCE_TYPE_RESOURCE == rsc_type
and rsc_loc.getAttribute("rsc") == rsc_value) or
(RESOURCE_TYPE_REGEXP == rsc_type
and rsc_loc.getAttribute("rsc-pattern") == rsc_value)))):
elementsToRemove.append(rsc_loc)
for etr in elementsToRemove:
constraintsElement.removeChild(etr)
element = dom.createElement("rsc_location")
element.setAttribute("id", constraint_id)
if rsc_type == RESOURCE_TYPE_RESOURCE:
element.setAttribute("rsc", rsc_value)
elif rsc_type == RESOURCE_TYPE_REGEXP:
element.setAttribute("rsc-pattern", rsc_value)
element.setAttribute("node", node)
element.setAttribute("score", score)
for option in options:
element.setAttribute(option[0], option[1])
constraintsElement.appendChild(element)
utils.replace_cib_configuration(dom)
def location_show(argv):
if (len(argv) != 0 and argv[0] == "nodes"):
byNode = True
showDetail = False
elif "--full" in utils.pcs_options:
byNode = False
showDetail = True
else:
byNode = False
showDetail = False
if len(argv) > 1:
if byNode:
valid_noderes = argv[1:]
else:
valid_noderes = [
parse_args.parse_typed_arg(
arg, [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE) for arg in argv[1:]
]
else:
valid_noderes = []
(dummy_dom, constraintsElement) = getCurrentConstraints()
nodehashon = {}
nodehashoff = {}
rschashon = {}
rschashoff = {}
ruleshash = defaultdict(list)
all_loc_constraints = constraintsElement.getElementsByTagName(
'rsc_location')
print("Location Constraints:")
for rsc_loc in all_loc_constraints:
if rsc_loc.hasAttribute("rsc-pattern"):
lc_rsc_type = RESOURCE_TYPE_REGEXP
lc_rsc_value = rsc_loc.getAttribute("rsc-pattern")
lc_name = "Resource pattern: {0}".format(lc_rsc_value)
else:
lc_rsc_type = RESOURCE_TYPE_RESOURCE
lc_rsc_value = rsc_loc.getAttribute("rsc")
lc_name = "Resource: {0}".format(lc_rsc_value)
lc_rsc = lc_rsc_type, lc_rsc_value, lc_name
lc_id = rsc_loc.getAttribute("id")
lc_node = rsc_loc.getAttribute("node")
lc_score = rsc_loc.getAttribute("score")
lc_role = rsc_loc.getAttribute("role")
lc_resource_discovery = rsc_loc.getAttribute("resource-discovery")
for child in rsc_loc.childNodes:
if child.nodeType == child.ELEMENT_NODE and child.tagName == "rule":
ruleshash[lc_rsc].append(child)
# NEED TO FIX FOR GROUP LOCATION CONSTRAINTS (where there are children of
# rsc_location)
if lc_score == "":
lc_score = "0"
if lc_score == "INFINITY":
positive = True
elif lc_score == "-INFINITY":
positive = False
elif int(lc_score) >= 0:
positive = True
else:
positive = False
if positive == True:
nodeshash = nodehashon
rschash = rschashon
else:
nodeshash = nodehashoff
rschash = rschashoff
hash_element = {
"id": lc_id,
"rsc_type": lc_rsc_type,
"rsc_value": lc_rsc_value,
"rsc_label": lc_name,
"node": lc_node,
"score": lc_score,
"role": lc_role,
"resource-discovery": lc_resource_discovery,
}
if lc_node in nodeshash:
nodeshash[lc_node].append(hash_element)
else:
nodeshash[lc_node] = [hash_element]
if lc_rsc in rschash:
rschash[lc_rsc].append(hash_element)
else:
rschash[lc_rsc] = [hash_element]
nodelist = sorted(set(list(nodehashon.keys()) + list(nodehashoff.keys())))
rsclist = sorted(set(list(rschashon.keys()) + list(rschashoff.keys())),
key=lambda item: ({
RESOURCE_TYPE_RESOURCE: 1,
RESOURCE_TYPE_REGEXP: 0,
}[item[0]], item[1]))
if byNode == True:
for node in nodelist:
if len(valid_noderes) != 0:
if node not in valid_noderes:
continue
print(" Node: " + node)
nodehash_label = ((nodehashon, " Allowed to run:"),
(nodehashoff, " Not allowed to run:"))
for nodehash, label in nodehash_label:
if node in nodehash:
print(label)
for options in nodehash[node]:
line_parts = [(" " + options["rsc_label"] + " (" +
options["id"] + ")")]
if options["role"]:
line_parts.append("(role: {0})".format(
options["role"]))
if options["resource-discovery"]:
line_parts.append(
"(resource-discovery={0})".format(
options["resource-discovery"]))
line_parts.append("Score: " + options["score"])
print(" ".join(line_parts))
show_location_rules(ruleshash, showDetail)
else:
for rsc in rsclist:
if len(valid_noderes) != 0:
if rsc[0:2] not in valid_noderes:
continue
print(" {0}".format(rsc[2]))
rschash_label = (
(rschashon, " Enabled on:"),
(rschashoff, " Disabled on:"),
)
for rschash, label in rschash_label:
if rsc in rschash:
for options in rschash[rsc]:
if not options["node"]:
continue
line_parts = [
label,
options["node"],
"(score:{0})".format(options["score"]),
]
if options["role"]:
line_parts.append("(role: {0})".format(
options["role"]))
if options["resource-discovery"]:
line_parts.append(
"(resource-discovery={0})".format(
options["resource-discovery"]))
if showDetail:
line_parts.append("(id:{0})".format(options["id"]))
print(" ".join(line_parts))
miniruleshash = {}
miniruleshash[rsc] = ruleshash[rsc]
show_location_rules(miniruleshash, showDetail, True)
def location_prefer(lib, argv, modifiers):
"""
Options:
* --force - allow unknown options, allow constraint for any resource type
* -f - CIB file
"""
modifiers.ensure_only_supported("--force", "-f")
rsc = argv.pop(0)
prefer_option = argv.pop(0)
dummy_rsc_type, rsc_value = parse_args.parse_typed_arg(
rsc, [RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE)
if prefer_option == "prefers":
prefer = True
elif prefer_option == "avoids":
prefer = False
else:
raise CmdLineInputError()
skip_node_check = False
if modifiers.is_specified("-f") or modifiers.get("--force"):
skip_node_check = True
warn(LOCATION_NODE_VALIDATION_SKIP_MSG)
else:
lib_env = utils.get_lib_env()
existing_nodes, report_list = get_existing_nodes_names(
corosync_conf=lib_env.get_corosync_conf(),
cib=lib_env.get_cib(),
)
if report_list:
process_library_reports(report_list)
report_list = []
parameters_list = []
for nodeconf in argv:
nodeconf_a = nodeconf.split("=", 1)
node = nodeconf_a[0]
if not skip_node_check:
report_list += _verify_node_name(node, existing_nodes)
if len(nodeconf_a) == 1:
if prefer:
score = "INFINITY"
else:
score = "-INFINITY"
else:
score = nodeconf_a[1]
_verify_score(score)
if not prefer:
if score[0] == "-":
score = score[1:]
else:
score = "-" + score
parameters_list.append([
sanitize_id(f"location-{rsc_value}-{node}-{score}"), rsc, node,
score
])
if report_list:
process_library_reports(report_list)
modifiers = modifiers.get_subset("--force", "-f")
for parameters in parameters_list:
location_add(lib,
parameters,
modifiers,
skip_score_and_node_check=True)
def location_rule(argv):
if len(argv) < 3:
usage.constraint(["location", "rule"])
sys.exit(1)
rsc_type, rsc_value = parse_args.parse_typed_arg(
argv.pop(0),
[RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE
)
argv.pop(0) # pop "rule"
options, rule_argv = rule_utils.parse_argv(
argv,
{
"constraint-id": None,
"resource-discovery": None,
}
)
resource_discovery = (
"resource-discovery" in options
and
options["resource-discovery"]
)
required_version = None
if resource_discovery:
required_version = 2, 2, 0
if rsc_type == RESOURCE_TYPE_REGEXP:
required_version = 2, 6, 0
if required_version:
dom = utils.cluster_upgrade_to_version(required_version)
else:
dom = utils.get_cib_dom()
if rsc_type == RESOURCE_TYPE_RESOURCE:
rsc_valid, rsc_error, correct_id = utils.validate_constraint_resource(
dom, rsc_value
)
if "--autocorrect" in utils.pcs_options and correct_id:
rsc_value = correct_id
elif not rsc_valid:
utils.err(rsc_error)
cib, constraints = getCurrentConstraints(dom)
lc = cib.createElement("rsc_location")
# If resource-discovery is specified, we use it with the rsc_location
# element not the rule
if resource_discovery:
lc.setAttribute("resource-discovery", options.pop("resource-discovery"))
constraints.appendChild(lc)
if options.get("constraint-id"):
id_valid, id_error = utils.validate_xml_id(
options["constraint-id"], 'constraint id'
)
if not id_valid:
utils.err(id_error)
if utils.does_id_exist(dom, options["constraint-id"]):
utils.err(
"id '%s' is already in use, please specify another one"
% options["constraint-id"]
)
lc.setAttribute("id", options["constraint-id"])
del options["constraint-id"]
else:
lc.setAttribute(
"id",
utils.find_unique_id(dom, sanitize_id("location-" + rsc_value))
)
if rsc_type == RESOURCE_TYPE_RESOURCE:
lc.setAttribute("rsc", rsc_value)
elif rsc_type == RESOURCE_TYPE_REGEXP:
lc.setAttribute("rsc-pattern", rsc_value)
rule_utils.dom_rule_add(lc, options, rule_argv)
location_rule_check_duplicates(constraints, lc)
utils.replace_cib_configuration(cib)
def location_add(argv,rm=False):
if rm:
location_remove(argv)
return
if len(argv) < 4:
usage.constraint(["location add"])
sys.exit(1)
constraint_id = argv.pop(0)
rsc_type, rsc_value = parse_args.parse_typed_arg(
argv.pop(0),
[RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE
)
node = argv.pop(0)
score = argv.pop(0)
options = []
# For now we only allow setting resource-discovery
if len(argv) > 0:
for arg in argv:
if '=' in arg:
options.append(arg.split('=',1))
else:
print("Error: bad option '%s'" % arg)
usage.constraint(["location add"])
sys.exit(1)
if options[-1][0] != "resource-discovery" and "--force" not in utils.pcs_options:
utils.err("bad option '%s', use --force to override" % options[-1][0])
id_valid, id_error = utils.validate_xml_id(constraint_id, 'constraint id')
if not id_valid:
utils.err(id_error)
if not utils.is_score(score):
utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" % score)
required_version = None
if rsc_type == RESOURCE_TYPE_REGEXP:
required_version = 2, 6, 0
if required_version:
dom = utils.cluster_upgrade_to_version(required_version)
else:
dom = utils.get_cib_dom()
if rsc_type == RESOURCE_TYPE_RESOURCE:
rsc_valid, rsc_error, correct_id = utils.validate_constraint_resource(
dom, rsc_value
)
if "--autocorrect" in utils.pcs_options and correct_id:
rsc_value = correct_id
elif not rsc_valid:
utils.err(rsc_error)
# Verify current constraint doesn't already exist
# If it does we replace it with the new constraint
dummy_dom, constraintsElement = getCurrentConstraints(dom)
elementsToRemove = []
# If the id matches, or the rsc & node match, then we replace/remove
for rsc_loc in constraintsElement.getElementsByTagName('rsc_location'):
if (
rsc_loc.getAttribute("id") == constraint_id
or
(
rsc_loc.getAttribute("node") == node
and
(
(
RESOURCE_TYPE_RESOURCE == rsc_type
and
rsc_loc.getAttribute("rsc") == rsc_value
)
or
(
RESOURCE_TYPE_REGEXP == rsc_type
and
rsc_loc.getAttribute("rsc-pattern") == rsc_value
)
)
)
):
elementsToRemove.append(rsc_loc)
for etr in elementsToRemove:
constraintsElement.removeChild(etr)
element = dom.createElement("rsc_location")
element.setAttribute("id",constraint_id)
if rsc_type == RESOURCE_TYPE_RESOURCE:
element.setAttribute("rsc", rsc_value)
elif rsc_type == RESOURCE_TYPE_REGEXP:
element.setAttribute("rsc-pattern", rsc_value)
element.setAttribute("node",node)
element.setAttribute("score",score)
for option in options:
element.setAttribute(option[0], option[1])
constraintsElement.appendChild(element)
utils.replace_cib_configuration(dom)
def location_show(argv):
if (len(argv) != 0 and argv[0] == "nodes"):
byNode = True
showDetail = False
elif "--full" in utils.pcs_options:
byNode = False
showDetail = True
else:
byNode = False
showDetail = False
if len(argv) > 1:
if byNode:
valid_noderes = argv[1:]
else:
valid_noderes = [
parse_args.parse_typed_arg(
arg,
[RESOURCE_TYPE_RESOURCE, RESOURCE_TYPE_REGEXP],
RESOURCE_TYPE_RESOURCE
)
for arg in argv[1:]
]
else:
valid_noderes = []
(dummy_dom,constraintsElement) = getCurrentConstraints()
nodehashon = {}
nodehashoff = {}
rschashon = {}
rschashoff = {}
ruleshash = defaultdict(list)
all_loc_constraints = constraintsElement.getElementsByTagName('rsc_location')
print("Location Constraints:")
for rsc_loc in all_loc_constraints:
if rsc_loc.hasAttribute("rsc-pattern"):
lc_rsc_type = RESOURCE_TYPE_REGEXP
lc_rsc_value = rsc_loc.getAttribute("rsc-pattern")
lc_name = "Resource pattern: {0}".format(lc_rsc_value)
else:
lc_rsc_type = RESOURCE_TYPE_RESOURCE
lc_rsc_value = rsc_loc.getAttribute("rsc")
lc_name = "Resource: {0}".format(lc_rsc_value)
lc_rsc = lc_rsc_type, lc_rsc_value, lc_name
lc_id = rsc_loc.getAttribute("id")
lc_node = rsc_loc.getAttribute("node")
lc_score = rsc_loc.getAttribute("score")
lc_role = rsc_loc.getAttribute("role")
lc_resource_discovery = rsc_loc.getAttribute("resource-discovery")
for child in rsc_loc.childNodes:
if child.nodeType == child.ELEMENT_NODE and child.tagName == "rule":
ruleshash[lc_rsc].append(child)
# NEED TO FIX FOR GROUP LOCATION CONSTRAINTS (where there are children of
# rsc_location)
if lc_score == "":
lc_score = "0"
if lc_score == "INFINITY":
positive = True
elif lc_score == "-INFINITY":
positive = False
elif int(lc_score) >= 0:
positive = True
else:
positive = False
if positive == True:
nodeshash = nodehashon
rschash = rschashon
else:
nodeshash = nodehashoff
rschash = rschashoff
hash_element = {
"id": lc_id,
"rsc_type": lc_rsc_type,
"rsc_value": lc_rsc_value,
"rsc_label": lc_name,
"node": lc_node,
"score": lc_score,
"role": lc_role,
"resource-discovery": lc_resource_discovery,
}
if lc_node in nodeshash:
nodeshash[lc_node].append(hash_element)
else:
nodeshash[lc_node] = [hash_element]
if lc_rsc in rschash:
rschash[lc_rsc].append(hash_element)
else:
rschash[lc_rsc] = [hash_element]
nodelist = sorted(set(list(nodehashon.keys()) + list(nodehashoff.keys())))
rsclist = sorted(
set(list(rschashon.keys()) + list(rschashoff.keys())),
key=lambda item: (
{
RESOURCE_TYPE_RESOURCE: 1,
RESOURCE_TYPE_REGEXP: 0,
}[item[0]],
item[1]
)
)
if byNode == True:
for node in nodelist:
if len(valid_noderes) != 0:
if node not in valid_noderes:
continue
print(" Node: " + node)
nodehash_label = (
(nodehashon, " Allowed to run:"),
(nodehashoff, " Not allowed to run:")
)
for nodehash, label in nodehash_label:
if node in nodehash:
print(label)
for options in nodehash[node]:
line_parts = [(
" " + options["rsc_label"]
+ " (" + options["id"] + ")"
)]
if options["role"]:
line_parts.append(
"(role: {0})".format(options["role"])
)
if options["resource-discovery"]:
line_parts.append(
"(resource-discovery={0})".format(
options["resource-discovery"]
)
)
line_parts.append("Score: " + options["score"])
print(" ".join(line_parts))
show_location_rules(ruleshash, showDetail)
else:
for rsc in rsclist:
if len(valid_noderes) != 0:
if rsc[0:2] not in valid_noderes:
continue
print(" {0}".format(rsc[2]))
rschash_label = (
(rschashon, " Enabled on:"),
(rschashoff, " Disabled on:"),
)
for rschash, label in rschash_label:
if rsc in rschash:
for options in rschash[rsc]:
if not options["node"]:
continue
line_parts = [
label,
options["node"],
"(score:{0})".format(options["score"]),
]
if options["role"]:
line_parts.append(
"(role: {0})".format(options["role"])
)
if options["resource-discovery"]:
line_parts.append(
"(resource-discovery={0})".format(
options["resource-discovery"]
)
)
if showDetail:
line_parts.append("(id:{0})".format(options["id"]))
print(" ".join(line_parts))
miniruleshash={}
miniruleshash[rsc] = ruleshash[rsc]
show_location_rules(miniruleshash, showDetail, True)
