def config_ticket_add(env,
ticket_name,
options,
instance_name=None,
allow_unknown_options=False):
"""
add a ticket to booth configuration
LibraryEnvironment env
string ticket_name -- the name of the ticket to be created
dict options -- options for the ticket
string instance_name -- booth instance name
bool allow_unknown_options -- allow using options unknown to pcs
"""
report_processor = SimpleReportProcessor(env.report_processor)
booth_env = env.get_booth_env(instance_name)
try:
booth_conf = booth_env.config.read_to_facade()
report_processor.report_list(
config_validators.add_ticket(
booth_conf,
ticket_name,
options,
allow_unknown_options=allow_unknown_options))
if report_processor.has_errors:
raise LibraryError()
booth_conf.add_ticket(ticket_name, options)
booth_env.config.write_facade(booth_conf, can_overwrite=True)
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
except ParserErrorException as e:
report_processor.report_list(
booth_env.config.parser_exception_to_report_list(e))
if report_processor.has_errors:
raise LibraryError()
def config_ticket_remove(
env: LibraryEnvironment, ticket_name, instance_name=None,
):
"""
remove a ticket from booth configuration
env
string ticket_name -- the name of the ticket to be removed
string instance_name -- booth instance name
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
try:
booth_conf = booth_env.config.read_to_facade()
report_processor.report_list(
config_validators.remove_ticket(booth_conf, ticket_name)
)
if report_processor.has_errors:
raise LibraryError()
booth_conf.remove_ticket(ticket_name)
booth_env.config.write_facade(booth_conf, can_overwrite=True)
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
except ParserErrorException as e:
report_processor.report_list(
booth_env.config.parser_exception_to_report_list(e)
)
if report_processor.has_errors:
raise LibraryError()
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 config_sync(
env: LibraryEnvironment,
instance_name=None,
skip_offline_nodes=False,
):
"""
Send specified local booth configuration to all nodes in the local cluster.
env
string instance_name -- booth instance name
skip_offline_nodes -- if True offline nodes will be skipped
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
if not env.is_cib_live:
raise LibraryError(
reports.live_environment_required([file_type_codes.CIB], ))
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())
report_processor.report_list(report_list)
try:
booth_conf_data = booth_env.config.read_raw()
booth_conf = booth_env.config.raw_to_facade(booth_conf_data)
if isinstance(booth_env.config.raw_file, GhostFile):
authfile_data = booth_env.key.read_raw()
authfile_path = booth_conf.get_authfile()
authfile_name = (os.path.basename(authfile_path)
if authfile_path else None)
else:
authfile_name, authfile_data, authfile_report_list = (
config_files.get_authfile_name_and_data(booth_conf))
report_processor.report_list(authfile_report_list)
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
except ParserErrorException as e:
report_processor.report_list(
booth_env.config.parser_exception_to_report_list(e))
if report_processor.has_errors:
raise LibraryError()
com_cmd = BoothSendConfig(env.report_processor,
booth_env.instance_name,
booth_conf_data,
authfile=authfile_name,
authfile_data=authfile_data,
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 _load_dr_config(
config_file: FileInstance, ) -> Tuple[ReportItemList, DrConfigFacade]:
if not config_file.raw_file.exists():
return [reports.dr_config_does_not_exist()], DrConfigFacade.empty()
try:
return [], config_file.read_to_facade()
except RawFileError as e:
return [raw_file_error_report(e)], DrConfigFacade.empty()
except ParserErrorException as e:
return (config_file.parser_exception_to_report_list(e),
DrConfigFacade.empty())
def get_local_corosync_conf():
"""
Read corosync.conf file from local machine
"""
# TODO The architecture of working with corosync.conf needs to be
# overhauled to match the new file framework.
instance = FileInstance.for_corosync_conf()
try:
return instance.read_raw().decode("utf-8")
except RawFileError as e:
raise LibraryError(raw_file_error_report(e)) from e
def _load_dr_config(
config_file: FileInstance, ) -> Tuple[ReportItemList, DrConfigFacade]:
if not config_file.raw_file.exists():
return (
[
ReportItem.error(reports.messages.DrConfigDoesNotExist()),
],
DrConfigFacade.empty(),
)
try:
return [], cast(DrConfigFacade, config_file.read_to_facade())
except RawFileError as e:
return [raw_file_error_report(e)], DrConfigFacade.empty()
except ParserErrorException as e:
return (
config_file.parser_exception_to_report_list(e),
DrConfigFacade.empty(),
)
def config_text(env: LibraryEnvironment, instance_name=None, node_name=None):
"""
get configuration in raw format
env
string instance_name -- booth instance name
string node_name -- get the config from specified node or local host if None
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
instance_name = booth_env.instance_name
# It does not make any sense for the cli to read a ghost file and send it
# to lib so that the lib could return it unchanged to cli. Just use 'cat'.
# When node_name is specified, using ghost files doesn't make any sense
# either.
_ensure_live_env(env, booth_env)
if node_name is None:
try:
return booth_env.config.read_raw()
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
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.
remote_data = run_and_raise(env.get_node_communicator(), com_cmd)[0][1]
try:
# TODO switch to new file transfer commands (not implemented yet)
# which send and receive configs as bytes instead of strings
return remote_data["config"]["data"].encode("utf-8")
except KeyError:
raise LibraryError(
ReportItem.error(reports.messages.InvalidResponseFormat(node_name))
)
def config_destroy(
env: LibraryEnvironment,
instance_name=None,
ignore_config_load_problems=False,
):
# pylint: disable=too-many-branches
"""
remove booth configuration files
env
string instance_name -- booth instance name
bool ignore_config_load_problems -- delete as much as possible when unable
to read booth configs for the given booth instance
"""
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)
# TODO use constants in reports
if resource.find_for_config(
get_resources(env.get_cib()), booth_env.config_path,
):
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
instance_name, "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", instance_name
):
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
instance_name, "(running in systemd)",
)
)
)
if external.is_service_enabled(
env.cmd_runner(), "booth", instance_name
):
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
instance_name, "(enabled in systemd)",
)
)
)
if report_processor.has_errors:
raise LibraryError()
try:
authfile_path = None
booth_conf = booth_env.config.read_to_facade()
authfile_path = booth_conf.get_authfile()
except RawFileError as e:
report_processor.report(
raw_file_error_report(
e,
force_code=report_codes.FORCE_BOOTH_DESTROY,
is_forced_or_warning=ignore_config_load_problems,
)
)
except ParserErrorException as e:
report_processor.report_list(
booth_env.config.parser_exception_to_report_list(
e,
force_code=report_codes.FORCE_BOOTH_DESTROY,
is_forced_or_warning=ignore_config_load_problems,
)
)
if report_processor.has_errors:
raise LibraryError()
if authfile_path:
authfile_dir, authfile_name = os.path.split(authfile_path)
if (authfile_dir == settings.booth_config_dir) and authfile_name:
try:
key_file = FileInstance.for_booth_key(authfile_name)
key_file.raw_file.remove(fail_if_file_not_found=False)
except RawFileError as e:
report_processor.report(
raw_file_error_report(
e,
force_code=report_codes.FORCE_BOOTH_DESTROY,
is_forced_or_warning=ignore_config_load_problems,
)
)
else:
report_processor.report(
ReportItem.warning(
reports.messages.BoothUnsupportedFileLocation(
authfile_path,
settings.booth_config_dir,
file_type_codes.BOOTH_KEY,
)
)
)
if report_processor.has_errors:
raise LibraryError()
try:
booth_env.config.raw_file.remove()
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
def create_in_cluster(
env: LibraryEnvironment,
ip,
instance_name=None,
allow_absent_resource_agent=False,
):
"""
Create group with ip resource and booth resource
env -- provides all for communication with externals
string ip -- float ip address for the operation of the booth
string instance_name -- booth instance name
bool allow_absent_resource_agent -- allowing creating booth resource even
if its agent is not installed
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
# Booth config path goes to CIB. Working with a mocked booth configs would
# not work coorectly as the path would point to a mock file (the path to a
# mock file is unknown to us in the lib anyway)
# It makes sense to work with a mocked CIB, though. Users can do other
# changes to the CIB and push them to the cluster at once.
_ensure_live_booth_env(booth_env)
resources_section = get_resources(env.get_cib())
id_provider = IdProvider(resources_section)
instance_name = booth_env.instance_name
# validate
if resource.find_for_config(resources_section, booth_env.config_path):
report_processor.report(
ReportItem.error(reports.messages.BoothAlreadyInCib(instance_name))
)
# verify the config exists and is readable
try:
booth_env.config.raw_file.read()
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
# validation done
create_id = partial(
resource.create_resource_id, resources_section, instance_name
)
get_agent = partial(
find_valid_resource_agent_by_name,
env.report_processor,
env.cmd_runner(),
allowed_absent=allow_absent_resource_agent,
)
create_primitive = partial(
primitive.create, env.report_processor, resources_section, id_provider
)
into_booth_group = partial(
group.place_resource,
group.provide_group(resources_section, create_id("group")),
)
into_booth_group(
create_primitive(
create_id("ip"),
get_agent("ocf:heartbeat:IPaddr2"),
instance_attributes={"ip": ip},
)
)
into_booth_group(
create_primitive(
create_id("service"),
get_agent("ocf:pacemaker:booth-site"),
instance_attributes={"config": booth_env.config_path},
)
)
env.push_cib()
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(
ReportItem.info(reports.messages.BoothConfigDistributionStarted()))
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 _prepare_pacemaker_remote_environment(
env,
report_processor,
existing_nodes_target_list,
new_node_target,
new_node_name,
skip_offline_nodes,
allow_incomplete_distribution,
allow_fails,
):
if new_node_target:
com_cmd = GetOnlineTargets(
report_processor,
ignore_offline_targets=skip_offline_nodes,
)
com_cmd.set_targets([new_node_target])
online_new_target_list = run_com(env.get_node_communicator(), com_cmd)
if not online_new_target_list and not skip_offline_nodes:
raise LibraryError()
else:
online_new_target_list = []
# check new nodes
if online_new_target_list:
com_cmd = GetHostInfo(report_processor)
com_cmd.set_targets(online_new_target_list)
report_processor.report_list(
_host_check_remote_node(
run_com(env.get_node_communicator(), com_cmd)))
if report_processor.has_errors:
raise LibraryError()
else:
report_processor.report_list(
_reports_skip_new_node(new_node_name, "unreachable"))
# share pacemaker authkey
authkey_file = FileInstance.for_pacemaker_key()
try:
if authkey_file.raw_file.exists():
authkey_content = authkey_file.read_raw()
authkey_targets = online_new_target_list
else:
authkey_content = generate_binary_key(
random_bytes_count=settings.pacemaker_authkey_bytes)
authkey_targets = (existing_nodes_target_list +
online_new_target_list)
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
if authkey_targets:
com_cmd = DistributeFiles(
report_processor,
node_communication_format.pcmk_authkey_file(authkey_content),
skip_offline_targets=skip_offline_nodes,
allow_fails=allow_incomplete_distribution,
)
com_cmd.set_targets(authkey_targets)
run_and_raise(env.get_node_communicator(), com_cmd)
# start and enable pacemaker_remote
if online_new_target_list:
com_cmd = ServiceAction(
report_processor,
node_communication_format.create_pcmk_remote_actions([
"start",
"enable",
]),
allow_fails=allow_fails,
)
com_cmd.set_targets(online_new_target_list)
run_and_raise(env.get_node_communicator(), com_cmd)
def create_in_cluster(
env: LibraryEnvironment,
ip: str,
instance_name: Optional[str] = None,
allow_absent_resource_agent: bool = False,
):
"""
Create group with ip resource and booth resource
env -- provides all for communication with externals
ip -- float ip address for the operation of the booth
instance_name -- booth instance name
allow_absent_resource_agent -- allowing creating booth resource even
if its agent is not installed
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
# Booth config path goes to CIB. Working with a mocked booth configs would
# not work coorectly as the path would point to a mock file (the path to a
# mock file is unknown to us in the lib anyway)
# It makes sense to work with a mocked CIB, though. Users can do other
# changes to the CIB and push them to the cluster at once.
_ensure_live_booth_env(booth_env)
resources_section = get_resources(env.get_cib())
id_provider = IdProvider(resources_section)
instance_name = booth_env.instance_name
# validate
if resource.find_for_config(resources_section, booth_env.config_path):
report_processor.report(
ReportItem.error(reports.messages.BoothAlreadyInCib(instance_name))
)
# verify the config exists and is readable
try:
booth_env.config.raw_file.read()
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
# validation done
create_id = partial(
resource.create_resource_id, resources_section, instance_name
)
create_primitive = partial(
primitive.create, env.report_processor, resources_section, id_provider
)
agent_factory = ResourceAgentFacadeFactory(
env.cmd_runner(), report_processor
)
# Group id validation is not needed since create_id creates a new unique
# booth group identifier
hierarchy.move_resources_to_group(
group.append_new(resources_section, create_id("group")),
[
create_primitive(
create_id("ip"),
_get_agent_facade(
env.report_processor,
agent_factory,
allow_absent_resource_agent,
ResourceAgentName("ocf", "heartbeat", "IPaddr2"),
),
instance_attributes={"ip": ip},
),
create_primitive(
create_id("service"),
_get_agent_facade(
env.report_processor,
agent_factory,
allow_absent_resource_agent,
ResourceAgentName("ocf", "pacemaker", "booth-site"),
),
instance_attributes={"config": booth_env.config_path},
),
],
)
env.push_cib()
def config_destroy(
env: LibraryEnvironment,
instance_name: Optional[str] = None,
ignore_config_load_problems: bool = False,
) -> None:
# pylint: disable=too-many-branches
"""
remove booth configuration files
env
instance_name -- booth instance name
ignore_config_load_problems -- delete as much as possible when unable to
read booth configs for the given booth instance
"""
report_processor = env.report_processor
booth_env = env.get_booth_env(instance_name)
found_instance_name = booth_env.instance_name
_ensure_live_env(env, booth_env)
booth_resource_list = resource.find_for_config(
get_resources(env.get_cib()),
booth_env.config_path,
)
if booth_resource_list:
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
found_instance_name,
reports.const.BOOTH_CONFIG_USED_IN_CLUSTER_RESOURCE,
resource_name=str(booth_resource_list[0].get("id", "")),
)
)
)
# Only systemd is currently supported. Initd does not supports multiple
# instances (here specified by name)
if is_systemd(env.service_manager):
if env.service_manager.is_running("booth", found_instance_name):
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
found_instance_name,
reports.const.BOOTH_CONFIG_USED_RUNNING_IN_SYSTEMD,
)
)
)
if env.service_manager.is_enabled("booth", found_instance_name):
report_processor.report(
ReportItem.error(
reports.messages.BoothConfigIsUsed(
found_instance_name,
reports.const.BOOTH_CONFIG_USED_ENABLED_IN_SYSTEMD,
)
)
)
if report_processor.has_errors:
raise LibraryError()
try:
authfile_path = None
booth_conf = booth_env.config.read_to_facade()
authfile_path = booth_conf.get_authfile()
except RawFileError as e:
report_processor.report(
raw_file_error_report(
e,
force_code=report_codes.FORCE,
is_forced_or_warning=ignore_config_load_problems,
)
)
except ParserErrorException as e:
report_processor.report_list(
booth_env.config.parser_exception_to_report_list(
e,
force_code=report_codes.FORCE,
is_forced_or_warning=ignore_config_load_problems,
)
)
if report_processor.has_errors:
raise LibraryError()
if authfile_path:
authfile_dir, authfile_name = os.path.split(authfile_path)
if (authfile_dir == settings.booth_config_dir) and authfile_name:
try:
key_file = FileInstance.for_booth_key(authfile_name)
key_file.raw_file.remove(fail_if_file_not_found=False)
except RawFileError as e:
report_processor.report(
raw_file_error_report(
e,
force_code=report_codes.FORCE,
is_forced_or_warning=ignore_config_load_problems,
)
)
else:
report_processor.report(
ReportItem.warning(
reports.messages.BoothUnsupportedFileLocation(
authfile_path,
settings.booth_config_dir,
file_type_codes.BOOTH_KEY,
)
)
)
if report_processor.has_errors:
raise LibraryError()
try:
booth_env.config.raw_file.remove()
except RawFileError as e:
report_processor.report(raw_file_error_report(e))
if report_processor.has_errors:
raise LibraryError()
