def _communication_to_response(
label,
dest_list,
action,
param_list,
response_code,
output,
debug_output,
was_connected,
errno,
error_msg,
raw_data,
):
return Response(
MockCurlSimple(
info={pycurl.RESPONSE_CODE: response_code},
output=output,
debug_output=debug_output,
request=Request(
# We do not need to check if token is the right one in tests:
# 1) Library commands tests do not care about tokens. That
# should be covered once in a specialized test, not in every
# single library command test.
# 2) If we need to test teh case when a token is not accepted
# by pcsd, we will do so by setting an appropriate response.
# The actual token value doesn't matter.
RequestTarget(label, dest_list=dest_list, token=None),
RequestData(action, param_list, raw_data),
),
),
was_connected=was_connected,
errno=errno,
error_msg=error_msg,
)
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData("remote/set_sbd_config", [("config", config)]),
) for target, config in self._request_data_list
]
def fixture_response_connected(self, response_code):
handle = MockCurl({pycurl.RESPONSE_CODE: response_code})
handle.request_obj = Request(RequestTarget(self.host),
RequestData(self.request))
handle.output_buffer = io.BytesIO()
handle.output_buffer.write(self.data)
return Response.connection_successful(handle)
def _get_request_data(self):
# check_auth_only is not used anymore. It was used in older pcsd to
# prevent a node to check against which nodes it is authorized and
# reporting that info. We are not interested in that anymore (it made
# sense to check it when authentication was bidirectional). So we tell
# the node not to do this extra check.
return RequestData("remote/check_auth", [("check_auth_only", 1)])
def _get_request_data(self):
return RequestData(
"remote/check_sbd",
# here we just need info about sbd service, therefore watchdog and
# device list is empty
[
("watchdog", ""),
("device_list", "[]"),
])
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData("remote/check_sbd",
[("watchdog", watchdog),
("device_list", json.dumps(device_list))]))
for target, watchdog, device_list in self._request_data_list
]
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData("remote/qdevice_net_sign_node_certificate", [
("certificate_request", base64.b64encode(cert)),
("cluster_name", cluster_name),
])) for target, cert, cluster_name in self._input_data
]
def _get_request_data(self):
return RequestData(
"remote/cluster_status_plaintext",
[("data_json",
json.dumps(
dict(
hide_inactive_resources=self._hide_inactive_resources,
verbose=self._verbose,
)))],
)
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData(
"api/v1/scsi-unfence-node/v1",
data=json.dumps({
"devices": self._devices,
"node": target.label
}),
),
) for target in self._target_list
]
def _get_request_data(self):
data = {
"config": {
"name": "{0}.conf".format(self._booth_name),
"data": self._config_data
}
}
if self._authfile is not None and self._authfile_data is not None:
data["authfile"] = {
"name": os.path.basename(self._authfile),
"data": base64.b64encode(self._authfile_data).decode("utf-8")
}
return RequestData("remote/booth_set_config",
[("data_json", json.dumps(data))])
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData(
"api/v1/scsi-unfence-node-mpath/v1",
data=json.dumps(
dict(
key=self._node_key_map[target.label],
original_devices=self._original_devices,
updated_devices=self._updated_devices,
)),
),
) for target in self._target_list
]
def _prepare_initial_requests(self):
return [
Request(
target,
RequestData(
"api/v1/scsi-unfence-node/v2",
data=json.dumps(
dict(
node=target.label,
original_devices=self._original_devices,
updated_devices=self._updated_devices,
)),
),
) for target in self._target_list
]
def __communication_to_response(self, label, address_list, action,
param_list, port, token, response_code,
output, debug_output, was_connected, errno,
error_msg):
return Response(
MockCurlSimple(info={pycurl.RESPONSE_CODE: response_code},
output=output.encode("utf-8"),
debug_output=debug_output.encode("utf-8"),
request=Request(
RequestTarget(label, address_list, port, token),
RequestData(action, param_list),
)),
was_connected=was_connected,
errno=6,
error_msg=error_msg,
)
def _get_request_data(self):
return RequestData("remote/qdevice_client_disable")
def fixture_request():
return Request(RequestTarget("host"), RequestData("action"))
def fixture_response_not_connected(self, errno, error_msg):
handle = MockCurl()
handle.request_obj = Request(RequestTarget(self.host),
RequestData(self.request))
return Response.connection_failure(handle, errno, error_msg)
def _get_request_data(self):
return RequestData("remote/get_quorum_info")
def _get_request_data(self):
return RequestData(self._get_request_action())
def _get_request_data(self):
return RequestData(
"remote/known_hosts_change",
[("data_json", json.dumps(self._json_data))],
)
def _get_request_data(self):
return RequestData(
"remote/qdevice_net_client_init_certificate_storage",
[("ca_certificate", base64.b64encode(self._ca_cert))],
)
def _get_request_data(self):
return RequestData("remote/qdevice_net_client_destroy")
def _get_request_data(self):
return RequestData("remote/set_certs", [("ssl_cert", self._ssl_cert),
("ssl_key", self._ssl_key)])
def _get_request_data(self):
return RequestData(
"remote/remove_nodes_from_cib",
[("data_json", json.dumps(dict(node_list=self._nodes_to_remove)))],
)
def get_request(timeout):
return Request(global_target, RequestData("delay/{0}".format(timeout)))
def _get_request_data(self):
return RequestData(
"remote/qdevice_net_client_import_certificate",
[("certificate", base64.b64encode(self._pk12))],
)
def _get_request_data(self):
return RequestData("remote/pacemaker_node_status")
def _get_request_data(self):
return RequestData("remote/qdevice_net_get_ca_certificate")
def _get_request_data(self):
return RequestData("remote/check_host")
def _get_request_data(self):
return RequestData("remote/cluster_destroy")
def _get_request_data(self):
return RequestData("remote/get_sbd_config")
