Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:38
📄 __init__.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # from .wizard import CloudlinuxWizard __all__ = ('CloudlinuxWizard',)	270 B	2026-02-17 10:40
📁 __pycache__	-	2026-03-27 02:38
📁 cli	-	2026-03-27 02:38
📁 config	-	2026-03-27 02:38
📄 constants.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # import os CL_SELECTOR_BIN = '/usr/sbin/cloudlinux-selector' PERSISTENT_DIR = '/var/lve/wizard/' MODULES_LOGS_DIR = '/var/log/cloudlinux/wizard/' MODULES_STATUS_FILE = os.path.join(PERSISTENT_DIR, 'modules-statuses.json') FILE_MARKER_PATH = os.path.join(PERSISTENT_DIR, 'done.flag') MODULES_STATUS_FILE_LOCK = MODULES_STATUS_FILE + '.lock' MAIN_LOG_PATH = os.path.join(MODULES_LOGS_DIR, 'wizard.log') CRASH_LOG_PATH = os.path.join(MODULES_LOGS_DIR, 'crash.log') class ModuleStatus: """ pending: in queue for installation installing: currently installing installed: installation of module (package) finished failed: if module was aborted during installation auto-skipped: if automatic installation of module (package) is impossible """ CANCELLED = 'cancelled' FAILED = 'failed' INSTALLED = 'installed' INSTALLING = 'installing' PENDING = 'pending' AUTO_SKIPPED = 'auto-skipped' class WizardStatus: """ idle: never executed before in_progress: currently working failed: installation of some module failed crashed: something really weird happened done: installation finished """ IDLE = 'idle' IN_PROGRESS = 'in_progress' FAILED = 'failed' CRASHED = 'crashed' DONE = 'done'	1.44 KB	2026-02-17 10:40
📄 exceptions.py #!/opt/cloudlinux/venv/bin/python3 -bb # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # from clcommon import FormattedException class InstallationFailedException(Exception): """ Exception that should be raised to signal that some bad error happened during installation and user should review log files """ pass class PackageMissingError(FormattedException): """ Exception that should be raised when we are missing some required package for wizard work """ def __init__(self, package): super().__init__({ 'message': "This module requires '%(package)s' package, but it " "is missing in system. Please install it and try again.", 'context': {'package': package} }) class CancelModuleException(FormattedException): """ Error that is raised when it is not permitted to cancel module installation, e.g. module is installing at the moment. """ def __init__(self, module, status): super().__init__({ 'message': 'Module "%(module)s" can\'t be cancelled as it is in status "%(status)s".', 'context': {'module': module, 'status': status} }) class UserInterventionNeededError(Exception): """ Exception that is raised when it is impossible to install module (package) automatically """ pass	1.49 KB	2026-02-17 10:40
📁 modules	-	2026-03-27 02:38
📄 parser.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # import argparse import json from clwizard.modules import get_supported_modules def validate_json_modules(json_string): try: data = json.loads(json_string) except (TypeError, ValueError) as json_error: raise argparse.ArgumentTypeError("Invalid JSON data passed") from json_error supported_modules = get_supported_modules() # TODO: Validate given json data separately for each module for name, instructions in data.items(): if name not in supported_modules: raise argparse.ArgumentTypeError( f"'{name}' module is not supported at the moment, " f"available keys: {list(supported_modules.keys())}" ) if "options" in list(instructions.keys()): if not set(instructions["options"].keys()).issubset( supported_modules[name].supported_options() ): raise argparse.ArgumentTypeError( f"'{name}' module has incorrect options: {list(instructions['options'].keys())}" ) elif instructions: raise argparse.ArgumentTypeError( f"'{name}' module has incorrect instructions: {list(instructions.keys())}" ) return data def parse_cloudlinux_wizard_opts(argv): """ Arg parser for cloudlinux-wizard utility """ parser = argparse.ArgumentParser( prog="cloudlinux-wizard", description="Utility for installing cloudlinux modules", ) # --json parameter is a convenience for UI calls, we do not process it parser.add_argument("--json", action="store_true", help=argparse.SUPPRESS) subparser = parser.add_subparsers(dest="subparser") install_parser = subparser.add_parser( "install", help="Install a module. The installation is performed in the background by default", ) install_parser.add_argument( "--no-async", help="Install in the foreground", action="store_true" ) install_parser.add_argument( "--force", help="Force the installer to ignore existing installations", action="store_true", ) installer_group = install_parser.add_mutually_exclusive_group(required=True) installer_group.add_argument( "--json-data", help="JSON with modules to be installed", type=validate_json_modules, ) installer_group.add_argument( "--resume", help="Restart the installation process with previously given arguments", action="store_true", ) status_parser = subparser.add_parser( "status", help="Return JSON with statuses of all modules" ) status_parser.add_argument( "--initial", "-i", action="store_true", help="Get the current modules' status" ) finish_parser = subparser.add_parser( "finish", help="Finalize the installation from UI and close the wizard" ) cancel_parser = subparser.add_parser( "cancel", help="Remove a module from the installation queue" ) cancel_parser.add_argument("module", choices=list(get_supported_modules())) opts = parser.parse_args(argv) return opts	3.29 KB	2026-02-17 10:40
📄 utils.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # import logging import os import subprocess from contextlib import contextmanager from typing import Iterable # NOQA import psutil from .constants import CRASH_LOG_PATH from .exceptions import PackageMissingError @contextmanager def atomic_write(filepath, fsync=True): """ Writeable file object that atomically updates a file (using a temporary file). :param filepath: the file path to be opened :param fsync: whether to force write the file to disk """ tmppath = filepath + '.tmp' try: with open(tmppath, 'w', encoding='utf-8') as f: yield f if fsync: f.flush() os.fsync(f.fileno()) os.rename(tmppath, filepath) finally: try: os.remove(tmppath) except (IOError, OSError): pass def is_background_process_running(): """ Detects if the process installing modules is running in the background. """ def _is_wizard_cmdline(cmdline): # type: (Iterable[str]) -> bool return ( {'/usr/sbin/cloudlinux-wizard', 'install', '--no-async'} <= set(cmdline) or {'/sbin/cloudlinux-wizard', 'install', '--no-async'} <= set(cmdline) ) for proc in psutil.process_iter(): # cmdline example: # ['/opt/cloudlinux/venv/bin/python3', # 'usr/sbin/cloudlinux-wizard', # '--json', 'install', '--json-data', '{json obj}'] try: cmdline = list(proc.cmdline()) except psutil.NoSuchProcess: continue if _is_wizard_cmdline(cmdline): return True return False def run_background(cmd): log_crash = open(CRASH_LOG_PATH, 'w', encoding='utf-8') # pylint: disable=consider-using-with return subprocess.Popen( cmd, stdin=subprocess.DEVNULL, stdout=log_crash, stderr=log_crash ) def installed_interpreters_list(interpreter): try: from clselect.clselectctl import interpreter_versions_short_summary # pylint: disable=import-outside-toplevel except ImportError as e: raise PackageMissingError('lvemanager') from e return interpreter_versions_short_summary(interpreter) def convert_package_version(version, version_size): """ Format version string e.g: 3.6.0 -> 3.6 if version size = 2 9.11.3 -> 9 if version size = 1 :param version given version to convert :param version_size expected size of result version string """ return '.'.join(version.split('.')[:version_size]) def setup_logger(logger_name, log_file): """ Logger setup for all modules :return: """ app_logger = logging.getLogger(logger_name) app_logger.setLevel(logging.INFO) try: fh = logging.FileHandler(log_file) except IOError: pass else: fh.formatter = logging.Formatter( '[%(levelname)s \| %(asctime)s]: %(message)s') app_logger.addHandler(fh) return app_logger	3.12 KB	2026-02-17 10:40
📄 wizard.py # coding=utf-8 # # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENCE.TXT # import json import os import sys import time import traceback from typing import ClassVar, NoReturn import psutil from clcommon import FormattedException from clcommon.utils import ( ExternalProgramFailed, get_cl_version, get_package_db_errors, is_ubuntu, run_command, ) from clwizard.config import NoSuchModule from .config import ( Config, acquire_config_access, ) from .constants import ( CRASH_LOG_PATH, FILE_MARKER_PATH, MAIN_LOG_PATH, ModuleStatus, WizardStatus, ) from .exceptions import CancelModuleException, InstallationFailedException from .modules import ALL_MODULES, get_supported_modules, run_installation from .parser import parse_cloudlinux_wizard_opts from .utils import ( is_background_process_running, run_background, setup_logger, ) class CloudlinuxWizard: """Main class for working with Wizard that exposes high level logic.""" # states in which we can remove the module from queue CANCELLABLE_MODULE_STATUSES: ClassVar[list[str]] = [ ModuleStatus.PENDING, ModuleStatus.FAILED, ModuleStatus.CANCELLED, ] # modules states in which wizard modules can be considered as done DONE_MODULES_STATUSES: ClassVar[list[str]] = [ ModuleStatus.INSTALLED, ModuleStatus.CANCELLED, ModuleStatus.AUTO_SKIPPED, ] def __init__(self): self._opts = None self._supported_modules = get_supported_modules() self.log = setup_logger("wizard.main", MAIN_LOG_PATH) def run(self, argv): """ CL Wizard main function. :param argv: command line arguments for wizard :return: None """ self._opts = parse_cloudlinux_wizard_opts(argv) try: if self._opts.subparser == "install": self._validate_system() if self.is_installation_finished() and not self._opts.force: self._print_result_and_exit( result="Installation already finished", exit_code=1, ) if self._opts.no_async: # In async mode, run_background_installation() spawns a new process with --no-async, # which will execute this branch. So we call _prepare_for_installation() here. self._prepare_for_installation() run_installation() else: self.run_background_installation(options=self._opts.json_data) elif self._opts.subparser == "status": self._validate_system() if self._opts.initial: self._get_initial_status() else: self._get_modules_statuses() elif self._opts.subparser == "cancel": self._cancel_module_installation(self._opts.module) elif self._opts.subparser == "finish": self.create_completion_marker() else: raise NotImplementedError if (self._opts.subparser in ["install", "cancel"] and self.is_all_modules_installed()) or ( self._opts.subparser == "finish" and not self.is_all_modules_installed() ): # Called only once if: # -- in case of an install: -all modules were installed successfully # -a module failed during installation, # but was installed after resuming # -- in case of cancelling: -a module failed during installation, # but was canceled by the user and as a result, # all modules in a 'done' status # -- in case of finish: -only if user closed the wizard while a module # had a status other than installed, cancelled or skipped self.run_collecting_statistics() self.run_cagefs_force_update() self._print_result_and_exit() except FormattedException as err: self.log.exception( "Got an error while running cloudlinux-wizard", exc_info=err, ) self._print_result_and_exit( result=err.message, context=err.context, details=err.details, exit_code=1, ) except InstallationFailedException: self._print_result_and_exit( result="Module installation failed, see the log for more information", exit_code=1, ) except Exception as err: self.log.exception("Unknown error in cloudlinux-wizard", exc_info=err) self._print_result_and_exit( result="Unknown error occured, please, try again or contact CloudLinux support if it persists.", details=traceback.format_exc(), ) @staticmethod def is_installation_finished(): # type: () -> bool return os.path.isfile(FILE_MARKER_PATH) def create_completion_marker(self): # type: () -> None try: os.mknod(FILE_MARKER_PATH) self.log.info("Wizard execution complete") except OSError as err: self.log.warning( "Wizard 'finish' command called more than once, error: '%s'", str(err), ) self._print_result_and_exit( result="Wizard 'finish' command called more than once", exit_code=1, ) def run_background_installation(self, options: dict \| None = None) -> None: cmd = sys.argv[:] cmd.append("--no-async") with acquire_config_access() as config: # two processes cannot use config at same time # so we can safely do check for running process here if is_background_process_running(): self._print_result_and_exit( result="Unable to start a new installation because a background task is still working", exit_code=1, ) # the only case when options are None is the 'resume' case if options is not None: config.set_modules(options) # worker will not be able to acquire reading lock # and will wait unless we finally close config file worker_pid = run_background(cmd).pid config.worker_pid = worker_pid self._print_result_and_exit(result="success", pid=worker_pid) def _validate_system(self): """ Check whether Wizard supports the current system. """ if get_cl_version() is None: self._print_result_and_exit( result="Could not identify the CloudLinux version. " "Restart your system. If you have the same problem again - " "contact CloudLinux support.", ) def _prepare_for_installation(self): """ Prepare the environment before performing the installation. This function updates the package lists if run on Ubuntu, expires Yum cache when running on RHEL-based systems. """ if is_ubuntu(): cmd = ["apt-get", "-q", "update"] try: out = run_command(cmd) self.log.info("apt-get update output:\n%s", out) except ExternalProgramFailed as err: self.log.exception("Error during apt-get update", exc_info=err) else: cmd = ["yum", "-qy", "clean", "expire-cache"] try: out = run_command(cmd) self.log.info("yum clean expire-cache output:\n%s", out) except ExternalProgramFailed as err: self.log.exception("Error during yum clean expire-cache", exc_info=err) def _get_module_log_path(self, module_name): """ Get path to module log file. """ return self._supported_modules[module_name].LOG_FILE def _get_modules_statuses(self): """ Get information about background worker state. """ # we should return modules in order, but config # does not know about it, let's sort modules here modules = [] with acquire_config_access() as config: state = self._get_wizard_state(config) for name in self._supported_modules: try: status = config.get_module_status(name) status_time = config.get_module_status_time(name) except NoSuchModule: continue module_status = { "status": status, "name": name, "status_time": status_time, } if status in [ModuleStatus.FAILED, ModuleStatus.AUTO_SKIPPED]: module_status["log_file"] = self._get_module_log_path(name) modules.append(module_status) if state == WizardStatus.CRASHED: self._print_result_and_exit( wizard_status=state, modules=modules, crash_log=CRASH_LOG_PATH, ) self._print_result_and_exit(wizard_status=state, modules=modules) def _get_initial_status(self): """ Get initial modules status that is used by lvemanager to display wizard pages. """ error_message = get_package_db_errors() if error_message: # package manager DB corrupted self._print_result_and_exit(result=error_message) else: all_modules_set = {str(key) for key in ALL_MODULES} supported_modules_set = set(self._supported_modules.keys()) unsupported_by_cp = list(all_modules_set - supported_modules_set) self._print_result_and_exit( modules={module_name: cls().initial_status() for module_name, cls in self._supported_modules.items()}, unsuppored_by_cp=unsupported_by_cp, ) def _cancel_module_installation(self, module: str) -> None: """ Remove module from queue or print the error if it's not possible. """ self.log.info("Trying to cancel the installation of module '%s'", module) with acquire_config_access() as config: status = config.get_module_status(module) if status in self.CANCELLABLE_MODULE_STATUSES: config.set_module_status( module_name=module, new_state=ModuleStatus.CANCELLED, ) self.log.info("Module '%s' installation successfully canceled", module) else: self.log.warning( "Unable to cancel module '%s' installation, because it is in status '%s'", module, status, ) raise CancelModuleException(module, status) def run_collecting_statistics(self): """ Collect user's statistics. """ cmd = ["/usr/sbin/cloudlinux-summary", "--send"] if not os.environ.get("SYNCHRONOUS_SUMMARY"): cmd.append("--async") self.log.info("Collecting statistics...") try: out = run_command(cmd) self.log.info("Statistics collection command output: '%s'", out) except ExternalProgramFailed as err: self.log.exception("Error during statistics collection", exc_info=err) def is_all_modules_installed(self): # type: () -> bool """ Check that all modules were either: -- installed -- canceled -- or auto-skipped """ with acquire_config_access() as config: statuses = list(config.statuses.values()) return all(status in self.DONE_MODULES_STATUSES for status in statuses) def run_cagefs_force_update(self): """ Run cagefsctl --force-update in background. """ cagefsctl_bin = "/usr/sbin/cagefsctl" if not os.path.isfile(cagefsctl_bin): return cmd = [cagefsctl_bin, "--force-update", "--wait-lock"] self.log.info("Starting cagefs force-update in the background: %s", cmd) cagefsctl_proc = run_background(cmd) # In Cloudlinux tests environment statistics wait for cagefsctl --force-update terminate is_test_environment = bool(os.environ.get("CL_TEST_SYSTEM")) if is_test_environment: cagefsctl_proc.communicate() def _get_wizard_state(self, config: Config) -> str: # worker pid is None only in the case when wizard # wasn't EVER called, this worker pid will stay # in config forever, even after wizard is Done if config.worker_pid is None: return WizardStatus.IDLE try: psutil.Process(config.worker_pid) except psutil.NoSuchProcess: # Background process is no longer alive. # 1. Wizard DONE: all modules are in state "installed", "cancelled" or "auto-skipped". # 2. Wizard FAILED: one of the modules in state "failed" or "cancelled" # and no modules are in status "installing" # 3. Wizard CRASHED: none of the above. statuses = list(config.statuses.values()) if all(status in self.DONE_MODULES_STATUSES for status in statuses): return WizardStatus.DONE # cancel module`s status is acceptable for general wizard status FAILED, DO NOT CHANGE IT PLS (LU-1295) # An extra check for "installing" status is needed to exclude possible CRASHED wizard status if any(status in (ModuleStatus.FAILED, ModuleStatus.CANCELLED) for status in statuses) and not any( status in (ModuleStatus.INSTALLING,) for status in statuses ): return WizardStatus.FAILED return WizardStatus.CRASHED return WizardStatus.IN_PROGRESS @staticmethod def _print_result_and_exit( result: str = "success", exit_code: int = 0, **extra, ) -> NoReturn: """ Print data in default format for web and exit. :param dict extra: extra fields for the response, usually we expect 'context' here """ message = {"result": result, "timestamp": time.time()} message.update(extra) print(json.dumps(message, indent=2, sort_keys=True)) sys.exit(exit_code)	14.61 KB	2026-02-17 10:40

Terminal