def process(self):
if self.level == 'node':
new_conf_url = 'yaml:///opt/seagate/cortx/sspl/conf/sspl.conf.LR2.yaml'
merged_conf_url = 'yaml:///opt/seagate/cortx/sspl/tmp/merged.conf'
# Only proceed if both existing and new config path are present
for filepath in [sspl_config_path, new_conf_url]:
if not os.path.exists(filepath.split(":/")[1]):
logger.debug(
"Config not upgraded as existing or new config file is not present."
)
return
conf_upgrade = ConfUpgrade(sspl_config_path, new_conf_url,
merged_conf_url)
try:
conf_upgrade.create_merged_config()
except ConfError as e:
logger.error(
"%s error seen while upgrading config, existing config retained"
% e)
else:
conf_upgrade.upgrade_existing_config()
finally:
conf_upgrade.remove_merged_config()
elif self.level == 'cluster':
# No action needed
pass
def validate(self):
"""Check for below requirement.
1. Validate input configs
2. Validate sspl conf is created
3. Check if message bus is accessible
"""
if os.geteuid() != 0:
msg = "Run this command with root privileges."
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate input/provisioner configs
machine_id = Utility.get_machine_id()
Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>cluster_id" % machine_id)
self.node_type = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX, "server_node>%s>type" % machine_id)
enclosure_id = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>storage>enclosure_id" % machine_id)
self.enclosure_type = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"storage_enclosure>%s>type" % enclosure_id)
# Validate sspl conf is created
if not os.path.isfile(consts.file_store_config_path):
msg = "Missing configuration - %s !! Create and rerun." % (
consts.file_store_config_path)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate message bus is accessible
self.mb = MessageBus()
def enable_sspl_service(self):
"""Enable sspl-ll service."""
self.dbus_service.enable("sspl-ll.service")
daemon_reload_cmd = "systemctl daemon-reload"
output, error, rc = SimpleProcess(daemon_reload_cmd).run()
if rc != 0:
logger.error(f"Failed in enable sspl service. ERROR: {error}")
raise SetupError(rc, error, daemon_reload_cmd)
def validate(self):
"""Check below requirements are met in setup.
1. Check if given product is supported by SSPL
2. Check if given setup is supported by SSPL
3. Check if required pre-requisites softwares are installed.
4. Validate BMC connectivity
5. Validate storage controller connectivity
"""
machine_id = Utility.get_machine_id()
# Validate input/provisioner configs
self.product = Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"cortx>release>product")
self.setup = Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"cortx>release>setup")
node_type = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX, "server_node>%s>type" % machine_id)
if node_type.lower() not in ["vm", "virtual"]:
bmc_ip = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>bmc>ip" % machine_id)
enclosure_id = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>storage>enclosure_id" % machine_id)
Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"storage_enclosure>%s>type" % enclosure_id)
primary_ip = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"storage_enclosure>%s>controller>primary>ip" % enclosure_id)
secondary_ip = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"storage_enclosure>%s>controller>secondary>ip" % enclosure_id)
# Validate product support
if self.product not in consts.enabled_products:
msg = "Product '%s' is not in sspl supported product list: %s" % (
self.product, consts.enabled_products)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate setup support
if self.setup not in consts.setups:
msg = "Setup '%s' is not in sspl supported setup list: %s" % (
self.setup, consts.setups)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate required pip3s and rpms are installed
self.validate_dependencies(self.setup)
# Validate BMC & Storage controller IP reachability
if node_type.lower() not in ["vm", "virtual"]:
# cluster_id required for decrypting the secret is only available from
# the prepare stage. However accessibility validation will be done in
# prepare stage. So at this time, validating ip reachability is fine.
NetworkV().validate("connectivity",
[bmc_ip, primary_ip, secondary_ip])
def process(self):
try:
if os.path.exists(file_store_config_path):
os.remove(file_store_config_path)
shutil.copyfile(
"%s/conf/sspl.conf.%s.yaml" % (SSPL_BASE_DIR, self.product),
file_store_config_path)
logger.info("%s - Process done" % self.name)
except OSError as e:
logger.error(f"Failed in Cleanup. ERROR: {e}")
def process(self):
args = ' '.join(self._args.args)
manifest_support_bundle = "%s/%s %s" % (self._script_dir, self.script,
args)
_, error, rc = SimpleProcess(manifest_support_bundle).run(
realtime_output=True)
if rc != 0:
msg = "%s - validation failure. %s" % (self.name, error)
logger.error(msg)
raise SetupError(rc, msg)
logger.info("%s - Process done" % self.name)
def validate(self):
"""Validate init command arguments."""
if not self.args.config:
msg = "%s - Argument validation failure. %s" % (
self.name, "Global config is required.")
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Validate config inputs
Conf.load(PRVSNR_CONFIG_INDEX, self.args.config[0])
self.sspl_init.validate()
logger.info("%s - validation done" % self.name)
def validate_group_existence(self):
max_retry = 3
for i in range(max_retry):
sspl_gid = Utility.get_gid(consts.USER)
if sspl_gid != -1:
break
else:
if i == (max_retry - 1):
msg = "No group found with name : %s" % (consts.USER)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
time.sleep(1)
def validate(self):
# Validate config inputs
from framework.utils.utility import Utility
Conf.load(GLOBAL_CONFIG_INDEX, global_config_path)
self.product = Utility.get_config_value(GLOBAL_CONFIG_INDEX,
"cortx>release>product")
if self.product is None:
msg = "%s - validation failure. %s" % (
self.name,
"'Product' name is required to restore suitable configs.")
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
logger.info("%s - Validation done" % self.name)
def validate(self):
"""Validate test command arguments."""
if not self.args.config:
msg = "%s - Argument validation failure. %s" % (
self.name, "Global config is required.")
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
if not self.args.plan:
msg = "%s - Argument validation failure. Test plan is needed" % (
self.name)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
result = PkgV().validate("rpms", "sspl-test")
if result == -1:
msg = "'sspl-test' rpm pkg not found."
logger.error(msg)
raise SetupError(1, msg)
# Service restart is required for coverage.
# Hence it can be enabled only with test plans
# which are present in TEST_REQ_SERVICE_RESTART list.
if self.args.coverage and self.args.plan[
0] not in TEST_REQ_SERVICE_RESTART:
msg = "Code coverage can not be enabled for %s test plan." \
% self.args.plan[0]
logger.error(msg)
raise SetupError(errno.EINVAL,
"%s - Argument validation failure. %s", self.name,
msg)
logger.info("%s - Validation done" % self.name)
def create_user(self):
"""Add sspl-ll user and validate user creation."""
os.system("/usr/sbin/useradd -r %s -s /sbin/nologin \
-c 'User account to run the %s service'" % (consts.USER, consts.USER))
usernames = [x[0] for x in pwd.getpwall()]
if consts.USER not in usernames:
msg = "User %s doesn't exit. Please add user." % (consts.USER)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Add sspl-ll user to required groups and sudoers file etc.
sspl_reinit = "%s/low-level/framework/sspl_reinit" % consts.SSPL_BASE_DIR
_ , error, rc = SimpleProcess(sspl_reinit).run()
if rc:
msg = "%s failed for with error : %e" % (sspl_reinit, error)
logger.error(msg)
raise SetupError(rc, msg)
def validate_nw_interfaces(self, interfaces):
"""Check network intefaces are up."""
if not isinstance(interfaces, list):
msg = "%s - validation failure. %s" % (self.name,
"Expected list of interfaces. Received, %s." % interfaces)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
cmd = "ip --br a | awk '{print $1, $2}'"
nws = [nw.strip() for nw in os.popen(cmd)]
nw_status = {nw.split(" ")[0]: nw.split(" ")[1] for nw in nws}
for interface, status in nw_status.items():
if interface in interfaces and status in ["down", "DOWN"]:
msg = "%s - validation failure. %s" % (
self.name, "Network interface %s is down." % interface)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
def process(self):
"""Configure sensor monitoring and log level setting."""
# Update sspl.conf with provisioner supplied input config copy
Conf.set(consts.SSPL_CONFIG_INDEX,
"SYSTEM_INFORMATION>global_config_copy_url",
consts.global_config_path)
Conf.save(consts.SSPL_CONFIG_INDEX)
if os.path.isfile(consts.SSPL_CONFIGURED):
os.remove(consts.SSPL_CONFIGURED)
os.makedirs(consts.SSPL_CONFIGURED_DIR, exist_ok=True)
with open(consts.SSPL_CONFIGURED, 'a'):
os.utime(consts.SSPL_CONFIGURED)
sspl_uid = Utility.get_uid(consts.USER)
sspl_gid = Utility.get_gid(consts.USER)
Utility.set_ownership_recursively([consts.SSPL_CONFIGURED], sspl_uid,
sspl_gid)
# Get the types of server and storage we are currently running on and
# enable/disable sensor groups in the conf file accordingly.
update_sensor_info(consts.SSPL_CONFIG_INDEX, self.node_type,
self.enclosure_type)
# Message bus topic creation
self.create_message_types()
# Skip this step if sspl is being configured for node replacement
# scenario as consul data is already
# available on healthy node
# Updating build requested log level
if not os.path.exists(consts.REPLACEMENT_NODE_ENV_VAR_FILE):
with open(f"{consts.SSPL_BASE_DIR}/low-level/files/opt/seagate" + \
"/sspl/conf/build-requested-loglevel") as f:
log_level = f.read().strip()
if not log_level:
log_level = "INFO"
if log_level in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
Conf.set(consts.SSPL_CONFIG_INDEX,
"SYSTEM_INFORMATION>log_level", log_level)
Conf.save(consts.SSPL_CONFIG_INDEX)
else:
msg = "Unexpected log level is requested, '%s'" % (log_level)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
def process(self, product):
"""Reset and cleanup config.
if self.pre_factory:
Cleanup sspl log and config files and rollback all steps executed
in post_install stage.
else:
Reset sspl config.
"""
try:
if os.path.exists(file_store_config_path):
FileStore().delete(
file_store_config_path)
shutil.copyfile("%s/conf/sspl.conf.%s.yaml" % (
SSPL_BASE_DIR, product), file_store_config_path)
if self.pre_factory:
self.cleanup_log_and_config()
except OSError as e:
logger.error(f"Failed in Cleanup. ERROR: {e}")
def create_user(self):
"""Add sspl-ll user and validate user creation."""
command = f"/usr/sbin/useradd -r {consts.USER} -s /sbin/nologin \
-c 'User account to run the {consts.USER} service'"
_, error, rc = SimpleProcess(command).run()
# rc 9 means user already exists
if rc != 0 and rc != 9:
logger.error(f"Failed to create sspl user. ERROR: {error}")
raise SetupError(rc, error, command)
self.validate_user_existence()
self.validate_group_existence()
# Add sspl-ll user to required groups and sudoers file etc.
sspl_reinit = "%s/low-level/framework/sspl_reinit" % consts.SSPL_BASE_DIR
_, error, rc = SimpleProcess(sspl_reinit).run()
if rc:
msg = "%s failed for with error : %e" % (sspl_reinit, error)
logger.error(msg)
raise SetupError(rc, msg)
def validate_nw_cable_connection(self, interfaces):
"""Check network interface links are up.
0 - Cable disconnected
1 - Cable connected
"""
if not isinstance(interfaces, list):
msg = "%s - validation failure. %s" % (self.name,
"Expected list of interfaces. Received, %s." % interfaces)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
for interface in interfaces:
cmd = "cat /sys/class/net/%s/carrier" % interface
output, error, rc = SimpleProcess(cmd).run()
output = output.decode().strip()
if output == "0":
msg = "%s - validation failure. %s" % (self.name,
"Network interface cable is disconnected - %s." % interface)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
def create_directories_and_ownership(self):
"""Create ras persistent cache directory and state file.
Assign ownership recursively on the configured directory.
The created state file will be used later by SSPL resourse agent(HA).
"""
# Extract the data path
sspldp = Utility.get_config_value(consts.SSPL_CONFIG_INDEX,
"SYSTEM_INFORMATION>data_path")
if not sspldp:
raise SetupError(errno.EINVAL, "Data path not set in sspl.conf")
sspl_uid = Utility.get_uid(consts.USER)
sspl_gid = Utility.get_gid(consts.USER)
if sspl_uid == -1 or sspl_gid == -1:
msg = "No user found with name : %s" % (consts.USER)
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Create sspl data directory if not exists
os.makedirs(sspldp, exist_ok=True)
# Create state file under sspl data directory
if not os.path.exists(self.state_file):
file = open(self.state_file, "w")
file.close()
# Create SSPL log and bundle directories
os.makedirs(consts.SSPL_LOG_PATH, exist_ok=True)
os.makedirs(consts.SSPL_BUNDLE_PATH, exist_ok=True)
# set ownership for SSPL dirs
list_root_dir = [consts.SSPL_CONFIGURED_DIR, consts.SSPL_LOG_PATH]
Utility.set_ownership_recursively(list_root_dir, sspl_uid, sspl_gid)
# Create /tmp/dcs/hpi if required. Not required for '<product>' role
if self.setup != "cortx":
os.makedirs(consts.HPI_PATH, mode=0o777, exist_ok=True)
zabbix_uid = Utility.get_uid("zabbix")
if zabbix_uid != -1:
os.chown(consts.HPI_PATH, zabbix_uid, -1)
# Create mdadm.conf to set ACL on it.
with open(consts.MDADM_PATH, 'a'):
os.utime(consts.MDADM_PATH)
os.chmod(consts.MDADM_PATH, mode=0o666)
os.chown(consts.MDADM_PATH, sspl_uid, -1)
def validate(self):
# Common validator classes to check Cortx/system wide validator
if not os.path.exists(self.SSPL_CONFIGURED):
error = "SSPL is not configured. Run provisioner scripts in %s" % (
self._script_dir)
syslog.openlog(logoption=syslog.LOG_PID,
facility=syslog.LOG_LOCAL3)
syslog.syslog(syslog.LOG_ERR, error)
logger.error(error)
raise SetupError(1, "%s - validation failure. %s", self.name,
error)
# Validate required services are running
retry = 3
while retry > 0:
try:
ServiceV().validate('isrunning', self.services)
except VError:
retry -= 1
time.sleep(5)
else:
break
ServiceV().validate('isrunning', self.services)
logger.info("%s - Validation done" % self.name)
def validate(self):
"""Check for below requirement.
1. Validate if sspl-ll user exists
2. Validate input keys
"""
# Check sspl-ll user exists
sspl_uid = Utility.get_uid(self.user)
if sspl_uid == -1:
msg = "User %s doesn't exist. Please add user." % self.user
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
# Check input/provisioner configs
machine_id = Utility.get_machine_id()
cluster_id = Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"server_node>%s>cluster_id" % machine_id)
Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>name" % cluster_id)
Utility.get_config_value(consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>site_count" % cluster_id)
storage_set_count = int(
Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>site>storage_set_count" % cluster_id))
for i in range(storage_set_count):
Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>storage_set[%s]>name" % (cluster_id, i))
Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>storage_set[%s]>server_nodes" % (cluster_id, i))
Utility.get_config_value(
consts.PRVSNR_CONFIG_INDEX,
"cluster>%s>storage_set[%s]>storage_enclosures" %
(cluster_id, i))
def process(self):
"""Run test using user requested test plan."""
self.plan = self.args.plan[0]
# if self.plan is other than "self"
# then only config change and service restart is required.
if self.plan not in IVT_TEST_PLANS:
# Take back up of sspl test config
sspl_test_backup = '/etc/sspl_tests.conf.back'
shutil.copyfile(sspl_test_file_path, sspl_test_backup)
# Add global config in sspl_test config and revert the changes once
# test completes. Global config path in sspl_tests.conf will be
# referred by sspl_tests later
sspl_global_config_url = Conf.get(
SSPL_CONFIG_INDEX, "SYSTEM_INFORMATION>global_config_copy_url")
Conf.set(SSPL_CONFIG_INDEX,
"SYSTEM_INFORMATION>global_config_copy_url",
self.sspl_test_gc_copy_url)
Conf.save(SSPL_CONFIG_INDEX)
# Enable & disable sensors based on environment
update_sensor_info(SSPL_TEST_CONFIG_INDEX, self.node_type,
self.enclosure_type)
# TODO: Move lines 99-131 & 152-159 to RunQATest class
# Create dummy service and add service name in /etc/sspl.conf
service_name = "dummy_service.service"
service_file_path_src = \
f"{TEST_DIR}/alerts/os/dummy_service_files/dummy_service.service"
service_executable_code_src = \
f"{TEST_DIR}/alerts/os/dummy_service_files/dummy_service.py"
service_file_path_des = "/etc/systemd/system"
service_executable_code_des = "/var/cortx/sspl/test"
os.makedirs(service_executable_code_des, 0o777, exist_ok=True)
shutil.copy(service_executable_code_src,
f'{service_executable_code_des}/dummy_service.py')
# Make service file executable.
cmd = f"chmod +x {service_executable_code_des}/dummy_service.py"
_, error, returncode = SimpleProcess(cmd).run()
if returncode != 0:
logger.error("%s error occurred while executing cmd: %s" %
(error, cmd))
logger.error("failed to assign execute permission for"
"dummy_service.py. dummy_service will fail.")
# Copy service file to /etc/systemd/system/ path.
shutil.copyfile(service_file_path_src,
f'{service_file_path_des}/dummy_service.service')
cmd = "systemctl daemon-reload"
_, error, returncode = SimpleProcess(cmd).run()
if returncode != 0:
logger.error(f"failed to execute '{cmd}',"
"systemctl will be unable to manage the"
f"dummy_service.service \n Error: {error}")
self.dbus_service.enable(service_name)
self.dbus_service.start(service_name)
service_list = Conf.get(SSPL_CONFIG_INDEX,
"SERVICEMONITOR>monitored_services")
service_list.append(service_name)
Conf.set(SSPL_CONFIG_INDEX, "SERVICEMONITOR>monitored_services",
service_list)
threshold_inactive_time_original = Conf.get(
SSPL_CONFIG_INDEX, "SERVICEMONITOR>threshold_inactive_time")
threshold_inactive_time_new = 30
Conf.set(SSPL_CONFIG_INDEX,
"SERVICEMONITOR>threshold_inactive_time",
threshold_inactive_time_new)
Conf.save(SSPL_CONFIG_INDEX)
cpu_usage_alert_wait = Conf.get(
SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_cpu_usage_wait_threshold")
memory_usage_alert_wait = Conf.get(
SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_memory_usage_wait_threshold")
cpu_usage_alert_wait_new = 10
memory_usage_alert_wait_new = 20
Conf.set(SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_cpu_usage_wait_threshold",
cpu_usage_alert_wait_new)
Conf.set(SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_memory_usage_wait_threshold",
memory_usage_alert_wait_new)
Conf.save(SSPL_CONFIG_INDEX)
# TODO: Convert shell script to python
# from cortx.sspl.sspl_test.run_qa_test import RunQATest
# RunQATest(self.plan, self.coverage_enabled).run()
CMD = "%s/run_qa_test.sh --plan %s --coverage %s"\
%(TEST_DIR, self.plan, self.coverage_enabled)
try:
_, error, rc = SimpleProcess(CMD).run(realtime_output=True)
except KeyboardInterrupt:
rc = 1
error = "KeyboardInterrupt occurred while executing sspl test."
logger.error("%s - ERROR: %s - CMD %s" %
(self.name, error, CMD))
# Restore the original path/file & service, then throw exception
# if execution is failed.
service_list.remove(service_name)
Conf.set(SSPL_CONFIG_INDEX, "SERVICEMONITOR>monitored_services",
service_list)
Conf.set(SSPL_CONFIG_INDEX,
"SERVICEMONITOR>threshold_inactive_time",
threshold_inactive_time_original)
Conf.set(SSPL_CONFIG_INDEX,
"SYSTEM_INFORMATION>global_config_copy_url",
sspl_global_config_url)
Conf.set(SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_cpu_usage_wait_threshold",
cpu_usage_alert_wait)
Conf.set(SSPL_CONFIG_INDEX,
"NODEDATAMSGHANDLER>high_memory_usage_wait_threshold",
memory_usage_alert_wait)
Conf.save(SSPL_CONFIG_INDEX)
shutil.copyfile(sspl_test_backup, sspl_test_file_path)
if rc != 0:
raise TestException("%s - ERROR: %s - CMD %s" %
(self.name, error, CMD))
print('Restarting the SSPL service..')
CMD = "systemctl restart sspl-ll"
try:
SimpleProcess(CMD).run(realtime_output=True)
except Exception as error:
raise TestException(
"Error occurred while executing sspl tests: %s" % error)
elif self.plan in NOT_IMPLEMENTED_TEST_PLANS:
print("Tests skipped, test plan %s not applicable for SSPL." %
(self.plan))
return 0
else:
# TODO: Convert shell script to python
# from cortx.sspl.sspl_test.run_qa_test import RunQATest
# RunQATest(self.plan).run()
try:
CMD = "%s/run_qa_test.sh --plan %s" % (TEST_DIR, self.plan)
_, error, returncode = SimpleProcess(CMD).run(
realtime_output=True)
except KeyboardInterrupt:
msg = "KeyboardInterrupt occurred while executing sspl test."
logger.error(msg)
raise TestException(msg)
except Exception as error:
msg = "Error occurred while executing self test: %s" % error
logger.error(msg)
raise TestException(msg)
def validate(self):
if not self.args.config:
msg = "%s - Argument validation failure. %s" % (
self.name, "Global config is required.")
logger.error(msg)
raise SetupError(errno.EINVAL, msg)
def cleanup_log_and_config():
"""--pre-factory cleanup : Cleanup logs, config files and
undo everything whatever was done in post-install Mini-Provisioner
Interface."""
Conf.load(SSPL_CONFIG_INDEX, sspl_config_path)
sspl_log_file_path = Utility.get_config_value(
SSPL_CONFIG_INDEX, "SYSTEM_INFORMATION>sspl_log_file_path")
iem_log_file_path = Utility.get_config_value(
SSPL_CONFIG_INDEX, "IEMSENSOR>log_file_path")
message_types = [
Utility.get_config_value(SSPL_CONFIG_INDEX, "INGRESSPROCESSOR>message_type"),
Utility.get_config_value(SSPL_CONFIG_INDEX, "EGRESSPROCESSOR>message_type")]
# Directories and file which needs to deleted.
directories = [
f'/var/{PRODUCT_FAMILY}/sspl', f'/var/{PRODUCT_FAMILY}/iem/',
f'/var/log/{PRODUCT_FAMILY}/sspl/', f'/var/log/{PRODUCT_FAMILY}/iem/',
'/etc/sspl-ll/', f'{PRODUCT_BASE_DIR}/iem/iec_mapping']
sspl_sudoers_file = '/etc/sudoers.d/sspl'
sspl_dbus_policy_rules = '/etc/polkit-1/rules.d/sspl-ll_dbus_policy.rules'
sspl_dbus_policy_conf = '/etc/dbus-1/system.d/sspl-ll_dbus_policy.conf'
sspl_service_file = '/etc/systemd/system/sspl-ll.service'
sspl_test_backup = '/etc/sspl_tests.conf.back'
sspl_test_file_path = '/etc/sspl_test_gc_url.yaml'
sspl_sb_log_file_path = sspl_log_file_path.replace(
"/sspl.log", "/sspl_support_bundle.log")
manifest_log_file_path = sspl_log_file_path.replace(
"/sspl.log", "/manifest.log")
# symlinks created during post_install
sspl_ll_cli = "/usr/bin/sspl_ll_cli"
# Remove SSPL config other config/log files which were
# created during post_install.
for filepath in [
sspl_ll_cli, sspl_test_backup, sspl_test_file_path,
file_store_config_path, global_config_file_path,
sspl_log_file_path, iem_log_file_path, sspl_sb_log_file_path,
manifest_log_file_path, RSYSLOG_IEM_CONF, IEM_LOGROTATE_CONF,
sspl_dbus_policy_conf, sspl_dbus_policy_rules,
sspl_sudoers_file, sspl_service_file]:
FileStore().delete(filepath)
# Delete directories which were created during post_install.
for directory in directories:
FileStore().delete(directory)
logger.info("Deleted config/log files and directories.")
# Delete sspl-ll user
usernames = [x[0] for x in pwd.getpwall()]
if USER in usernames:
_, err, rc = SimpleProcess("/usr/sbin/userdel -f %s" % USER).run()
if rc != 0:
logger.info("Error occurref while deleteing %s user. ERROR: %s"
%(USER, err))
else:
logger.info("Deleted %s user." % USER)
# Delete topic
mbadmin = MessageBusAdmin(admin_id="admin")
try:
mbadmin.deregister_message_type(message_types)
logger.info("Delete kafka %s topics." % message_types)
except MessageBusError as e:
logger.error(f"MessageBusError occurred while deleting topic:{e}")
