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 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 test_minimal(self):
for tag, nvtype in self.tag_type:
with self.subTest(tag=tag, nvset_type=nvtype):
xml = etree.fromstring(f"""<{tag} id="my-id" />""")
self.assertEqual(
nvpair_multi.nvset_element_to_dto(xml),
CibNvsetDto("my-id", nvtype, {}, None, []),
)
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 test_minimal(self):
for tag in nvpair_multi.NVSETS_ALL:
with self.subTest(tag=tag):
xml = etree.fromstring(f"""<{tag} id="my-id" />""")
self.assertEqual(
nvpair_multi.nvset_element_to_dto(xml,
get_in_effect_eval()),
CibNvsetDto("my-id", {}, None, []),
)
def test_expired(self):
for tag, nvtype in self.tag_type:
with self.subTest(tag=tag, nvset_type=nvtype):
xml = etree.fromstring(
f"""
<{tag} id="my-id" score="150">
<rule id="my-id-rule" boolean-op="and">
<rsc_expression
id="my-id-rule-rsc-ocf-pacemaker-Dummy"
class="ocf" provider="pacemaker" type="Dummy"
/>
</rule>
<nvpair id="my-id-pair1" name="name1" value="value1" />
</{tag}>
"""
)
self.assertEqual(
nvpair_multi.nvset_element_to_dto(
xml,
get_in_effect_eval(
{"my-id-rule": CibRuleInEffectStatus.EXPIRED}
),
),
CibNvsetDto(
"my-id",
nvtype,
{"score": "150"},
CibRuleExpressionDto(
"my-id-rule",
CibRuleExpressionType.RULE,
CibRuleInEffectStatus.EXPIRED,
{"boolean-op": "and"},
None,
None,
[
CibRuleExpressionDto(
"my-id-rule-rsc-ocf-pacemaker-Dummy",
CibRuleExpressionType.RSC_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"class": "ocf",
"provider": "pacemaker",
"type": "Dummy",
},
None,
None,
[],
"resource ocf:pacemaker:Dummy",
),
],
"resource ocf:pacemaker:Dummy",
),
[CibNvpairDto("my-id-pair1", "name1", "value1")],
),
)
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 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 test_full(self):
for tag, nvtype in self.tag_type:
with self.subTest(tag=tag, nvset_type=nvtype):
xml = etree.fromstring(f"""
<{tag} id="my-id" score="150">
<rule id="my-id-rule" boolean-op="or">
<op_expression id="my-id-rule-op" name="monitor" />
</rule>
<nvpair id="my-id-pair1" name="name1" value="value1" />
<nvpair id="my-id-pair2" name="name2" value="value2" />
</{tag}>
""")
self.assertEqual(
nvpair_multi.nvset_element_to_dto(xml),
CibNvsetDto(
"my-id",
nvtype,
{"score": "150"},
CibRuleExpressionDto(
"my-id-rule",
CibRuleExpressionType.RULE,
False,
{"boolean-op": "or"},
None,
None,
[
CibRuleExpressionDto(
"my-id-rule-op",
CibRuleExpressionType.OP_EXPRESSION,
False,
{"name": "monitor"},
None,
None,
[],
"op monitor",
),
],
"op monitor",
),
[
CibNvpairDto("my-id-pair1", "name1", "value1"),
CibNvpairDto("my-id-pair2", "name2", "value2"),
],
),
)
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 test_full(self):
for tag, nvtype in self.tag_type:
with self.subTest(tag=tag, nvset_type=nvtype):
xml = etree.fromstring(
f"""
<{tag} id="my-id" score="150">
<rule id="my-id-rule" boolean-op="and">
<rsc_expression
id="my-id-rule-rsc-ocf-pacemaker-Dummy"
class="ocf" provider="pacemaker" type="Dummy"
/>
<op_expression id="my-id-rule-op" name="monitor" />
<rule id="my-id-rule-rule" boolean-op="or">
<expression id="my-id-rule-rule-expr"
operation="defined" attribute="attr1"
/>
<expression id="my-id-rule-rule-expr-1"
attribute="attr2" operation="gt"
type="integer" value="5"
/>
<date_expression id="my-id-rule-rule-expr-2"
operation="lt" end="2020-08-07"
/>
<date_expression id="my-id-rule-rule-expr-3"
operation="in_range"
start="2020-09-01" end="2020-09-11"
/>
<date_expression id="my-id-rule-rule-expr-4"
operation="in_range" start="2020-10-01"
>
<duration id="my-id-rule-rule-expr-4-duration"
months="1"
/>
</date_expression>
<date_expression id="my-id-rule-rule-expr-5"
operation="date_spec"
>
<date_spec id="my-id-rule-rule-expr-5-datespec"
years="2021-2022"
/>
</date_expression>
<date_expression id="my-id-rule-rule-expr-6"
operation="in_range" end="2020-09-11"
/>
</rule>
</rule>
<nvpair id="my-id-pair1" name="name1" value="value1" />
<nvpair id="my-id-pair2" name="name2" value="value2" />
</{tag}>
"""
)
self.assertEqual(
nvpair_multi.nvset_element_to_dto(
xml, get_in_effect_eval()
),
CibNvsetDto(
"my-id",
nvtype,
{"score": "150"},
CibRuleExpressionDto(
"my-id-rule",
CibRuleExpressionType.RULE,
CibRuleInEffectStatus.UNKNOWN,
{"boolean-op": "and"},
None,
None,
[
CibRuleExpressionDto(
"my-id-rule-rsc-ocf-pacemaker-Dummy",
CibRuleExpressionType.RSC_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"class": "ocf",
"provider": "pacemaker",
"type": "Dummy",
},
None,
None,
[],
"resource ocf:pacemaker:Dummy",
),
CibRuleExpressionDto(
"my-id-rule-op",
CibRuleExpressionType.OP_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{"name": "monitor"},
None,
None,
[],
"op monitor",
),
CibRuleExpressionDto(
"my-id-rule-rule",
CibRuleExpressionType.RULE,
CibRuleInEffectStatus.UNKNOWN,
{"boolean-op": "or"},
None,
None,
[
CibRuleExpressionDto(
"my-id-rule-rule-expr",
CibRuleExpressionType.EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"operation": "defined",
"attribute": "attr1",
},
None,
None,
[],
"defined attr1",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-1",
CibRuleExpressionType.EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"attribute": "attr2",
"operation": "gt",
"type": "integer",
"value": "5",
},
None,
None,
[],
"attr2 gt integer 5",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-2",
CibRuleExpressionType.DATE_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"operation": "lt",
"end": "2020-08-07",
},
None,
None,
[],
"date lt 2020-08-07",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-3",
CibRuleExpressionType.DATE_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"operation": "in_range",
"start": "2020-09-01",
"end": "2020-09-11",
},
None,
None,
[],
"date in_range 2020-09-01 to 2020-09-11",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-4",
CibRuleExpressionType.DATE_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"operation": "in_range",
"start": "2020-10-01",
},
None,
CibRuleDateCommonDto(
"my-id-rule-rule-expr-4-duration",
{"months": "1"},
),
[],
"date in_range 2020-10-01 to duration months=1",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-5",
CibRuleExpressionType.DATE_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{"operation": "date_spec"},
CibRuleDateCommonDto(
"my-id-rule-rule-expr-5-datespec",
{"years": "2021-2022"},
),
None,
[],
"date-spec years=2021-2022",
),
CibRuleExpressionDto(
"my-id-rule-rule-expr-6",
CibRuleExpressionType.DATE_EXPRESSION,
CibRuleInEffectStatus.UNKNOWN,
{
"operation": "in_range",
"end": "2020-09-11",
},
None,
None,
[],
"date in_range to 2020-09-11",
),
],
"defined attr1 or attr2 gt integer 5 or "
"date lt 2020-08-07 or "
"date in_range 2020-09-01 to 2020-09-11 or "
"date in_range 2020-10-01 to duration months=1 or "
"date-spec years=2021-2022 or "
"date in_range to 2020-09-11",
),
],
"resource ocf:pacemaker:Dummy and op monitor and "
"(defined attr1 or attr2 gt integer 5 or "
"date lt 2020-08-07 or "
"date in_range 2020-09-01 to 2020-09-11 or "
"date in_range 2020-10-01 to duration months=1 "
"or date-spec years=2021-2022 or "
"date in_range to 2020-09-11)",
),
[
CibNvpairDto("my-id-pair1", "name1", "value1"),
CibNvpairDto("my-id-pair2", "name2", "value2"),
],
),
)
