def config_sync(env, skip_offline_nodes=False):
"""
Send specified local booth configuration to all nodes in cluster.
env -- LibraryEnvironment
skip_offline_nodes -- if True offline nodes will be skipped
"""
config = env.booth.get_config_content()
authfile_path = config_structure.get_authfile(parse(config))
authfile_content = config_files.read_authfile(
env.report_processor, authfile_path
)
com_cmd = BoothSendConfig(
env.report_processor,
env.booth.name,
config,
authfile=authfile_path,
authfile_data=authfile_content,
skip_offline_targets=skip_offline_nodes
)
com_cmd.set_targets(
env.get_node_target_factory().get_target_list(
env.get_corosync_conf().get_nodes_names(),
skip_non_existing=skip_offline_nodes,
)
)
run_and_raise(env.get_node_communicator(), com_cmd)
def config_sync(env, skip_offline_nodes=False):
"""
Send specified local booth configuration to all nodes in cluster.
env -- LibraryEnvironment
skip_offline_nodes -- if True offline nodes will be skipped
"""
config = env.booth.get_config_content()
authfile_path = config_structure.get_authfile(parse(config))
authfile_content = config_files.read_authfile(
env.report_processor, authfile_path
)
cluster_nodes_names, report_list = get_existing_nodes_names(
env.get_corosync_conf()
)
if not cluster_nodes_names:
report_list.append(reports.corosync_config_no_nodes_defined())
env.report_processor.process_list(report_list)
com_cmd = BoothSendConfig(
env.report_processor,
env.booth.name,
config,
authfile=authfile_path,
authfile_data=authfile_content,
skip_offline_targets=skip_offline_nodes
)
com_cmd.set_targets(
env.get_node_target_factory().get_target_list(
cluster_nodes_names,
skip_non_existing=skip_offline_nodes,
)
)
run_and_raise(env.get_node_communicator(), com_cmd)
def send_all_config_to_node(
communicator,
reporter,
target_list,
rewrite_existing=False,
skip_wrong_config=False
):
"""
Send all booth configs from default booth config directory and theri
authfiles to specified node.
communicator -- NodeCommunicator
reporter -- report processor
target_list list -- list of targets to which configs should be delivered
rewrite_existing -- if True rewrite existing file
skip_wrong_config -- if True skip local configs that are unreadable
"""
_reporter = SimpleReportProcessor(reporter)
config_dict = booth_conf.read_configs(reporter, skip_wrong_config)
if not config_dict:
return
_reporter.report(reports.booth_config_distribution_started())
file_list = []
for config, config_data in sorted(config_dict.items()):
try:
authfile_path = config_structure.get_authfile(
config_parser.parse(config_data)
)
file_list.append({
"name": config,
"data": config_data,
"is_authfile": False
})
if authfile_path:
content = booth_conf.read_authfile(reporter, authfile_path)
if not content:
continue
file_list.append({
"name": os.path.basename(authfile_path),
"data": base64.b64encode(content).decode("utf-8"),
"is_authfile": True
})
except LibraryError:
_reporter.report(reports.booth_skipping_config(
config, "unable to parse config"
))
com_cmd = BoothSaveFiles(
_reporter, file_list, rewrite_existing=rewrite_existing
)
com_cmd.set_targets(target_list)
run(communicator, com_cmd)
if _reporter.has_errors:
raise LibraryError()
def send_all_config_to_node(communicator,
reporter,
target_list,
rewrite_existing=False,
skip_wrong_config=False):
"""
Send all booth configs from default booth config directory and theri
authfiles to specified node.
communicator -- NodeCommunicator
reporter -- report processor
target_list list -- list of targets to which configs should be delivered
rewrite_existing -- if True rewrite existing file
skip_wrong_config -- if True skip local configs that are unreadable
"""
_reporter = SimpleReportProcessor(reporter)
config_dict = booth_conf.read_configs(reporter, skip_wrong_config)
if not config_dict:
return
_reporter.report(reports.booth_config_distribution_started())
file_list = []
for config, config_data in sorted(config_dict.items()):
try:
authfile_path = config_structure.get_authfile(
config_parser.parse(config_data))
file_list.append({
"name": config,
"data": config_data,
"is_authfile": False
})
if authfile_path:
content = booth_conf.read_authfile(reporter, authfile_path)
if not content:
continue
file_list.append({
"name":
os.path.basename(authfile_path),
"data":
base64.b64encode(content).decode("utf-8"),
"is_authfile":
True
})
except LibraryError:
_reporter.report(
reports.booth_skipping_config(config,
"unable to parse config"))
com_cmd = BoothSaveFiles(_reporter,
file_list,
rewrite_existing=rewrite_existing)
com_cmd.set_targets(target_list)
run(communicator, com_cmd)
if _reporter.has_errors:
raise LibraryError()
def config_destroy(env, ignore_config_load_problems=False):
env.booth.command_expect_live_env()
if not env.is_cib_live:
raise LibraryError(reports.live_environment_required(["CIB"]))
name = env.booth.name
config_is_used = partial(booth_reports.booth_config_is_used, name)
report_list = []
if resource.find_for_config(
get_resources(env.get_cib()),
get_config_file_name(name),
):
report_list.append(config_is_used("in cluster resource"))
#Only systemd is currently supported. Initd does not supports multiple
#instances (here specified by name)
if external.is_systemctl():
if external.is_service_running(env.cmd_runner(), "booth", name):
report_list.append(config_is_used("(running in systemd)"))
if external.is_service_enabled(env.cmd_runner(), "booth", name):
report_list.append(config_is_used("(enabled in systemd)"))
if report_list:
raise LibraryError(*report_list)
authfile_path = None
try:
authfile_path = config_structure.get_authfile(
parse(env.booth.get_config_content())
)
except LibraryError:
if not ignore_config_load_problems:
raise LibraryError(booth_reports.booth_cannot_identify_keyfile())
#if content not received, not valid,... still remove config needed
env.report_processor.process(
booth_reports.booth_cannot_identify_keyfile(
severity=ReportItemSeverity.WARNING
)
)
if(
authfile_path
and
os.path.dirname(authfile_path) == settings.booth_config_dir
):
env.booth.set_key_path(authfile_path)
env.booth.remove_key()
env.booth.remove_config()
def config_destroy(env, ignore_config_load_problems=False):
env.booth.command_expect_live_env()
if not env.is_cib_live:
raise LibraryError(reports.live_environment_required(["CIB"]))
name = env.booth.name
config_is_used = partial(booth_reports.booth_config_is_used, name)
report_list = []
if resource.find_for_config(
get_resources(env.get_cib()),
get_config_file_name(name),
):
report_list.append(config_is_used("in cluster resource"))
#Only systemd is currently supported. Initd does not supports multiple
#instances (here specified by name)
if external.is_systemctl():
if external.is_service_running(env.cmd_runner(), "booth", name):
report_list.append(config_is_used("(running in systemd)"))
if external.is_service_enabled(env.cmd_runner(), "booth", name):
report_list.append(config_is_used("(enabled in systemd)"))
if report_list:
raise LibraryError(*report_list)
authfile_path = None
try:
authfile_path = config_structure.get_authfile(
parse(env.booth.get_config_content())
)
except LibraryError:
if not ignore_config_load_problems:
raise LibraryError(booth_reports.booth_cannot_identify_keyfile())
#if content not received, not valid,... still remove config needed
env.report_processor.process(
booth_reports.booth_cannot_identify_keyfile(
severity=ReportItemSeverity.WARNING
)
)
if(
authfile_path
and
os.path.dirname(authfile_path) == settings.booth_config_dir
):
env.booth.set_key_path(authfile_path)
env.booth.remove_key()
env.booth.remove_config()
def config_sync(env, name, skip_offline_nodes=False):
"""
Send specified local booth configuration to all nodes in cluster.
env -- LibraryEnvironment
name -- booth instance name
skip_offline_nodes -- if True offline nodes will be skipped
"""
config = env.booth.get_config_content()
authfile_path = config_structure.get_authfile(parse(config))
authfile_content = config_files.read_authfile(env.report_processor,
authfile_path)
sync.send_config_to_all_nodes(env.node_communicator(),
env.report_processor,
env.get_corosync_conf().get_nodes(),
name,
config,
authfile=authfile_path,
authfile_data=authfile_content,
skip_offline=skip_offline_nodes)
def config_sync(env, name, skip_offline_nodes=False):
"""
Send specified local booth configuration to all nodes in cluster.
env -- LibraryEnvironment
name -- booth instance name
skip_offline_nodes -- if True offline nodes will be skipped
"""
config = env.booth.get_config_content()
authfile_path = config_structure.get_authfile(parse(config))
authfile_content = config_files.read_authfile(
env.report_processor, authfile_path
)
sync.send_config_to_all_nodes(
env.node_communicator(),
env.report_processor,
env.get_corosync_conf().get_nodes(),
name,
config,
authfile=authfile_path,
authfile_data=authfile_content,
skip_offline=skip_offline_nodes
)
def send_all_config_to_node(
communicator,
reporter,
target,
rewrite_existing=False,
skip_wrong_config=False
):
"""
Send all booth configs from default booth config directory and theri
authfiles to specified node.
communicator -- NodeCommunicator
reporter -- report processor
node -- NodeAddress
rewrite_existing -- if True rewrite existing file
skip_wrong_config -- if True skip local configs that are unreadable
"""
config_dict = booth_conf.read_configs(reporter, skip_wrong_config)
if not config_dict:
return
reporter.process(reports.booth_config_distribution_started())
file_list = []
for config, config_data in sorted(config_dict.items()):
try:
authfile_path = config_structure.get_authfile(
config_parser.parse(config_data)
)
file_list.append({
"name": config,
"data": config_data,
"is_authfile": False
})
if authfile_path:
content = booth_conf.read_authfile(reporter, authfile_path)
if not content:
continue
file_list.append({
"name": os.path.basename(authfile_path),
"data": base64.b64encode(content).decode("utf-8"),
"is_authfile": True
})
except LibraryError:
reporter.process(reports.booth_skipping_config(
config, "unable to parse config"
))
com_cmd = BoothSaveFiles(
reporter, file_list, rewrite_existing=rewrite_existing
)
com_cmd.set_targets([target])
response = run_and_raise(communicator, com_cmd)[0][1]
try:
report_list = []
for file in response["existing"]:
report_list.append(lib_reports.file_already_exists(
None,
file,
Severities.WARNING if rewrite_existing else Severities.ERROR,
(
None if rewrite_existing
else report_codes.FORCE_FILE_OVERWRITE
),
target.label
))
for file, reason in response["failed"].items():
report_list.append(reports.booth_config_distribution_node_error(
target.label, reason, file
))
reporter.process_list(report_list)
reporter.process(
reports.booth_config_accepted_by_node(target.label, response["saved"])
)
except (KeyError, ValueError):
raise LibraryError(lib_reports.invalid_response_format(target.label))
def send_all_config_to_node(
communicator,
reporter,
node,
rewrite_existing=False,
skip_wrong_config=False
):
"""
Send all booth configs from default booth config directory and theri
authfiles to specified node.
communicator -- NodeCommunicator
reporter -- report processor
node -- NodeAddress
rewrite_existing -- if True rewrite existing file
skip_wrong_config -- if True skip local configs that are unreadable
"""
config_dict = booth_conf.read_configs(reporter, skip_wrong_config)
if not config_dict:
return
file_list = []
for config, config_data in sorted(config_dict.items()):
try:
authfile_path = config_structure.get_authfile(
config_parser.parse(config_data)
)
file_list.append({
"name": config,
"data": config_data,
"is_authfile": False
})
if authfile_path:
content = booth_conf.read_authfile(reporter, authfile_path)
if not content:
continue
file_list.append({
"name": os.path.basename(authfile_path),
"data": base64.b64encode(content).decode("utf-8"),
"is_authfile": True
})
except LibraryError:
reporter.process(reports.booth_skipping_config(
config, "unable to parse config"
))
data = [("data_json", json.dumps(file_list))]
if rewrite_existing:
data.append(("rewrite_existing", "1"))
reporter.process(reports.booth_sending_local_configs_to_node(node.label))
try:
response = json.loads(communicator.call_node(
node,
"remote/booth_save_files",
NodeCommunicator.format_data_dict(data)
))
report_list = []
for file in response["existing"]:
report_list.append(lib_reports.file_already_exists(
None,
file,
Severities.WARNING if rewrite_existing else Severities.ERROR,
(
None if rewrite_existing
else report_codes.FORCE_FILE_OVERWRITE
),
node.label
))
for file, reason in response["failed"].items():
report_list.append(reports.booth_config_not_saved(
node.label, reason, file
))
reporter.process_list(report_list)
reporter.process(
reports.booth_config_saved(node.label, response["saved"])
)
except NodeCommunicationException as e:
raise LibraryError(node_communicator_exception_to_report_item(e))
except (KeyError, ValueError):
raise LibraryError(lib_reports.invalid_response_format(node.label))
def send_all_config_to_node(
communicator,
reporter,
node,
rewrite_existing=False,
skip_wrong_config=False
):
"""
Send all booth configs from default booth config directory and theri
authfiles to specified node.
communicator -- NodeCommunicator
reporter -- report processor
node -- NodeAddress
rewrite_existing -- if True rewrite existing file
skip_wrong_config -- if True skip local configs that are unreadable
"""
config_dict = booth_conf.read_configs(reporter, skip_wrong_config)
if not config_dict:
return
reporter.process(reports.booth_config_distribution_started())
file_list = []
for config, config_data in sorted(config_dict.items()):
try:
authfile_path = config_structure.get_authfile(
config_parser.parse(config_data)
)
file_list.append({
"name": config,
"data": config_data,
"is_authfile": False
})
if authfile_path:
content = booth_conf.read_authfile(reporter, authfile_path)
if not content:
continue
file_list.append({
"name": os.path.basename(authfile_path),
"data": base64.b64encode(content).decode("utf-8"),
"is_authfile": True
})
except LibraryError:
reporter.process(reports.booth_skipping_config(
config, "unable to parse config"
))
data = [("data_json", json.dumps(file_list))]
if rewrite_existing:
data.append(("rewrite_existing", "1"))
try:
response = json.loads(communicator.call_node(
node,
"remote/booth_save_files",
NodeCommunicator.format_data_dict(data)
))
report_list = []
for file in response["existing"]:
report_list.append(lib_reports.file_already_exists(
None,
file,
Severities.WARNING if rewrite_existing else Severities.ERROR,
(
None if rewrite_existing
else report_codes.FORCE_FILE_OVERWRITE
),
node.label
))
for file, reason in response["failed"].items():
report_list.append(reports.booth_config_distribution_node_error(
node.label, reason, file
))
reporter.process_list(report_list)
reporter.process(
reports.booth_config_accepted_by_node(node.label, response["saved"])
)
except NodeCommunicationException as e:
raise LibraryError(node_communicator_exception_to_report_item(e))
except (KeyError, ValueError):
raise LibraryError(lib_reports.invalid_response_format(node.label))