def op_element_to_dto(
op_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None
) -> CibResourceOperationDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
return CibResourceOperationDto(
id=str(op_element.attrib["id"]),
name=str(op_element.attrib["name"]),
interval=str(op_element.attrib["interval"]),
description=op_element.get("description"),
start_delay=op_element.get("start-delay"),
interval_origin=op_element.get("interval-origin"),
timeout=op_element.get("timeout"),
enabled=get_optional_value(is_true, op_element.get("enabled")),
record_pending=get_optional_value(is_true,
op_element.get("record-pending")),
role=get_optional_value(
lambda _role: role.get_value_primary(const.PcmkRoleType(_role)),
op_element.get("role"),
),
on_fail=get_optional_value(const.PcmkOnFailAction,
op_element.get("on-fail")),
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval) for nvset in
nvpair_multi.find_nvsets(op_element, nvpair_multi.NVSET_META)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval) for nvset in
nvpair_multi.find_nvsets(op_element, nvpair_multi.NVSET_INSTANCE)
],
)
def primitive_element_to_dto(
primitive_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None,
) -> CibResourcePrimitiveDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
return CibResourcePrimitiveDto(
id=str(primitive_element.attrib["id"]),
agent_name=ResourceAgentNameDto(
standard=str(primitive_element.attrib["class"]),
provider=primitive_element.get("provider"),
type=str(primitive_element.attrib["type"]),
),
description=primitive_element.get("description"),
operations=[
op_element_to_dto(op_element, rule_eval)
for op_element in primitive_element.findall("operations/op")
],
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(primitive_element,
nvpair_multi.NVSET_META)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(primitive_element,
nvpair_multi.NVSET_INSTANCE)
],
utilization=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(
primitive_element, nvpair_multi.NVSET_UTILIZATION)
],
)
def test_instance(self):
self.assertEqual(
["set2", "set6"],
[
el.get("id") for el in nvpair_multi.find_nvsets(
self.xml, nvpair_multi.NVSET_INSTANCE)
],
)
def test_meta(self):
self.assertEqual(
["set1", "set5"],
[
el.get("id") for el in nvpair_multi.find_nvsets(
self.xml, nvpair_multi.NVSET_META)
],
)
def _defaults_config(
env: LibraryEnvironment,
cib_section_name: str,
) -> List[CibNvsetDto]:
return [
nvpair_multi.nvset_element_to_dto(nvset_el)
for nvset_el in nvpair_multi.find_nvsets(
sections.get(env.get_cib(), cib_section_name))
]
def clone_element_to_dto(
clone_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None,
) -> CibResourceCloneDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
return CibResourceCloneDto(
id=str(clone_element.attrib["id"]),
description=clone_element.get("description"),
member_id=str(get_inner_resource(clone_element).attrib["id"]),
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval) for nvset in
nvpair_multi.find_nvsets(clone_element, nvpair_multi.NVSET_META)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(clone_element,
nvpair_multi.NVSET_INSTANCE)
],
)
def _defaults_config(
cib: _Element,
nvset_tag: nvpair_multi.NvsetTag,
cib_section_name: str,
rule_evaluator: RuleInEffectEval,
) -> List[CibNvsetDto]:
return [
nvpair_multi.nvset_element_to_dto(nvset_el, rule_evaluator)
for nvset_el in nvpair_multi.find_nvsets(
sections.get(cib, cib_section_name), nvset_tag)
]
def test_full(self):
xml = etree.fromstring("""
<parent>
<meta_attributes id="set1" />
<instance_attributes id="set2" />
<not_an_nvset id="set3" />
</parent>
""")
self.assertEqual(
["set1", "set2"],
[el.get("id") for el in nvpair_multi.find_nvsets(xml)],
)
def group_element_to_dto(
group_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None,
) -> CibResourceGroupDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
return CibResourceGroupDto(
id=str(group_element.attrib["id"]),
description=group_element.get("description"),
member_ids=[
str(primitive_el.attrib["id"])
for primitive_el in get_inner_resources(group_element)
],
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval) for nvset in
nvpair_multi.find_nvsets(group_element, nvpair_multi.NVSET_META)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(group_element,
nvpair_multi.NVSET_INSTANCE)
],
)
def _defaults_config(env: LibraryEnvironment, cib_section_name: str,
evaluate_expired: bool) -> List[CibNvsetDto]:
runner = env.cmd_runner()
cib = env.get_cib()
if evaluate_expired:
if has_rule_in_effect_status_tool():
in_effect_eval: RuleInEffectEval = RuleInEffectEvalOneByOne(
cib, runner)
else:
in_effect_eval = RuleInEffectEvalDummy()
env.report_processor.report(
ReportItem.warning(reports.messages.
RuleInEffectStatusDetectionNotSupported()))
else:
in_effect_eval = RuleInEffectEvalDummy()
return [
nvpair_multi.nvset_element_to_dto(nvset_el, in_effect_eval)
for nvset_el in nvpair_multi.find_nvsets(
sections.get(cib, cib_section_name))
]
def bundle_element_to_dto(
bundle_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None,
) -> bundle.CibResourceBundleDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
primitive_el = get_inner_resource(bundle_element)
runtime_el = _get_container_element(bundle_element)
network_el = bundle_element.find("network")
return bundle.CibResourceBundleDto(
id=str(bundle_element.attrib["id"]),
description=bundle_element.get("description"),
member_id=(
str(primitive_el.attrib["id"]) if primitive_el is not None else None
),
container_type=(
bundle.ContainerType(runtime_el.tag)
if runtime_el is not None
else None
),
container_options=(
bundle.CibResourceBundleContainerRuntimeOptionsDto(
image=str(runtime_el.attrib["image"]),
replicas=get_optional_value(int, runtime_el.get("replicas")),
replicas_per_host=get_optional_value(
int, runtime_el.get("replicas-per-host")
),
promoted_max=get_optional_value(
int,
runtime_el.get("promoted-max") or runtime_el.get("masters"),
),
run_command=runtime_el.get("run-command"),
network=runtime_el.get("network"),
options=runtime_el.get("options"),
)
if runtime_el is not None
else None
),
network=(
_bundle_network_element_to_dto(network_el)
if network_el is not None
else None
),
port_mappings=[
bundle.CibResourceBundlePortMappingDto(
id=str(net_map_el.attrib["id"]),
port=get_optional_value(int, net_map_el.get("port")),
internal_port=get_optional_value(
int, net_map_el.get("internal-port")
),
range=net_map_el.get("range"),
)
for net_map_el in bundle_element.findall("network/port-mapping")
],
storage_mappings=[
bundle.CibResourceBundleStorageMappingDto(
id=str(storage_el.attrib["id"]),
source_dir=storage_el.get("source-dir"),
source_dir_root=storage_el.get("source-dir-root"),
target_dir=str(storage_el.attrib["target-dir"]),
options=storage_el.get("options"),
)
for storage_el in bundle_element.findall("storage/storage-mapping")
],
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(
bundle_element, nvpair_multi.NVSET_META
)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(
bundle_element, nvpair_multi.NVSET_INSTANCE
)
],
)
def _defaults_update(
env: LibraryEnvironment,
cib_section_name: str,
nvset_id: Optional[str],
nvpairs: Mapping[str, str],
pcs_command: reports.types.PcsCommand,
) -> None:
cib = env.get_cib()
id_provider = IdProvider(cib)
if nvset_id is None:
# Backward compatibility code to support an old use case where no id
# was requested and provided and the first meta_attributes nvset was
# created / updated. However, we check that there is only one nvset
# present in the CIB to prevent breaking the configuration with
# multiple nvsets in place.
# This is to be supported as it provides means of easily managing
# defaults if only one set of defaults is needed.
# TODO move this to a separate lib command.
if not nvpairs:
return
# Do not create new defaults element if we are only removing values
# from it.
only_removing = True
for value in nvpairs.values():
if value != "":
only_removing = False
break
if only_removing and not sections.exists(cib, cib_section_name):
env.report_processor.report(
ReportItem.warning(reports.messages.DefaultsCanBeOverriden()))
return
nvset_elements = nvpair_multi.find_nvsets(
sections.get(cib, cib_section_name))
if len(nvset_elements) > 1:
env.report_processor.report(
reports.item.ReportItem.error(
reports.messages.CibNvsetAmbiguousProvideNvsetId(
pcs_command)))
raise LibraryError()
env.report_processor.report(
ReportItem.warning(reports.messages.DefaultsCanBeOverriden()))
if len(nvset_elements) == 1:
nvpair_multi.nvset_update(nvset_elements[0], id_provider, nvpairs)
elif only_removing:
# do not create new nvset if there is none and we are only removing
# nvpairs
return
else:
nvpair_multi.nvset_append_new(
sections.get(cib, cib_section_name),
id_provider,
nvpair_multi.NVSET_META,
nvpairs,
{},
)
env.push_cib()
return
nvset_elements, report_list = nvpair_multi.find_nvsets_by_ids(
sections.get(cib, cib_section_name), [nvset_id])
if env.report_processor.report_list(report_list).has_errors:
raise LibraryError()
nvpair_multi.nvset_update(nvset_elements[0], id_provider, nvpairs)
env.report_processor.report(
ReportItem.warning(reports.messages.DefaultsCanBeOverriden()))
env.push_cib()
def test_empty(self):
xml = etree.fromstring("<parent />")
self.assertEqual([], nvpair_multi.find_nvsets(xml))
