def save_files(self, files_data, saved=(), existing=(), failed=(), rewrite_existing=False, node_labels=None, communication_list=None, name="http.booth.save_files"): param_list = [("data_json", json.dumps(files_data))] if rewrite_existing: param_list.append(("rewrite_existing", "1")) place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/booth_save_files", param_list=param_list, output=json.dumps({ "saved": saved, "existing": existing, "failed": failed, }), )
def check_sbd(self, communication_list=None, name="http.sbd.check_sbd"): place_multinode_call( self.__calls, name, communication_list=communication_list, action="remote/check_sbd", )
def get_config(self, booth_name, config_data=None, authfile=None, authfile_data=None, node_labels=None, communication_list=None, name="http.booth.get_config"): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/booth_get_config", param_list=[("name", booth_name)], output=json.dumps({ "config": { "data": config_data, }, "authfile": { "name": authfile, "data": base64.b64encode(authfile_data).decode("utf-8") if authfile_data else None, }, }), )
def remove_files(self, node_labels=None, pcsd_settings=False, communication_list=None, name="http.files.remove_files"): """ Create a call for removing the files on the nodes. node_labels list -- create success responses from these nodes pcsd_settings bool -- if True, remove file pcsd_settings communication_list list -- create custom responses name string -- the key of this call """ input_data = {} output_data = {} if pcsd_settings: file_id = "pcsd settings" input_data[file_id] = dict(type="pcsd_settings") output_data[file_id] = dict( code="deleted", message="", ) place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/remove_file", param_list=[("data_json", json.dumps(input_data)) ], output=json.dumps(dict(files=output_data)))
def set_sbd_config( self, config_generator=None, node_labels=None, communication_list=None, name="http.sbd.set_sbd_config" ): if bool(config_generator) == bool(communication_list): raise AssertionError( "Exactly one of 'config_generator', 'communication_list' " "must be specified" ) if config_generator and not node_labels: raise AssertionError( "'node_labels' has to be defined if 'config_generator' is used" ) if communication_list is None: communication_list = [ dict( param_list=[("config", config_generator(node))], label=node, ) for node in node_labels ] place_multinode_call( self.__calls, name, None, communication_list, action="remote/set_sbd_config", )
def send_config(self, booth_name, config, authfile=None, authfile_data=None, node_labels=None, communication_list=None, name="http.booth.send_config"): data = { "config": { "name": "{}.conf".format(booth_name), "data": config, } } if authfile and authfile_data: data["authfile"] = { "name": authfile, "data": base64.b64encode(authfile_data).decode("utf-8"), } place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/booth_set_config", param_list=[("data_json", json.dumps(data))])
def enable_sbd(self, node_labels=None, communication_list=None, name="http.sbd.enable_sbd"): place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/sbd_enable")
def remove_stonith_watchdog_timeout( self, node_labels=None, communication_list=None, name="http.pcmk.remove_stonith_watchdog_timeout"): place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/remove_stonith_watchdog_timeout")
def qdevice_net_get_ca_cert( self, ca_cert=b"ca_cert", node_labels=None, communication_list=None, name="http.corosync.qdevice_net_get_ca_cert", ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/qdevice_net_get_ca_certificate", output=base64.b64encode(ca_cert), )
def qdevice_net_client_setup( self, ca_cert=b"ca_cert", node_labels=None, communication_list=None, name="http.corosync.qdevice_net_client_setup", ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/qdevice_net_client_init_certificate_storage", param_list=[("ca_certificate", base64.b64encode(ca_cert))], )
def qdevice_net_client_import_cert_and_key( self, cert=b"pk12 cert", node_labels=None, communication_list=None, name="http.corosync.qdevice_net_client_import_cert_and_key", ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/qdevice_net_client_import_certificate", param_list=[("certificate", base64.b64encode(cert))], )
def reload_corosync_conf( self, node_labels=None, communication_list=None, name="http.corosync.reload_corosync_conf" ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/reload_corosync_conf", output=json.dumps(dict(code="reloaded", message="")), )
def check_sbd(self, watchdog=None, device_list=(), node_labels=None, communication_list=None, name="http.sbd.check_sbd"): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/check_sbd", )
def disable_sbd(self, node_labels=None, communication_list=None, name="http.sbd.disable_sbd"): """ Create a call for disabling sbd on nodes node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/sbd_disable")
def check_corosync_offline(self, node_labels=None, communication_list=None, name="http.corosync.check_corosync_offline"): """ Create a call for checking that corosync is offline string name -- the key of this call list node_labels -- create success responses from these nodes list communication_list -- create custom responses """ place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/status", output='{"corosync":false}')
def qdevice_net_sign_certificate( self, cluster_name, cert=b"cert", signed_cert=b"signed cert", node_labels=None, communication_list=None, name="http.corosync.qdevice_net_sign_certificate", ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/qdevice_net_sign_node_certificate", param_list=[ ("certificate_request", base64.b64encode(cert)), ("cluster_name", cluster_name), ], output=base64.b64encode(signed_cert), )
def update_known_hosts( self, node_labels=None, to_add=None, to_add_hosts=None, communication_list=None, name="http.host.update_known_hosts", ): """ Create a call for updating known hosts on the hosts. node_labels list -- create success responses from these nodes dict to_add -- records to add: {host_name: {dest_list: [{"addr": , "port": ,}]}} list to_add_hosts -- constructs to_add from host names communication_list list -- create custom responses name string -- the key of this call """ if to_add_hosts and to_add: raise AssertionError( "Cannot specify both 'to_add_hosts' and 'to_add'") if to_add_hosts: to_add = { name: { "dest_list": [{ "addr": name, "port": settings.pcsd_default_port }] } for name in to_add_hosts } add_with_token = { name: dict(data, token=None) for name, data in to_add.items() } place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/known_hosts_change", param_list=[("data_json", json.dumps( dict(known_hosts_add=add_with_token, known_hosts_remove={})))], )
def set_stonith_watchdog_timeout_to_zero( self, node_labels=None, communication_list=None, name="http.pcmk.set_stonith_watchdog_timeout_to_zero"): """ Create a call for setting on hosts node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/set_stonith_watchdog_timeout_to_zero")
def get_quorum_status( self, node_list=None, node_labels=None, communication_list=None, name="http.host.get_quorum_status", ): output = "" if node_list: output = outdent("""\ Quorum information ------------------ Date: Fri Jan 16 13:03:28 2015 Quorum provider: corosync_votequorum Nodes: {nodes_num} Node ID: 1 Ring ID: 19860 Quorate: Yes\n Votequorum information ---------------------- Expected votes: {nodes_num} Highest expected: {nodes_num} Total votes: {nodes_num} Quorum: {quorum_num} Flags: Quorate\n Membership information ---------------------- Nodeid Votes Qdevice Name {nodes}\ """).format(nodes_num=len(node_list), quorum_num=(len(node_list) // 2) + 1, nodes="".join([ _quorum_status_node_fixture(node_id, node) for node_id, node in enumerate(node_list, 1) ])) place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/get_quorum_info", output=output, )
def qdevice_client_stop(self, name="http.corosync.qdevice_client_stop", node_labels=None, communication_list=None): """ Create a call for stopping qdevice service string name -- the key of this call list node_labels -- create success responses from these nodes list communication_list -- create custom responses """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/qdevice_client_stop", output="corosync-qdevice stopped", )
def start_cluster( self, node_labels=None, communication_list=None, name="http.host.start_cluster", ): """ Create a call for starting cluster on the nodes. node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/cluster_start", )
def cluster_destroy( self, node_labels=None, communication_list=None, name="http.host.cluster_destroy", ): """ Create a call for destroying a cluster on the hosts node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/cluster_destroy", )
def check_auth(self, node_labels=None, communication_list=None, name="http.host.check_auth"): """ Create a call for checking authentication on hosts node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/check_auth", output='{"success":true}', param_list=[("check_auth_only", 1)], )
def remove_nodes_from_cib( self, nodes_to_remove, node_labels=None, communication_list=None, name="http.pcmk.remove_nodes_from_cib", ): place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/remove_nodes_from_cib", param_list=[("data_json", json.dumps(dict(node_list=nodes_to_remove)))], output=json.dumps(dict( code="success", message="", )), )
def set_corosync_conf( self, corosync_conf, node_labels=None, communication_list=None, name="http.corosync.set_corosync_conf" ): """ Create a call for sending corosync.conf text string corosync_conf -- corosync.conf text to be sent list node_labels -- create success responses from these nodes list communication_list -- create custom responses string name -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/set_corosync_conf", param_list=[("corosync_conf", corosync_conf)], output="Succeeded", )
def send_pcsd_cert(self, cert, key, node_labels=None, communication_list=None, name="http.host.send_pcsd_cert"): """ Create a call for sending pcsd SSL cert and key string cert -- pcsd SSL certificate string key -- pcsd SSL key node_labels list -- create success responses from these nodes communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/set_certs", param_list=[("ssl_cert", cert), ("ssl_key", key)], )
def get_host_info( self, node_labels=None, output_data=None, communication_list=None, name="http.host.get_host_info", ): """ Create a call for getting overall info about a host node_labels list -- create success responses from these nodes output_data dict -- default output data which will be converted to JSON communication_list list -- create custom responses name string -- the key of this call """ place_multinode_call( self.__calls, name, node_labels, communication_list, action="remote/check_host", output=json.dumps(output_data) if output_data else "", )
def put_files( self, node_labels=None, pcmk_authkey=None, corosync_authkey=None, corosync_conf=None, pcs_settings_conf=None, communication_list=None, name="http.files.put_files", ): """ Create a call for the files distribution to the nodes. node_labels list -- create success responses from these nodes pcmk_authkey bytes -- content of pacemaker authkey file corosync_authkey bytes -- content of corosync authkey file corosync_conf string -- content of corosync.conf pcs_settings_conf string -- content of pcs_settings.conf communication_list list -- create custom responses name string -- the key of this call """ input_data = {} output_data = {} written_output_dict = dict( code="written", message="", ) if pcmk_authkey: file_id = "pacemaker_remote authkey" input_data[file_id] = dict( data=base64.b64encode(pcmk_authkey).decode("utf-8"), type="pcmk_remote_authkey", rewrite_existing=True, ) output_data[file_id] = written_output_dict if corosync_authkey: file_id = "corosync authkey" input_data[file_id] = dict( data=base64.b64encode(corosync_authkey).decode("utf-8"), type="corosync_authkey", rewrite_existing=True, ) output_data[file_id] = written_output_dict if corosync_conf: file_id = "corosync.conf" input_data[file_id] = dict( data=corosync_conf, type="corosync_conf", ) output_data[file_id] = written_output_dict if pcs_settings_conf: file_id = "pcs_settings.conf" input_data[file_id] = dict( data=pcs_settings_conf, type="pcs_settings_conf", rewrite_existing=True, ) output_data[file_id] = written_output_dict place_multinode_call(self.__calls, name, node_labels, communication_list, action="remote/put_file", param_list=[("data_json", json.dumps(input_data)) ], output=json.dumps(dict(files=output_data)))
def place_multinode_call(self, *args, **kwargs): place_multinode_call(self.__calls, *args, **kwargs)