def test_success(self):
assert_report_item_list_equal(
config_validators.check_instance_name(
"valid_instance"
),
[]
)
def pull_config(env: LibraryEnvironment, node_name, instance_name=None):
"""
Get config from specified node and save it on local system. It will
rewrite existing files.
env
string node_name -- name of the node from which the config should be fetched
string instance_name -- booth instance name
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
instance_name = booth_env.instance_name
_ensure_live_env(env, booth_env)
conf_dir = os.path.dirname(booth_env.config_path)
env.report_processor.report(
ReportItem.info(
reports.messages.BoothFetchingConfigFromNode(
node_name,
config=instance_name,
)))
com_cmd = BoothGetConfig(env.report_processor, instance_name)
com_cmd.set_targets(
[env.get_node_target_factory().get_target_from_hostname(node_name)])
# pylint: disable=unsubscriptable-object
# In general, pylint is right. And it cannot know in this case code is OK.
# It is covered by tests.
output = run_and_raise(env.get_node_communicator(), com_cmd)[0][1]
try:
# TODO adapt to new file transfer framework once it is written
if (output["authfile"]["name"] is not None
and output["authfile"]["data"]):
authfile_name = output["authfile"]["name"]
report_list = config_validators.check_instance_name(authfile_name)
if report_list:
raise LibraryError(*report_list)
booth_key = FileInstance.for_booth_key(authfile_name)
booth_key.write_raw(
base64.b64decode(output["authfile"]["data"].encode("utf-8")),
can_overwrite=True,
)
booth_env.config.write_raw(output["config"]["data"].encode("utf-8"),
can_overwrite=True)
env.report_processor.report(
ReportItem.info(
reports.messages.BoothConfigAcceptedByNode(
name_list=[instance_name])))
except RawFileError as e:
if not os.path.exists(conf_dir):
report_processor.report(
ReportItem.error(
reports.messages.BoothPathNotExists(conf_dir)))
else:
report_processor.report(raw_file_error_report(e))
except KeyError as e:
raise LibraryError(
ReportItem.error(
reports.messages.InvalidResponseFormat(node_name))) from e
if report_processor.has_errors:
raise LibraryError()
def config_setup(
env: LibraryEnvironment,
site_list,
arbitrator_list,
instance_name=None,
overwrite_existing=False,
):
"""
create booth configuration
env
list site_list -- site adresses of multisite
list arbitrator_list -- arbitrator adresses of multisite
string instance_name -- booth instance name
bool overwrite_existing -- allow overwriting existing files
"""
instance_name = instance_name or constants.DEFAULT_INSTANCE_NAME
report_processor = env.report_processor
report_processor.report_list(
config_validators.check_instance_name(instance_name)
)
report_processor.report_list(
config_validators.create(site_list, arbitrator_list)
)
if report_processor.has_errors:
raise LibraryError()
booth_env = env.get_booth_env(instance_name)
booth_conf = booth_env.create_facade(site_list, arbitrator_list)
booth_conf.set_authfile(booth_env.key_path)
try:
booth_env.key.write_raw(
tools.generate_binary_key(
random_bytes_count=settings.booth_authkey_bytes
),
can_overwrite=overwrite_existing,
)
booth_env.config.write_facade(
booth_conf, can_overwrite=overwrite_existing
)
except FileAlreadyExists as e:
report_processor.report(
ReportItem(
severity=reports.item.get_severity(
reports.codes.FORCE,
overwrite_existing,
),
message=reports.messages.FileAlreadyExists(
e.metadata.file_type_code,
e.metadata.path,
),
)
)
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
def test_report(self):
instance = "/tmp/booth/invalid_instance"
assert_report_item_list_equal(
config_validators.check_instance_name(instance),
[
fixture.error(
report_codes.BOOTH_INVALID_NAME,
name=instance,
reason="contains illegal character '/'",
),
]
)
def test_report(self):
instance = "/tmp/booth/invalid_instance"
assert_report_item_list_equal(
config_validators.check_instance_name(instance),
[
fixture.error(
report_codes.BOOTH_INVALID_NAME,
name=instance,
forbidden_characters="/",
),
],
)
def __init__(self, instance_name, booth_files_data):
"""
Create a new BoothEnv
string|None instance_name -- booth instance name
dict booth_files_data -- ghost files (config_data, key_data, key_path)
"""
if (
"config_data" in booth_files_data
and "key_data" not in booth_files_data
):
raise LibraryError(
ReportItem.error(
reports.messages.LiveEnvironmentNotConsistent(
[file_type_codes.BOOTH_CONFIG],
[file_type_codes.BOOTH_KEY],
)
)
)
if (
"config_data" not in booth_files_data
and "key_data" in booth_files_data
):
raise LibraryError(
ReportItem.error(
reports.messages.LiveEnvironmentNotConsistent(
[file_type_codes.BOOTH_KEY],
[file_type_codes.BOOTH_CONFIG],
)
)
)
self._instance_name = instance_name or constants.DEFAULT_INSTANCE_NAME
report_list = config_validators.check_instance_name(self._instance_name)
if report_list:
raise LibraryError(*report_list)
self._config_file = FileInstance.for_booth_config(
f"{self._instance_name}.conf",
**self._init_file_data(booth_files_data, "config_data"),
)
self._key_file = FileInstance.for_booth_key(
f"{self._instance_name}.key",
**self._init_file_data(booth_files_data, "key_data"),
)
if isinstance(self._key_file.raw_file, raw_file.GhostFile):
self._key_path = booth_files_data.get("key_path", "")
else:
self._key_path = self._key_file.raw_file.metadata.path
