def test_create_from_plain_values(self):
self.assertEqual(
{
"first": validate.ValuePair("A", "a"),
"second": validate.ValuePair("B", "b"),
},
validate.values_to_pairs({
"first": "A",
"second": "B",
}, lambda key, value: value.lower()))
def test_keep_pair_if_is_already_there(self):
self.assertEqual(
{
"first": validate.ValuePair("A", "aaa"),
"second": validate.ValuePair("B", "b"),
},
validate.values_to_pairs(
{
"first": validate.ValuePair("A", "aaa"),
"second": "B",
}, lambda key, value: value.lower()))
def _validate_ticket_options(options, allow_unknown_options):
validator_list = ([
validate.NamesIn(constants.TICKET_KEYS,
option_type="booth ticket",
banned_name_list=constants.GLOBAL_KEYS,
**validate.set_warning(report_codes.FORCE_OPTIONS,
allow_unknown_options)),
] + [validate.ValueNotEmpty(option, None) for option in options])
normalized_options = validate.values_to_pairs(
options, lambda key, value: value.strip())
return validate.ValidatorAll(validator_list).validate(normalized_options)
def test_keep_pair_if_is_already_there(self):
self.assertEqual(
{
"first": validate.ValuePair("A", "aaa"),
"second": validate.ValuePair("B", "b"),
},
validate.values_to_pairs(
{
"first": validate.ValuePair("A", "aaa"),
"second": "B",
},
lambda key, value: value.lower()
)
)
def test_create_from_plain_values(self):
self.assertEqual(
{
"first": validate.ValuePair("A", "a"),
"second": validate.ValuePair("B", "b"),
},
validate.values_to_pairs(
{
"first": "A",
"second": "B",
},
lambda key, value: value.lower()
)
)
def prepare(
report_processor, raw_operation_list, default_operation_list,
allowed_operation_name_list, allow_invalid=False
):
"""
Return operation_list prepared from raw_operation_list and
default_operation_list.
report_processor is tool for warning/info/error reporting
list of dicts raw_operation_list are entered operations that require
follow-up care
list of dicts default_operation_list are operations defined as default by
(most probably) resource agent
bool allow_invalid is flag for validation skipping
"""
operations_to_validate = [
validate.values_to_pairs(op, normalize) for op in raw_operation_list
]
report_list = []
options_validators = OPERATION_OPTIONS_VALIDATORS + [
validate.value_in(
"name",
allowed_operation_name_list,
option_name_for_report="operation name",
code_to_allow_extra_values=report_codes.FORCE_OPTIONS,
allow_extra_values=allow_invalid,
)
]
for operation in operations_to_validate:
report_list.extend(
validate_operation(operation, options_validators)
)
operation_list = [
validate.pairs_to_values(op) for op in operations_to_validate
]
report_list.extend(validate_different_intervals(operation_list))
#can raise LibraryError
report_processor.process_list(report_list)
return complete_all_intervals(operation_list) + get_remaining_defaults(
report_processor,
operation_list,
default_operation_list
)
def _validate_ticket_options(options, allow_unknown_options):
validator_list = [
validate.NamesIn(
constants.TICKET_KEYS,
option_type="booth ticket",
banned_name_list=constants.GLOBAL_KEYS,
severity=report.item.get_severity(
report_codes.FORCE, allow_unknown_options
),
),
] + [validate.ValueNotEmpty(option, None) for option in options]
normalized_options = validate.values_to_pairs(
options, lambda key, value: value.strip()
)
return validate.ValidatorAll(validator_list).validate(normalized_options)
def _validate_ticket_options(options, allow_unknown_options):
severity = reports.item.get_severity(reports.codes.FORCE,
allow_unknown_options)
validator_list = ([
validate.NamesIn(
constants.TICKET_KEYS,
option_type="booth ticket",
banned_name_list=constants.GLOBAL_KEYS,
severity=severity,
),
] + [
validate.ValueNotEmpty(option, None)
for option in options if option != "mode"
] + [validate.ValueIn("mode", ["auto", "manual"], severity=severity)])
normalized_options = validate.values_to_pairs(
options, lambda key, value: value.strip())
return validate.ValidatorAll(validator_list).validate(normalized_options)
def operations_to_normalized(raw_operation_list):
return [
validate.values_to_pairs(op, normalize) for op in raw_operation_list
]
def _operations_to_normalized(
raw_operation_list: Iterable[ResourceOperationFilteredIn],
) -> List[validate.TypeOptionNormalizedMap]:
return [
validate.values_to_pairs(op, _normalize) for op in raw_operation_list
]
def prepare_options_plain(
cib: _Element,
report_processor: reports.ReportProcessor,
options,
ticket: str,
resource_id,
):
options = options.copy()
report_processor.report_list(_validate_options_common(options))
if not ticket:
report_processor.report(
ReportItem.error(
reports.messages.RequiredOptionsAreMissing(["ticket"])))
else:
report_processor.report_list(validate_ticket_name(ticket))
options["ticket"] = ticket
if not resource_id:
report_processor.report(
ReportItem.error(
reports.messages.RequiredOptionsAreMissing(["rsc"])))
options["rsc"] = resource_id
role_value_validator = validate.ValueIn("rsc-role",
const.PCMK_ROLES,
option_name_for_report="role")
role_value_validator.empty_string_valid = True
validators = [
role_value_validator,
validate.ValueDeprecated(
"rsc-role",
{
const.PCMK_ROLE_PROMOTED_LEGACY: const.PCMK_ROLE_PROMOTED,
const.PCMK_ROLE_UNPROMOTED_LEGACY: const.PCMK_ROLE_UNPROMOTED,
},
reports.ReportItemSeverity.deprecation(),
option_name_for_report="role",
),
]
report_processor.report_list(
validate.ValidatorAll(validators).validate(
validate.values_to_pairs(
options,
validate.option_value_normalization(
{"rsc-role": lambda value: value.capitalize()}),
)))
if report_processor.has_errors:
raise LibraryError()
if "rsc-role" in options:
if options["rsc-role"]:
options["rsc-role"] = pacemaker.role.get_value_for_cib(
options["rsc-role"].capitalize(),
tools.are_new_role_names_supported(cib),
)
else:
del options["rsc-role"]
return constraint.prepare_options(
tuple(list(ATTRIB) + list(ATTRIB_PLAIN)),
options,
partial(
_create_id,
cib,
options["ticket"],
resource_id,
options.get("rsc-role", ""),
),
partial(tools.check_new_id_applicable, cib, DESCRIPTION),
)
