def config(
lib: Any,
argv: Sequence[str],
modifiers: InputModifiers,
) -> None:
"""
Options: None
"""
modifiers.ensure_only_supported()
if argv:
raise CmdLineInputError()
config_raw = lib.dr.get_config()
try:
config_dto = dto.from_dict(DrConfigDto, config_raw)
except (KeyError, TypeError, ValueError) as e:
raise error(
"Unable to communicate with pcsd, received response:\n"
f"{config_raw}"
) from e
lines = ["Local site:"]
lines.extend(indent(_config_site_lines(config_dto.local_site)))
for site_dto in config_dto.remote_site_list:
lines.append("Remote site:")
lines.extend(indent(_config_site_lines(site_dto)))
print("\n".join(lines))
def main() -> None:
# pylint: disable=broad-except
argv = sys.argv[1:]
if argv:
_exit(
communication.const.COM_STATUS_INPUT_ERROR,
status_msg="No arguments allowed",
)
utils.subprocess_setup()
logging.basicConfig()
try:
input_dto = dto.from_dict(
communication.dto.InternalCommunicationRequestDto,
json.load(sys.stdin),
)
cli_env = get_cli_env(input_dto.options)
lib = Library(cli_env, utils.get_middleware_factory())
if input_dto.cmd not in SUPPORTED_COMMANDS:
_exit(
communication.const.COM_STATUS_UNKNOWN_CMD,
status_msg=f"Unknown command '{input_dto.cmd}'",
)
for sub_cmd in input_dto.cmd.split("."):
lib = getattr(lib, sub_cmd)
output_data = lib(**input_dto.cmd_data) # type: ignore
_exit(
communication.const.COM_STATUS_SUCCESS,
report_list=cli_env.report_processor.processed_items,
data=(
dto.to_dict(output_data)
if isinstance(output_data, dto.DataTransferObject)
else output_data
),
)
except LibraryError as e:
_exit(
communication.const.COM_STATUS_ERROR,
report_list=(
cli_env.report_processor.processed_items + list(e.args)
),
data=e.output,
)
except json.JSONDecodeError as e:
_exit(
communication.const.COM_STATUS_INPUT_ERROR,
status_msg=f"Unable to parse input data: {e.msg}",
)
except DaciteError as e:
_exit(
communication.const.COM_STATUS_INPUT_ERROR,
status_msg=str(e),
)
except Exception as e:
# TODO: maybe add traceback?
_exit(communication.const.COM_STATUS_EXCEPTION, status_msg=str(e))
def entity_fixture(index):
return dto.from_dict(
RelationEntityDto,
dict(id=f"ent_id{index}",
type="ent_type",
members=[f"{index}m1", f"{index}m2", f"{index}m0"],
metadata=dict(
id=f"ent_id{index}",
k0="val0",
k1="val1",
)))
def _convert_input_data(cmd: str, data: Dict[str, Any]) -> Mapping[str, Any]:
if cmd == "resource_agent.get_agent_metadata":
try:
data["agent_name"] = dto.from_dict(ResourceAgentNameDto,
data["agent_name"])
except (DaciteError, KeyError) as e:
_exit(
communication.const.COM_STATUS_INPUT_ERROR,
status_msg=str(e),
)
return data
def status(
lib: Any,
argv: Sequence[str],
modifiers: InputModifiers,
) -> None:
"""
Options:
* --full - show full details, node attributes and failcount
* --hide-inactive - hide inactive resources
* --request-timeout - HTTP timeout for node authorization check
"""
modifiers.ensure_only_supported(
"--full",
"--hide-inactive",
"--request-timeout",
)
if argv:
raise CmdLineInputError()
status_list_raw = lib.dr.status_all_sites_plaintext(
hide_inactive_resources=modifiers.get("--hide-inactive"),
verbose=modifiers.get("--full"),
)
try:
status_list = [
dto.from_dict(DrSiteStatusDto, status_raw)
for status_raw in status_list_raw
]
except (KeyError, TypeError, ValueError) as e:
raise error(
"Unable to communicate with pcsd, received response:\n"
f"{status_list_raw}"
) from e
has_errors = False
plaintext_parts = []
for site_status in status_list:
plaintext_parts.append(
"--- {local_remote} cluster - {role} site ---".format(
local_remote=("Local" if site_status.local_site else "Remote"),
role=site_status.site_role.capitalize(),
)
)
if site_status.status_successfully_obtained:
plaintext_parts.append(site_status.status_plaintext.strip())
plaintext_parts.extend(["", ""])
else:
has_errors = True
plaintext_parts.extend(
["Error: Unable to get status of the cluster from any node", ""]
)
print("\n".join(plaintext_parts).strip())
if has_errors:
raise error("Unable to get status of all sites")
def _action_dto(action):
all_keys = {
"name": "",
"timeout": None,
"interval": None,
"role": None,
"start-delay": None,
"depth": None,
"automatic": False,
"on_target": False,
}
all_keys.update(action)
return from_dict(ResourceAgentActionDto, all_keys)
def entity_fixture(index):
return dto.from_dict(
RelationEntityDto,
dict(
id=f"ent_id{index}",
type=str(ResourceRelationType.INNER_RESOURCES.value),
members=[f"{index}m1", f"{index}m2", f"{index}m0"],
metadata=dict(
id=f"ent_id{index}",
k0="val0",
k1="val1",
),
),
)
def show_resource_relations_cmd(
lib: Any, argv: Sequence[str], modifiers: InputModifiers,
) -> None:
"""
Options:
* -f - CIB file
* --full - show constraint ids and resource types
"""
modifiers.ensure_only_supported("-f", "--full")
if len(argv) != 1:
raise CmdLineInputError()
tree = ResourcePrintableNode.from_dto(
dto.from_dict(
ResourceRelationDto,
lib.resource.get_resource_relations_tree(argv[0]),
)
)
for line in tree_to_lines(tree, verbose=modifiers.get("--full")):
print(line)
def _process_response(self, response):
report_item = response_to_report_item(response,
report_pcsd_too_old_on_404=True)
if report_item:
self._report(report_item)
return
node_label = response.request.target.label
try:
result = from_dict(InternalCommunicationResultDto,
json.loads(response.data))
context = reports.ReportItemContext(node_label)
self._report_list([
reports.report_dto_to_item(report, context)
for report in result.report_list
])
if result.status == const.COM_STATUS_SUCCESS:
self._on_success()
except (json.JSONDecodeError, DaciteError):
self._report(
reports.ReportItem.error(
reports.messages.InvalidResponseFormat(node_label)))
def test_nested_from_dict(self):
self.assertEqual(self.nested_dto, from_dict(MyDto3, self.nested_dict))
def test_simple_from_dict(self):
self.assertEqual(self.simple_dto, from_dict(MyDto1, self.simple_dict))
