def send_config_to_all_nodes(
communicator, reporter, node_list, name, config_data, authfile=None,
authfile_data=None, skip_offline=False
):
"""
Send config_data of specified booth instance from local node to all nodes in
node_list.
communicator -- NodeCommunicator
reporter -- report processor
node_list -- NodeAddressesList
name -- name of booth instance
config_data -- config_data content as string
authfile -- path to authfile
authfile_data -- content of authfile as bytes
skip_offline -- if True offline nodes will be skipped
"""
reporter.process(reports.booth_config_distribution_started())
parallel_nodes_communication_helper(
_set_config_on_node,
[
(
[
communicator, reporter, node, name, config_data,
authfile, authfile_data
],
{}
)
for node in node_list
],
reporter,
skip_offline
)
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 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 before(self):
self._report(reports_booth.booth_config_distribution_started())
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
"""
# TODO adapt to new file transfer framework once it is written
# TODO the function is not modular enough - it raises LibraryError
file_list = []
for conf_file_name in sorted(config_files.get_all_configs_file_names()):
config_file = FileInstance.for_booth_config(conf_file_name)
try:
booth_conf_data = config_file.raw_file.read()
authfile_name, authfile_data, authfile_report_list = (
config_files.get_authfile_name_and_data(
config_file.raw_to_facade(booth_conf_data)))
reporter.report_list(authfile_report_list)
file_list.append({
"name": conf_file_name,
"data": booth_conf_data.decode("utf-8"),
"is_authfile": False
})
if authfile_name and authfile_data:
file_list.append({
"name":
authfile_name,
"data":
base64.b64encode(authfile_data).decode("utf-8"),
"is_authfile":
True
})
except RawFileError as e:
reporter.report(
raw_file_error_report(
e,
force_code=report_codes.SKIP_UNREADABLE_CONFIG,
is_forced_or_warning=skip_wrong_config,
))
except ParserErrorException as e:
reporter.report_list(
config_file.parser_exception_to_report_list(
e,
force_code=report_codes.SKIP_UNREADABLE_CONFIG,
is_forced_or_warning=skip_wrong_config,
))
if reporter.has_errors:
raise LibraryError()
if not file_list:
# no booth configs exist, nothing to be synced
return
reporter.report(booth_reports.booth_config_distribution_started())
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 test_success(self):
self.assert_message_from_report(
"Sending booth configuration to cluster nodes...",
reports.booth_config_distribution_started())
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))
