def _process_response(self, response):
report = response_to_report_item(response)
target = response.request.target
if report is None:
try:
parsed_response = json.loads(response.data)
# If the node is offline, we only get the "offline" key. Asking
# for any other in that case results in KeyError which is not
# what we want.
if (
parsed_response.get("pending", True)
or
not parsed_response.get("online", False)
):
self._not_yet_started_target_list.append(target)
return
report = reports.cluster_start_success(target.label)
except (json.JSONDecodeError, KeyError):
report = reports.invalid_response_format(target.label)
else:
if not response.was_connected:
self._not_yet_started_target_list.append(target)
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
self._report(report)
def _process_response(self, response):
report = response_to_report_item(response)
if report is None:
self._online_target_list.append(response.request.target)
return
if not response.was_connected:
report = (ReportItem.warning(
reports.messages.OmittingNode(response.request.target.label))
if self._ignore_offline_targets else
response_to_report_item(
response, forceable=report_codes.SKIP_OFFLINE_NODES))
self._report(report)
def _process_response(self, response):
report = response_to_report_item(response)
if report is None:
self._online_target_list.append(response.request.target)
return
if not response.was_connected:
report = (
reports.omitting_node(response.request.target.label)
if self._ignore_offline_targets
else response_to_report_item(
response, forceable=report_codes.SKIP_OFFLINE_NODES
)
)
self._report(report)
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
node = response.request.target.label
if report is not None:
self._has_failure = True
self._report(report)
return self._get_next_list()
if response.data.strip() == "Cannot initialize CMAP service":
# corosync is not running on the node, this is OK
return self._get_next_list()
try:
quorum_status = corosync_live.QuorumStatus.from_string(
response.data
)
if not quorum_status.is_quorate:
return self._get_next_list()
self._quorum_status = quorum_status
except corosync_live.QuorumStatusParsingException as e:
self._has_failure = True
self._report(
reports.corosync_quorum_get_status_error(
e.reason,
node=node,
severity=ReportItemSeverity.WARNING,
)
)
return self._get_next_list()
return []
def _process_response(self, response):
report = response_to_report_item(response,
severity=ReportItemSeverity.WARNING)
node = response.request.target.label
if report is not None:
self.__has_failures = True
self._report(report)
return self._get_next_list()
try:
output = json.loads(response.data)
if output["code"] == "reloaded":
self.__was_successful = True
self._report(reports.corosync_config_reloaded(node))
return
if output["code"] == "not_running":
self._report(reports.corosync_config_reload_not_possible(node))
else:
self.__has_failures = True
self._report(
reports.corosync_config_reload_error(
output["message"],
node=node,
severity=ReportItemSeverity.WARNING,
))
except (ValueError, LookupError):
self._report(
reports.invalid_response_format(
node,
severity=ReportItemSeverity.WARNING,
))
return self._get_next_list()
def _get_response_report(self, response):
return response_to_report_item(
response,
severity=self._failure_severity,
forceable=self._failure_forceable,
report_pcsd_too_old_on_404=self._report_pcsd_too_old_on_404,
)
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
node = response.request.target.label
if report is not None:
self.__has_failures = True
self._report(report)
return self._get_next_list()
try:
output = json.loads(response.data)
if output["code"] == "reloaded":
self.__was_successful = True
self._report(reports.corosync_config_reloaded(node))
return []
if output["code"] == "not_running":
self._report(reports.corosync_config_reload_not_possible(node))
else:
self.__has_failures = True
self._report(reports.corosync_config_reload_error(
output["message"],
node=node,
severity=ReportItemSeverity.WARNING,
))
except (ValueError, LookupError):
self.__has_failures = True
self._report(reports.invalid_response_format(
node,
severity=ReportItemSeverity.WARNING,
))
return self._get_next_list()
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=reports.ReportItemSeverity.WARNING)
node = response.request.target.label
if report_item is not None:
self._has_failure = True
self._report(report_item)
return self._get_next_list()
if response.data.strip() == "Cannot initialize CMAP service":
# corosync is not running on the node, this is OK
return self._get_next_list()
try:
quorum_status = corosync_live.QuorumStatus.from_string(
response.data)
if not quorum_status.is_quorate:
return self._get_next_list()
self._quorum_status = quorum_status
except corosync_live.QuorumStatusParsingException as e:
self._has_failure = True
self._report(
ReportItem.warning(
reports.messages.CorosyncQuorumGetStatusError(
e.reason,
node=node,
)))
return self._get_next_list()
return []
def _process_response(self, response):
report = response_to_report_item(response)
if report:
self._report(report)
return
report_list = []
node_label = response.request.target.label
try:
data = json.loads(response.data)
if not data["sbd"]["installed"]:
report_list.append(reports.sbd_not_installed(node_label))
if not data["watchdog"]["exist"]:
report_list.append(
reports.watchdog_not_found(node_label,
data["watchdog"]["path"]))
for device in data.get("device_list", []):
if not device["exist"]:
report_list.append(
reports.sbd_device_does_not_exist(
device["path"], node_label))
elif not device["block_device"]:
report_list.append(
reports.sbd_device_is_not_block_device(
device["path"], node_label))
# TODO maybe we can check whenever device is initialized by sbd (by
# running 'sbd -d <dev> dump;')
except (ValueError, KeyError, TypeError):
report_list.append(reports.invalid_response_format(node_label))
if report_list:
self._report_list(report_list)
else:
self._report(
reports.sbd_check_success(response.request.target.label))
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
if report_item is None:
self._on_success()
return []
self._report(report_item)
return self._get_next_list()
def _get_response_report(self, response):
"""
Convert specified response to report item. Returns None if the response
has no failures.
Response response -- a response to be converted
"""
return response_to_report_item(response)
def test_code_other(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(500)),
(severity.ERROR, report_codes.NODE_COMMUNICATION_ERROR, {
"node": self.host,
"command": self.request,
"reason": "HTTP error: 500"
}, None))
def test_code_403(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(403)),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_PERMISSION_DENIED, {
"node": self.host,
"command": self.request,
"reason": "HTTP error: 403"
}, None))
def _get_response_report(self, response):
# pylint: disable=no-self-use
"""
Convert specified response to report item. Returns None if the response
has no failures.
Response response -- a response to be converted
"""
return response_to_report_item(response)
def test_code_404(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(404)),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND, {
"node": self.host,
"command": self.request,
"reason": "HTTP error: 404"
}, None))
def test_code_400(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(400)),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL, {
"node": self.host,
"command": self.request,
"reason": self.data.decode("utf-8")
}, None))
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
if report is None:
self._on_success()
return []
self._report(report)
return self._get_next_list()
def _process_response(self, response):
report = response_to_report_item(response,
severity=ReportItemSeverity.WARNING)
node_label = response.request.target.label
if report is None:
self._report(reports.cluster_destroy_success(node_label))
else:
self._report(report)
self._unreachable_nodes.append(node_label)
def test_timedouted(self):
response = self.fixture_response_not_connected(
pycurl.E_OPERATION_TIMEOUTED, "err")
assert_report_item_equal(
lib.response_to_report_item(response),
(severity.ERROR, report_codes.NODE_COMMUNICATION_ERROR_TIMED_OUT, {
"node": self.host,
"command": self.request,
"reason": "err"
}, None))
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
if report_item is not None:
self.__has_failures = True
self._report(report_item)
return self._get_next_list()
self.__corosync_conf = response.data
self.__was_successful = True
return []
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
node_label = response.request.target.label
if report is None:
self._report(reports.cluster_destroy_success(node_label))
else:
self._report(report)
self._unreachable_nodes.append(node_label)
def test_unable_to_connect(self):
response = self.fixture_response_not_connected(pycurl.E_SEND_ERROR,
"err")
assert_report_item_equal(
lib.response_to_report_item(response),
(severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, {
"node": self.host,
"command": self.request,
"reason": "err"
}, None))
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=reports.ReportItemSeverity.WARNING)
node_label = response.request.target.label
if report_item is None:
self._report(
ReportItem.info(
reports.messages.ClusterDestroySuccess(node_label)))
else:
self._report(report_item)
self._unreachable_nodes.append(node_label)
def _process_response(self, response):
report = response_to_report_item(response,
severity=ReportItemSeverity.INFO)
host_name = response.request.target.label
if report is None:
report = reports.host_already_authorized(host_name)
else:
# If we cannot connect it may be because a node's address and / or
# port is not correct. Since these are part of authentication info
# we tell we're not authorized.
self._not_authorized_host_name_list.append(host_name)
self._report(report)
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.INFO
)
host_name = response.request.target.label
if report is None:
report = reports.host_already_authorized(host_name)
else:
# If we cannot connect it may be because a node's address and / or
# port is not correct. Since these are part of authentication info
# we tell we're not authorized.
self._not_authorized_host_name_list.append(host_name)
self._report(report)
def _process_response(self, response):
report = response_to_report_item(response)
target = response.request.target
if report is None:
try:
parsed_response = json.loads(response.data)
# If the node is offline, we only get the "offline" key. Asking
# for any other in that case results in KeyError which is not
# what we want.
if (parsed_response.get("pending", True)
or not parsed_response.get("online", False)):
self._not_yet_started_target_list.append(target)
return
report = reports.cluster_start_success(target.label)
except (json.JSONDecodeError, KeyError):
report = reports.invalid_response_format(target.label)
else:
if not response.was_connected:
self._not_yet_started_target_list.append(target)
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
self._report(report)
def test_code_404(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(404)),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND,
{
"node": self.host,
"command": self.request,
"reason": "HTTP error: 404"
},
None
)
)
def test_code_403(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(403)),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_PERMISSION_DENIED,
{
"node": self.host,
"command": self.request,
"reason": "HTTP error: 403"
},
None
)
)
def test_code_400(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(400)),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
{
"node": self.host,
"command": self.request,
"reason": self.data.decode("utf-8")
},
None
)
)
def test_code_401(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(401)),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
{
"node": self.host,
"command": self.request,
"reason": "HTTP error: 401",
},
None,
),
)
def _process_response(self, response):
report_item = response_to_report_item(response)
if report_item:
self._report(report_item)
return
report_list = []
node_label = response.request.target.label
try:
data = json.loads(response.data)
if not data["sbd"]["installed"]:
report_list.append(
ReportItem.error(
reports.messages.SbdNotInstalled(node_label)))
if "watchdog" in data:
if data["watchdog"]["exist"]:
if not data["watchdog"].get("is_supported", True):
report_list.append(
ReportItem.error(
reports.messages.SbdWatchdogNotSupported(
node_label, data["watchdog"]["path"])))
else:
report_list.append(
ReportItem.error(
reports.messages.WatchdogNotFound(
node_label, data["watchdog"]["path"])))
for device in data.get("device_list", []):
if not device["exist"]:
report_list.append(
ReportItem.error(
reports.messages.SbdDeviceDoesNotExist(
device["path"], node_label)))
elif not device["block_device"]:
report_list.append(
ReportItem.error(
reports.messages.SbdDeviceIsNotBlockDevice(
device["path"], node_label)))
# TODO maybe we can check whenever device is initialized by sbd
# (by running 'sbd -d <dev> dump;')
except (ValueError, KeyError, TypeError):
report_list.append(
ReportItem.error(
reports.messages.InvalidResponseFormat(node_label)))
if report_list:
self._report_list(report_list)
else:
self._report(
ReportItem.info(
reports.messages.SbdCheckSuccess(
response.request.target.label)))
def test_code_other(self):
assert_report_item_equal(
lib.response_to_report_item(self.fixture_response_connected(500)),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR,
{
"node": self.host,
"command": self.request,
"reason": "HTTP error: 500"
},
None
)
)
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
if report_item is not None:
self._report(report_item)
return self._get_next_list()
node = response.request.target.label
try:
output = json.loads(response.data)
if output["status"] == "success":
self._was_successful = True
self._cluster_status = output["data"]
return []
if output["status_msg"]:
self._report(
ReportItem.error(
reports.messages.NodeCommunicationCommandUnsuccessful(
node,
response.request.action,
output["status_msg"],
)))
# TODO Node name should be added to each received report item and
# those modified report itemss should be reported. That, however,
# requires reports overhaul which would add possibility to add a
# node name to any report item. Also, infos and warnings should not
# be ignored.
if output["report_list"]:
for report_data in output["report_list"]:
if (report_data["severity"] == ReportItemSeverity.ERROR
and report_data["report_text"]):
# pylint: disable=line-too-long
self._report(
ReportItem.error(
reports.messages.
NodeCommunicationCommandUnsuccessful(
node,
response.request.action,
report_data["report_text"],
)))
except (ValueError, LookupError, TypeError):
self._report(
ReportItem.warning(
reports.messages.InvalidResponseFormat(node)))
return self._get_next_list()
def test_timedouted(self):
response = self.fixture_response_not_connected(
pycurl.E_OPERATION_TIMEOUTED, "err"
)
assert_report_item_equal(
lib.response_to_report_item(response),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_TIMED_OUT,
{
"node": self.host,
"command": self.request,
"reason": "err"
},
None
)
)
def test_unable_to_connect(self):
response = self.fixture_response_not_connected(
pycurl.E_SEND_ERROR, "err"
)
assert_report_item_equal(
lib.response_to_report_item(response),
(
severity.ERROR,
report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
{
"node": self.host,
"command": self.request,
"reason": "err"
},
None
)
)
def _process_response(self, response):
report_item = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
node_label = response.request.target.label
if report_item is not None:
if not response.was_connected:
self._report(report_item)
self._report(
ReportItem.warning(
reports.messages.UnableToGetSbdConfig(node_label, "")))
return
self._config_list.append({
"node":
node_label,
"config":
environment_file_to_dict(response.data),
})
self._successful_target_list.append(node_label)
def _process_response(self, response):
report = response_to_report_item(response,
severity=ReportItemSeverity.WARNING)
node_label = response.request.target.label
if report is not None:
if not response.was_connected:
self._report(report)
self._report(
reports.unable_to_get_sbd_config(node_label, "",
ReportItemSeverity.WARNING))
return
self._config_list.append({
"node":
node_label,
"config":
environment_file_to_dict(response.data)
})
self._successful_target_list.append(node_label)
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
node_label = response.request.target.label
if report is not None:
if not response.was_connected:
self._report(report)
self._report(
reports.unable_to_get_sbd_config(
node_label, "", ReportItemSeverity.WARNING
)
)
return
self._config_list.append({
"node": node_label,
"config": environment_file_to_dict(response.data)
})
self._successful_target_list.append(node_label)
def _process_response(self, response):
report = response_to_report_item(response,
severity=ReportItemSeverity.WARNING)
node_label = response.request.target.label
if report is not None:
self._report_list([
report,
#reason is in previous report item, warning is there implicit
reports.unable_to_get_sbd_status(node_label, "")
])
return
try:
self._status_list.append({
"node": node_label,
"status": json.loads(response.data)["sbd"]
})
self._successful_target_list.append(node_label)
except (ValueError, KeyError) as e:
self._report(reports.unable_to_get_sbd_status(node_label, str(e)))
def _process_response(self, response):
report = response_to_report_item(
response, severity=ReportItemSeverity.WARNING
)
node_label = response.request.target.label
if report is not None:
self._report_list([
report,
#reason is in previous report item, warning is there implicit
reports.unable_to_get_sbd_status(node_label, "")
])
return
try:
self._status_list.append({
"node": node_label,
"status": json.loads(response.data)["sbd"]
})
self._successful_target_list.append(node_label)
except (ValueError, KeyError) as e:
self._report(reports.unable_to_get_sbd_status(node_label, str(e)))
def _process_response(self, response):
report = response_to_report_item(response)
if report:
self._report(report)
return
report_list = []
node_label = response.request.target.label
try:
data = json.loads(response.data)
if not data["sbd"]["installed"]:
report_list.append(reports.sbd_not_installed(node_label))
if "watchdog" in data:
if data["watchdog"]["exist"]:
if not data["watchdog"].get("is_supported", True):
report_list.append(reports.sbd_watchdog_not_supported(
node_label, data["watchdog"]["path"]
))
else:
report_list.append(reports.watchdog_not_found(
node_label, data["watchdog"]["path"]
))
for device in data.get("device_list", []):
if not device["exist"]:
report_list.append(reports.sbd_device_does_not_exist(
device["path"], node_label
))
elif not device["block_device"]:
report_list.append(reports.sbd_device_is_not_block_device(
device["path"], node_label
))
# TODO maybe we can check whenever device is initialized by sbd
# (by running 'sbd -d <dev> dump;')
except (ValueError, KeyError, TypeError):
report_list.append(reports.invalid_response_format(node_label))
if report_list:
self._report_list(report_list)
else:
self._report(
reports.sbd_check_success(response.request.target.label)
)
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 _process_response(self, response):
report_item = response_to_report_item(
response, severity=ReportItemSeverity.WARNING)
node = response.request.target.label
if report_item is not None:
self.__has_failures = True
self._report(report_item)
return self._get_next_list()
try:
output = json.loads(response.data)
if output["code"] == "reloaded":
self.__was_successful = True
self._report(
ReportItem.info(
reports.messages.CorosyncConfigReloaded(node)))
return []
if output["code"] == "not_running":
self._report(
ReportItem.warning(
reports.messages.CorosyncConfigReloadNotPossible(
node)))
else:
self.__has_failures = True
self._report(
ReportItem.warning(
reports.messages.CorosyncConfigReloadError(
output["message"],
node=node,
)))
except (ValueError, LookupError):
self.__has_failures = True
self._report(
ReportItem.warning(
reports.messages.InvalidResponseFormat(node)))
return self._get_next_list()
def test_code_200(self):
self.assertIsNone(
lib.response_to_report_item(self.fixture_response_connected(200)))
def test_code_200(self):
self.assertIsNone(
lib.response_to_report_item(self.fixture_response_connected(200))
)
def _get_response_report(self, response):
return response_to_report_item(
response,
severity=self._failure_severity,
forceable=self._failure_forceable,
)
def _process_response(self, response):
report = response_to_report_item(response)
if report is None:
return
self._report(report)
return self._get_next_list()
def _get_response_report(self, response):
return response_to_report_item(
response,
severity=self._failure_severity,
forceable=self._failure_forceable,
)
