def __init__(self, args: dict):
"""Initialize post install command"""
from files.opt.seagate.sspl.setup.sspl_post_install import (
SSPLPostInstall)
super().__init__(args)
self.post_install = SSPLPostInstall()
logger.info("%s - Init 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 process(self):
"""Setup and run SSPL test"""
from files.opt.seagate.sspl.setup.sspl_test import SSPLTestCmd
sspl_test = SSPLTestCmd(self.args)
sspl_test.validate()
sspl_test.process()
logger.info("%s - Process done" % self.name)
def process(self):
logger.info(f"Nothing to be done for {self.name}.")
if self.level == 'node':
# No action needed
pass
elif self.level == 'cluster':
# No action needed
pass
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 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 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 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):
# 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 process(self):
"""Cleanup sspl config and log files."""
from files.opt.seagate.sspl.setup.sspl_cleanup import SSPLCleanup
sspl_cleanup = SSPLCleanup(self.args.args)
sspl_cleanup.process(self.product)
logger.info("%s - Process done" % self.name)
def process(self):
from files.opt.seagate.sspl.setup.sspl_reset import Reset
Reset().process()
logger.info("%s - Process done" % self.name)
def validate(self):
"""Check for required packages are installed."""
# RPM dependency
rpm_deps = {"cortx-sspl-test": None}
# python 3rd party package dependency
pip3_packages_dep = {"Flask": "1.1.1", "coverage": "5.5"}
if not self.coverage_enabled:
pip3_packages_dep.pop("coverage")
# Validate pip3 python pkg with required version.
for pkg, version in pip3_packages_dep.items():
installed_pkg = None
uninstalled_pkg = False
try:
pkg_req = Requirement.parse(f"{pkg}=={version}")
installed_pkg = working_set.find(pkg_req)
except VersionConflict:
cmd = f'pip3 uninstall -y {pkg}'
_, err, ret = SimpleProcess(cmd).run()
if ret:
raise TestException(
"Failed to uninstall the pip3 pkg: %s(v%s), "
"due to an Error: %s" % (pkg, version, err))
uninstalled_pkg = True
except Exception as err:
raise TestException("Failed at verification of pip3 pkg: %s, "
"due to an Error: %s" % (pkg, err))
if not installed_pkg or uninstalled_pkg:
cmd = f'pip3 install {pkg}=={version}'
_, err, ret = SimpleProcess(cmd).run()
if ret:
raise TestException(
"Failed to install the pip3 pkg: %s(v%s), "
"due to an Error: %s" % (pkg, version, err))
logger.info(f"Ensured Package Dependency: {pkg}(v{version}).")
# Validate rpm dependencies
pkg_validator = PkgV()
pkg_validator.validate_rpm_pkgs(host=socket.getfqdn(),
pkgs=rpm_deps,
skip_version_check=True)
# Load global, sspl and test configs
Conf.load(SSPL_CONFIG_INDEX, sspl_config_path)
Conf.load(SSPL_TEST_CONFIG_INDEX, sspl_test_config_path)
# Take copy of supplied config passed to sspl_test and load it
with open(self.sspl_test_gc_copy_file, "w") as f:
f.write("")
self.sspl_test_gc_copy_url = "yaml://%s" % self.sspl_test_gc_copy_file
Conf.load(SSPL_TEST_GLOBAL_CONFIG, self.sspl_test_gc_copy_url)
Conf.load("global_config", self.sspl_test_gc_url)
Conf.copy("global_config", SSPL_TEST_GLOBAL_CONFIG)
# Validate input configs
machine_id = Utility.get_machine_id()
self.node_type = Conf.get(SSPL_TEST_GLOBAL_CONFIG,
"server_node>%s>type" % machine_id)
enclosure_id = Conf.get(
SSPL_TEST_GLOBAL_CONFIG,
"server_node>%s>storage>enclosure_id" % machine_id)
self.enclosure_type = Conf.get(
SSPL_TEST_GLOBAL_CONFIG,
"storage_enclosure>%s>type" % enclosure_id)
def process(self):
"""Configure SSPL for prepare stage."""
self.copy_input_config()
self.prepare.process()
logger.info("%s - Process done" % self.name)
def __init__(self, args):
super().__init__(args)
logger.info("%s - Init done" % self.name)
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}")
def __init__(self, args):
from files.opt.seagate.sspl.setup.sspl_setup_init import SSPLInit
super().__init__(args)
self.sspl_init = SSPLInit()
logger.info("%s - Init done" % self.name)
def process(self):
"""Setup SSPL configuration."""
self.copy_input_config()
self.sspl_config.process()
logger.info("%s - Process done" % self.name)
def __init__(self, args):
"""Initialize config command."""
from files.opt.seagate.sspl.setup.sspl_config import SSPLConfig
super().__init__(args)
self.sspl_config = SSPLConfig()
logger.info("%s - Init done" % self.name)
def process(self):
logger.info(f"{self.name} interface not implemented.")
def process(self):
"""Perform SSPL post installation."""
self.copy_input_config(stage=self.name)
self.post_install.process()
logger.info("%s - Process done" % self.name)
def process(self):
"""Configure SSPL init."""
self.copy_input_config()
self.sspl_init.process()
logger.info("%s - Process done" % self.name)
def __init__(self, args: dict):
"""Initialize prepare command"""
from files.opt.seagate.sspl.setup.sspl_prepare import SSPLPrepare
super().__init__(args)
self.prepare = SSPLPrepare()
logger.info("%s - Init done" % self.name)
