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 # import os from collections import OrderedDict from typing import Dict # NOQA from clwizard.config import NoSuchModule, acquire_config_access from clwizard.constants import ModuleStatus, MAIN_LOG_PATH from clwizard.exceptions import InstallationFailedException, UserInterventionNeededError from clwizard.utils import setup_logger from .base import WizardInstaller # NOQA from .cagefs import CagefsInstaller from .governor import GovernorInstaller from .nodejs import NodejsInstaller from .php import PhpInstaller from .python import PythonInstaller from .ruby import RubyInstaller from .lsapi import LsapiInstaller # order of modules is important # add new modules in correct order ALL_MODULES = OrderedDict([ ('cagefs', CagefsInstaller), ('mysql_governor', GovernorInstaller), ('nodejs', NodejsInstaller), ('php', PhpInstaller), ('python', PythonInstaller), ('ruby', RubyInstaller), ('mod_lsapi', LsapiInstaller), # add other modules here ]) log = setup_logger('wizard.runner', MAIN_LOG_PATH) def get_supported_modules(): """Get list of supported modules on current control panel""" return { name: module for name, module in ALL_MODULES.items() if module.is_supported_by_control_panel() } def run_installation(): """Install modules according to settings in status file""" log.info('~' * 60) log.info('> Start new modules installation in process with pid %s', os.getpid()) for name, installer_class in get_supported_modules().items(): installer = installer_class() # we should re-read config each time in order to be able to 'cancel' with acquire_config_access() as config: try: options = config.get_module_options(module_name=name) state = config.get_module_status(module_name=name) except NoSuchModule: log.info( "Module %s is not set for installation, skip it", name) continue # 'resume case' when we should skip already installed modules if state == ModuleStatus.INSTALLED: log.info( "Module %s is already installed, skip it", name) continue if state == ModuleStatus.CANCELLED: log.info( "Module %s has been cancelled, skip it", name) continue if state == ModuleStatus.AUTO_SKIPPED: log.info( "Module %s requires a manual installation. " "Skipping it and continuing installation", name) continue config.set_module_status( module_name=name, new_state=ModuleStatus.INSTALLING) _install_module(name, installer, options=options) log.info('> Process with pid %s successfully finished work', os.getpid()) log.info('-' * 60) def _install_module(module, installer, options): # type: (str, WizardInstaller, Dict) -> None log.info("Installing module: %s", module) try: installer.run_installation(options) except InstallationFailedException: _write_module_state_atomic( module_name=module, new_state=ModuleStatus.FAILED) log.error( "Installation failed for module %s", module, extra={ 'fingerprint': ['{{ default }}', module], # Used to group and break up events 'data': {'options': str(options)}}) # Additional data for sentry event raise except UserInterventionNeededError: _write_module_state_atomic( module_name=module, new_state=ModuleStatus.AUTO_SKIPPED) log.warning("Automatic installation was skipped for module %s", module) except Exception as err: _write_module_state_atomic( module_name=module, new_state=ModuleStatus.FAILED) log.error("Installation failed for module %s", module) installer.app_logger.exception( "Unknown error occurred, please, retry " "or contact CloudLinux support if it happens again." "\n\nError: %s", str(err), extra={ # Used to group and break up events 'fingerprint': ['{{ default }}', module, str(err)[:25]], # Additional data for sentry event 'data': {'options': str(options)} }) raise InstallationFailedException() from err else: _write_module_state_atomic( module_name=module, new_state=ModuleStatus.INSTALLED) log.info("Module '%s' successfully installed " "using options '%s'", module, options) def _write_module_state_atomic(module_name, new_state): # type: (str, str) -> None with acquire_config_access() as config_access: config_access.set_module_status(module_name=module_name, new_state=new_state)	5 KB	2026-02-17 10:40
📁 __pycache__	-	2026-03-27 02:38
📄 base.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 import re from abc import abstractmethod from typing import Dict, List, Optional # NOQA from clcommon import cpapi from clcommon.group_info_reader import GroupInfoReader from clcommon.utils import ( ExternalProgramFailed, get_cl_version, get_package_db_errors, get_passenger_package_name, is_ea4, is_package_installed, is_ubuntu, run_command, ) from clwizard.exceptions import InstallationFailedException from clwizard.utils import convert_package_version, setup_logger class WizardInstaller: """ General interface for modules installers """ LOG_FILE = "" _REQUIRED_CL_COMPONENT_SUPPORT = None def __init__(self): self.app_logger = setup_logger("wizard." + self.__class__.__name__, self.LOG_FILE) def _run_command(self, cmd, cmd_env=None): # type: (List[str], Dict[str, str]) -> str """Run external tool and log results""" self.app_logger.info("~" * 60) self.app_logger.info("Executing command %s...", " ".join(cmd)) try: output = run_command(cmd, env_data=cmd_env) except ExternalProgramFailed as err: self.app_logger.info("...external command failed, see the following lines for tracebacks, errors, etc.") self.app_logger.error(str(err)) raise self.app_logger.info("...external command successfully ended with output:") self.app_logger.info(output) self.app_logger.info("-" * 60) return output def _is_package_installed(self, package_name): # type: (str) -> bool """Check if package exists on server""" error_message = get_package_db_errors() if error_message: # DB corrupted log_message = f"Can't check package {package_name} presence. Errors:\n{error_message}" self.app_logger.error(log_message) raise InstallationFailedException() return is_package_installed(package_name) def _install_package(self, packages): # type: (str) -> Optional[str] """Install a package and log results""" if is_ubuntu(): return self._install_apt_package(packages) return self._install_yum_package(packages) def _install_apt_package(self, packages): # type: (str) -> Optional[str] """Install an apt package and log results""" apt_env = {} # For debconf to avoid making any interactive queries. apt_env["DEBIAN_FRONTEND"] = "noninteractive" apt_env["DEBCONF_NONINTERACTIVE_SEEN"] = "true" if packages: return self._run_command(["apt-get", "install", "-y"] + list(packages), cmd_env=apt_env) return None def _install_yum_package(self, packages): # type: (str) -> Optional[str] """Install a yum package and log results""" if packages: return self._run_command(["yum", "install", "-y"] + list(packages)) return None def _install_groups(self, groups): # type: (str) -> Optional[str] """ Install a package group. On Ubuntu, this will install the meta packages. Currently, we only support PHP Selector on Ubuntu. If other selectors are added, they will need to have a meta packages. """ if is_ubuntu(): groups = [group + "-meta" for group in groups] return self._install_apt_package(groups) return self._install_yum_groups(groups) def _install_yum_groups(self, *groups): # type: (str) -> Optional[str] """Install package group with yum and log results""" if groups: return self._run_command(["yum", "groupinstall", "-y"] + list(groups)) return None def _ensure_cl_ea4_repo_exists(self): """ Check whether cloudlinux-ea4.repo is present and install it if not. It's required only on EA4 to install proper Passenger package """ # CLOS-2147: should also be made compatible with Ubuntu, once Python/Node/Ruby selector # support comes into play. # As of 02.11.2023, only PHP Selector is supposed to be supported. cl_ea4_repofile = "/etc/yum.repos.d/cloudlinux-ea4.repo" if os.path.exists(cl_ea4_repofile): return dist = get_cl_version() or "Unknown" if "ubuntu" in dist: raise InstallationFailedException("Functionality currently not supported for Ubuntu") # From "cl7h" to "7", "cl9" to "9", etc. maj_ver_match = re.search(r"\d+", dist) if not maj_ver_match: raise InstallationFailedException("Failed to get the distribution's major version") dist_maj_ver = int(maj_ver_match.group()) # NOTE(rprilipskii): We already have a Debian repo for EA4: # https://repo.cloudlinux.com/cloudlinux-ubuntu/cloudlinux-ea4/stable/20.04/ # but there's no cloudlinux-ea4-release in them. # In CLOS-2147 see how we're supposed to ensure that the cloudlinux-ubuntu/cloudlinux-ea4 # repo is enabled on the system. package_url = ( "https://repo.cloudlinux.com/cloudlinux/EA4/" f"cloudlinux-ea4-release-latest-{dist_maj_ver}.noarch.rpm" ) self.app_logger.info("Unable to find cloudlinux-ea4 repo. Trying to install it using url: %s", package_url) self._install_yum_package(package_url) def _install_passenger(self): """ Install proper passenger package for Selectors if it's not yet installed """ # CLOS-2147: should also be made compatible with Ubuntu, once Python/Node/Ruby selector # support comes into play. # As of 02.11.2023, only PHP Selector is supposed to be supported. # Per Alexander Demeshko, Passenger is not supported on Ubuntu at the moment, todo later. if is_ubuntu(): raise InstallationFailedException("Passenger currently not supported on Ubuntu") if is_ea4(): self._ensure_cl_ea4_repo_exists() passenger = get_passenger_package_name() self.app_logger.info("Trying to install Passenger package: %s", passenger) try: self._install_yum_package(passenger) except ExternalProgramFailed as extern_failed: raise InstallationFailedException() from extern_failed @staticmethod def _get_available_versions(group): # type: (str) -> List """ Get a list of available Python, NodeJS, PHP or Ruby module versions. :param group: - group name, e.g: python :return: list of available versions """ available_groups_info = GroupInfoReader.get_group_info(group) versions = [] # we need to format version: # python: 2.3.3 -> 2.3 # ruby: 2.1.1 -> 2.1 # php: 7.2.0 -> 7.2 # nodejs: 8.1.0 -> 8 ver_size = 1 if group == "nodejs" else 2 for group_data in available_groups_info.values(): versions.append(convert_package_version(group_data["version"], version_size=ver_size)) return versions @abstractmethod def run_installation(self, options): # type: (Dict) -> None raise NotImplementedError() @classmethod def supported_options(cls): return set() @abstractmethod def initial_status(self): # type: () -> Dict """ Method that returns dictionary with two required keys: {installed: True\|False and options: {...}] This will be used by lvemanager to properly display wizard. """ raise NotImplementedError() @classmethod def is_supported_by_control_panel(cls): """ Checks whether we must :return: """ if cls._REQUIRED_CL_COMPONENT_SUPPORT is None: return True return cpapi.is_panel_feature_supported(cls._REQUIRED_CL_COMPONENT_SUPPORT)	7.96 KB	2026-02-17 10:40
📄 cagefs.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 from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed from clconfig.cagefs_statistics_config import check_cagefs_initialized from cllimits.cagefs_lib import CageFs, CageFsException from clwizard.constants import MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException from .base import WizardInstaller class CagefsInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'cagefs.log') _REQUIRED_CL_COMPONENT_SUPPORT = Feature.CAGEFS def __init__(self): super().__init__() self.cgfs = CageFs(logger=self.app_logger) def _enable_existing_users(self): """ Enable all users statuses and after it toggle to initial mode :return: """ initial_mode = self.cgfs.get_user_mode() out = self.cgfs.set_enabled_mode() self.app_logger.info("Cagefs users status was updated to enabled: %s", out) if initial_mode == 'Disable All': self.cgfs.toggle_user_mode() def _set_enabled_mode(self): mode = self.cgfs.get_user_mode() self.app_logger.info("Current mode is: %s", mode) if mode == 'Disable All': self.app_logger.info("Try to set mode to Enable all") self.cgfs.toggle_user_mode() self.app_logger.info("Mode was toggled to Enable all") def _install_cagefs_package(self): if not self._is_package_installed('cagefs'): try: self._install_package('cagefs') except ExternalProgramFailed as err: raise InstallationFailedException() from err else: self.app_logger.info("Skip package installation, it is already installed") def _initialize_cagefs(self): if not check_cagefs_initialized(): try: out = self.cgfs.initialize_cagefs() self.app_logger.info("Cagefs was initialized: %s", out) except CageFsException as err: self.app_logger.error("Cagefs initialization failed with error: %s", str(err)) raise InstallationFailedException() from err else: self.app_logger.info("Initializing was skipped, cagefs was already initialized") def _enable_cagefs(self): try: out = self.cgfs.enable_cagefs() self.app_logger.info("Cagefs was enabled, ready for configuration\n %s", out) except CageFsException as err: raise InstallationFailedException() from err def run_installation(self, options): self._install_cagefs_package() self._initialize_cagefs() self._enable_cagefs() try: if options['enable_for_existing_users']: self._enable_existing_users() if options['enable_for_new_users']: self._set_enabled_mode() except CageFsException as err: self.app_logger.error("Can`t configure options: %s", str(err)) raise InstallationFailedException() from err @classmethod def supported_options(cls): return {'enable_for_existing_users', 'enable_for_new_users'} def initial_status(self): try: enabled_for_new = self.cgfs.get_user_mode() == 'Enable All' except CageFsException: self.app_logger.warning( 'Unable to detect cagefs mode, assuming that it is "Disable All"' ) enabled_for_new = False return { # we always allow user to initialize cagefs # bool needed to replace None with False # None is given when cagefs is not installed 'already_configured': bool(check_cagefs_initialized()), 'options': {'enable_for_new_users': enabled_for_new}, }	3.93 KB	2026-02-17 10:40
📄 governor.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 from typing import Dict, List # NOQA from clcommon.const import Feature from clcommon.lib.mysql_governor_lib import MySQLGovernor from clcommon.utils import ExternalProgramFailed, run_command from clconfig.db_info_lib import MysqlInfo from cldetectlib import getCPName from clwizard.constants import MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException, UserInterventionNeededError from .base import WizardInstaller class GovernorInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'governor.log') UNKNOWN = 'unknown' UTILITY_PATH = '/usr/share/lve/dbgovernor/mysqlgovernor.py' _REQUIRED_CL_COMPONENT_SUPPORT = Feature.GOVERNOR def __init__(self): super().__init__() # dict( # 'vendor': MySQL\|MariaDB\|Percona, # 'version': server version in the form of {major}.{minor} # or {major}.{minor}-{release} for percona, # 'cll-lve': patches from CL applied or not (True\|False) # ) self.db_info = MysqlInfo().get() def _install_governor_package(self): if not self._is_package_installed('governor-mysql'): try: out = self._install_package('governor-mysql') except ExternalProgramFailed as err: self.app_logger.error("Package installation failed with error: %s", str(err)) raise InstallationFailedException() from err self.app_logger.info("Package was installed successfully: %s", out) else: self.app_logger.info("Skip the governor-mysql installation, it is already installed") def _prepare_db_options(self): if GovernorInstaller.UNKNOWN in (self.db_info["vendor"], self.db_info["version"]): return None try: vendor = self.db_info['vendor'].lower() # split(-)[0] drop release # split[.][0-2] use only major and minor versions version = ''.join(self.db_info['version'].split('-')[0].split('.')[0:2]) return vendor + version except IndexError: return None def _initialize_governor(self): """ Trying to install governor with --wizard key, it detects the DB automatically (on DA and cPanel), for other panels we will have blockers for the governor module. """ try: self.app_logger.info("Install MySQL Governor") # for governor there are errors that could be handled only manually by user # these errors have exit code 3 self._run_cmd_and_check_special_status( [GovernorInstaller.UTILITY_PATH, '--install', '--wizard'], exit_status=3 ) except ExternalProgramFailed as err: raise InstallationFailedException() from err def _run_cmd_and_check_special_status(self, cmd, exit_status): """ There are cases when some commands can't be executed without the user's intervention. Such scripts/commands return a special exit code that must be checked for. """ retcode, out, _ = run_command(cmd, return_full_output=True) if retcode == exit_status: self.app_logger.warning('Can`t install governor automatically') self.app_logger.warning('Reason: %s', out) raise UserInterventionNeededError() if retcode != 0: self.app_logger.error('Error occurred during running "%s"\nReason is: "%s"', cmd, out) raise ExternalProgramFailed(out) def run_installation(self, options): if self.db_info["vendor"] is None: raise InstallationFailedException("Please, install a MySQL server first.") self._install_governor_package() self._initialize_governor() def _get_warnings(self): # type: () -> List """ Get list of warnings that should be shown in wizard before module installation """ warnings = [ { "message": ( "Please create a full database backup (including system tables)." " MySQL/MariaDB/Percona server will be updated from CloudLinux repositories." ) } ] # type: List[Dict] if self.db_info["vendor"] is None: warnings.append( { "message": ( "Could not detect a MySQL server." " For a list of compatible options please see %(url)s." ), "context": { "url": "https://docs.cloudlinux.com/mysql_governor_installation.html" }, } ) return warnings def _get_blockers(self): # type: () -> List """ Get a list of possible blockers to disable Governor module in Wizard UI. """ blockers = [] if getCPName() not in ['cPanel', 'DirectAdmin']: blockers.append( { 'message': 'MySQL Governor can\'t be automatically installed.' ' Please install it through the command-line interface.' ' Learn more here: %(url)s', 'context': { 'url': 'https://docs.cloudlinux.com/installation-wizard.html', }, } ) return blockers def _is_already_configured(self): """ Check if the governor is ready for work. """ mysql_gov = MySQLGovernor() return mysql_gov.is_governor_present() and self.db_info['cll-lve'] def initial_status(self): result = { 'already_configured': self._is_already_configured(), 'db_version': self.db_info['version'], } warnings = self._get_warnings() if warnings: result.update({'warnings': warnings}) blockers = self._get_blockers() if blockers: result.update({'blockers': blockers}) return result	6.18 KB	2026-02-17 10:40
📄 lsapi.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 dataclasses import dataclass import os from contextlib import contextmanager from typing import Any, Dict, List # NOQA from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed, is_ea4, is_litespeed_running, is_testing_enabled_repo, is_ubuntu from cldetectlib import get_apache_modules, get_boolean_param, is_da from clwizard.constants import MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException from .base import WizardInstaller _DA_CUSTOMBUILD = "/usr/local/directadmin/custombuild/build" # LSAPI package naming schemes differ between normal CL and Ubuntu. # This is why we define two sets of package names here. @dataclass class LsapiPackageSet: general: List[str] # general LSAPI-related packages general_lsapi: str # LSAPI package for systems without EA4 (not cPanel) ea4_lsapi: str # EA4 lsapi package cl_lsapi_set = LsapiPackageSet( general=["liblsapi", "liblsapi-devel"], general_lsapi="mod_lsapi", ea4_lsapi="ea-apache24-mod_lsapi", ) ubuntu_lsapi_set = LsapiPackageSet( general=["liblsapi", "liblsapi-dev"], general_lsapi="mod-lsapi", ea4_lsapi="ea-apache24-mod-lsapi", ) class LsapiInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, "lsapi.log") UTILITY = "/usr/bin/switch_mod_lsapi" _REQUIRED_CL_COMPONENT_SUPPORT = Feature.LSAPI def __init__(self): super().__init__() self._prepare_lsapi_packages() self.apache_modules = get_apache_modules() or [] # type: List[str] def _prepare_lsapi_packages(self): package_set = ubuntu_lsapi_set if is_ubuntu() else cl_lsapi_set self.lsapi_packages = package_set.general[:] if is_ea4(): self.lsapi_packages.append(package_set.ea4_lsapi) else: self.lsapi_packages.append(package_set.general_lsapi) def _install_lsapi_packages(self): """ Install lsapi packages if needed :return: None """ packages_to_install = [] for package in self.lsapi_packages: if not self._is_package_installed(package): packages_to_install.append(package) if packages_to_install: try: out = self._install_package(*packages_to_install) except ExternalProgramFailed as err: self.app_logger.error("Package installation failed with error: %s", str(err)) raise InstallationFailedException() from err self.app_logger.info("Package was installed successfully: %s", out) else: self.app_logger.info("Skip package installation, all packages are already installed") def _initialize_lsapi(self): """ Configure lsapi on base package installation. :return: None """ try: self._run_command([self.UTILITY, "--setup"]) except ExternalProgramFailed as err: raise InstallationFailedException() from err @contextmanager def use_cl_beta_on_da(self, use_beta: bool): """ Context manager to set the option `cloudlinux_beta` in DA custombuild options. @param use_beta: True == `cloudlinux_beta=yes`, False == `cloudlinux_beta=no` """ inital_state = get_boolean_param("/usr/local/directadmin/custombuild/options.conf", "cloudlinux_beta") if use_beta and not inital_state: self._run_command([_DA_CUSTOMBUILD, "set", "cloudlinux_beta", "yes"]) try: yield finally: if use_beta and not inital_state: self._run_command([_DA_CUSTOMBUILD, "set", "cloudlinux_beta", "no"]) def _install_lsapi_on_da(self, use_beta: bool) -> None: """ Configure and build lsapi on DirectAdmin. :param use_beta: Whether to use the beta version of CloudLinux packages. :return: None """ try: with self.use_cl_beta_on_da(use_beta=use_beta): self._run_command([_DA_CUSTOMBUILD, "update"]) self._run_command([_DA_CUSTOMBUILD, "set", "php1_mode", "lsphp"]) self._run_command([_DA_CUSTOMBUILD, "php", "n"]) self._run_command([_DA_CUSTOMBUILD, "apache"]) except ExternalProgramFailed as err: raise InstallationFailedException() from err def run_installation(self, options): """ Install the lsapi module on the system. :return: None """ if is_da(): if "use_beta_for_da" in options: use_beta_for_da = options["use_beta_for_da"] else: use_beta_for_da = is_testing_enabled_repo() self._install_lsapi_on_da(use_beta_for_da) else: self._install_lsapi_packages() self._initialize_lsapi() @classmethod def supported_options(cls): return {"use_beta_for_da"} def _get_warnings(self) -> List[Dict[str, str \| dict[str, str]]]: """ Get a list of warnings that should be shown in Wizard before the module installation. :return: List of warnings to be shown in UI. Warning is a dictionary with the following keys and values: - message: str - warning message with placeholders for additional context - context: dict - additional context for the message """ warnings: List[Dict[str, str \| dict[str, str]]] = [] if is_da(): warnings.append({"message": "Installation will be performed via DirectAdmin CustomBuild tool"}) if "suexec_module" not in self.apache_modules: warnings.append( { "message": ( "mod_suexec is not installed." " It is recommended to use mod_suexec with mod_lsapi." " It is also required for CRIU to work." " Please see %(url)s for more information." ), "context": {"url": "https://docs.cloudlinux.com/apache_mod_lsapi.html"}, } ) return warnings def _get_blockers(self) -> List[Dict[str, str \| dict[str, str]]]: """ Get a list of possible blockers that may disable module in Wizard UI. :return: List of blockers to be shown in UI. Blocker is a dictionary with the following keys and values: - message: str - blocker message with placeholders for additional context - context: dict - additional context for the message """ blockers = [] if is_litespeed_running(): blockers.append( { "message": "The server is running under Litespeed." " mod_lsapi works with the Apache server only." " Please see %(url)s for the requirements.", "context": {"url": "https://docs.cloudlinux.com/apache_mod_lsapi.html"}, } ) if "ruid2_module" in self.apache_modules: blockers.append( { "message": "mod_ruid2 is enabled, it is not compatible with mod_lsapi." " Please see %(url)s for the requirements.", "context": { "url": "https://docs.cloudlinux.com/apache_mod_lsapi.html", }, } ) if "mpm_itk_module" in self.apache_modules: blockers.append( { "message": "MPM ITK is enabled, it is not compatible with mod_lsapi." " Please see %(url)s for the requirements.", "context": { "url": "https://docs.cloudlinux.com/apache_mod_lsapi.html", }, } ) return blockers def initial_status(self): result: Dict[str, Any] = { "already_configured": all(self._is_package_installed(pkg) for pkg in self.lsapi_packages), } warnings = self._get_warnings() if warnings: result.update({"warnings": warnings}) blockers = self._get_blockers() if blockers: result.update({"blockers": blockers}) return result	8.33 KB	2026-02-17 10:40
📄 nodejs.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 from typing import Dict, Iterable # NOQA from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed, get_passenger_package_name from clwizard.constants import CL_SELECTOR_BIN, MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException, PackageMissingError from clwizard.modules.base import WizardInstaller from clwizard.utils import installed_interpreters_list class NodejsInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'nodejs.log') _REQUIRED_CL_COMPONENT_SUPPORT = Feature.NODEJS_SELECTOR def _set_default_nodejs_version(self, version): # type: (str) -> None self.app_logger.info("trying to set default NodeJS version as '%s'", version) try: self._run_command( [ CL_SELECTOR_BIN, 'set', '--interpreter', 'nodejs', '--default-version', version, '--json', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _set_cloudlinux_selector_status(self, status): # type: (str) -> None self.app_logger.info("trying to set NodeJS Selector state '%s'", status) try: self._run_command( [ CL_SELECTOR_BIN, 'set', '--interpreter', 'nodejs', '--selector-status', status, '--json', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _install_nodejs_versions(self, versions): # type: (Iterable[str]) -> None self.app_logger.info("Trying to install NodeJS versions: %s", ', '.join(versions)) # Given a version (e.g., '6') construct required package group name group_names = ['alt-nodejs' + version for version in versions] try: self._install_groups(*group_names) except ExternalProgramFailed as e: raise InstallationFailedException() from e def run_installation(self, options): default_version = options.get('default_version') # type: str install_versions = options.get('versions', []) if default_version and default_version not in install_versions: self.app_logger.error( "Version %s that was specified to be set as default " "must be included in install_versions", default_version, ) raise InstallationFailedException() self._install_passenger() self._install_nodejs_versions(install_versions) self._set_cloudlinux_selector_status(status='enabled') if default_version: self._set_default_nodejs_version(default_version) @classmethod def supported_options(cls): return {'default_version', 'versions'} @staticmethod def _nodejs_get_default_version(): # type: () -> str try: from clselect.clselectctl import get_default_version # pylint: disable=import-outside-toplevel except ImportError as e: raise PackageMissingError('lvemanager') from e return get_default_version('nodejs') def _is_already_configured(self): # type: () -> bool """ Checks that nodejs selector is ready to work All configurations were done: - At least one interpreter version is installed - Passenger is installed - Nodejs selector is enabled :return: bool value configured or not """ return bool( any(it.installed for it in installed_interpreters_list('nodejs')) and self._is_package_installed(get_passenger_package_name()) and self._is_nodejs_selector_enabled() ) def initial_status(self): # type: () -> Dict """ Return dictionary with two required keys: installed and options. This will be used by lvemanager UI to properly display wizard. """ interpreters_list = installed_interpreters_list('nodejs') installed_versions = [it.version for it in interpreters_list if it.installed] return { 'already_configured': self._is_already_configured(), 'options': { 'default_version': self._nodejs_get_default_version(), 'installed_versions': installed_versions, 'available_versions': self._get_available_versions('nodejs'), }, } def _is_nodejs_selector_enabled(self): # type: () -> bool """ Return True if Nodejs Selector enabled :return: bool """ self.app_logger.info("trying to get NodeJS Selector state.") try: from clselector.selectorlib import CloudlinuxSelectorLib # pylint: disable=import-outside-toplevel return CloudlinuxSelectorLib('nodejs').get_nodejs_selector_status()['selector_enabled'] except ImportError: return False	5.31 KB	2026-02-17 10:40
📄 php.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 from typing import Dict, List # NOQA from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed from clconfig.cagefs_statistics_config import check_cagefs_initialized from clwizard.constants import CL_SELECTOR_BIN, MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException, PackageMissingError from .base import WizardInstaller class PhpInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'php.log') _REQUIRED_CL_COMPONENT_SUPPORT = Feature.PHP_SELECTOR def _set_default_php_version(self, version): # type: (str) -> None self.app_logger.info("trying to set default php version as '%s'", version) try: self._run_command( [ CL_SELECTOR_BIN, 'set', '--interpreter', 'php', '--default-version', version, '--json', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _set_cloudlinux_selector_status(self, status): # type: (str) -> None self.app_logger.info("trying to set PHP Selector state '%s'", status) try: self._run_command( [ CL_SELECTOR_BIN, 'set', '--interpreter', 'php', '--selector-status', status, '--json', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _install_php_version(self, versions): # type: (List) -> None """ Install given php versions via groups :param versions: e.g ['4.4', '5.4', '5.6'] :return: None """ self.app_logger.info( "php version '%s' is going to be installed", ','.join(versions) ) groups = [] for ver in versions: # given version in format '5.6' get it's package name package_name = 'alt-php' + ver.replace('.', '') groups.append(package_name) try: # with RPM we install php versions via groups, # all extra alt-phpXX modules will be installed as dependencies # On Ubuntu, _install_groups will install the meta packages. self._install_groups(*groups) except ExternalProgramFailed as e: raise InstallationFailedException() from e def run_installation(self, options): # type: (Dict) -> None """ Run installation of php module It is possible to install only alt-php packages and skip further installation if 'enable_selector': False Otherwise we will configure php selector also -- set selector status to enabled -- set default version if it was passed :param options: {'versions': [5.5, 5.6], 'enable_selector': True} :return: """ default_version = options.get('default_version') install_versions = options.get('versions', []) to_enable_selector = options.get('enable_selector') if to_enable_selector: if default_version and default_version not in install_versions: self.app_logger.error( "Version %s that was specified to be set as default " "must be included in install_versions", default_version, ) raise InstallationFailedException() self._install_php_version(install_versions) if check_cagefs_initialized(): if to_enable_selector: self._set_cloudlinux_selector_status(status='enabled') if default_version: self._set_default_php_version(default_version) else: try: self._set_cloudlinux_selector_status(status='disabled') except Exception as e: self.app_logger.error( "Error occurred while disabling PHP Selector: %s", str(e) ) @classmethod def supported_options(cls): return {'default_version', 'versions', 'enable_selector'} @staticmethod def _php_get_default_version(): # type: () -> str try: from clselect.clselect import ClSelect # pylint: disable=import-outside-toplevel except ImportError as e: raise PackageMissingError('lvemanager') from e return ClSelect().get_version()[0] @staticmethod def _php_interpreters_list(): # type: () -> List try: from clselect.clselectctl import ( # pylint: disable=import-outside-toplevel interpreter_versions_short_summary ) except ImportError as e: raise PackageMissingError('lvemanager') from e return interpreter_versions_short_summary('php') def _get_warnings(self): # type: () -> List[Dict] """ Get list of warnings that should be shown in wizard before module installation """ warnings = [ { # this message is hardcoded because we do not want to # show a lot of possible warnings, so just tell the client to go # to the settings page where cldiag warnings are shown 'message': "Further CloudLinux PHP Selector setup will be available " "in LVE Manager settings after installation. Find more details " "in our documentation at %(url)s.", 'context': { 'url': 'https://docs.cloudlinux.com/php_selector_installation.html' }, } ] return warnings def initial_status(self): # type: () -> Dict installed_versions = [] for php_interpreter in self._php_interpreters_list(): if not php_interpreter.installed: continue installed_versions.append(php_interpreter.version) return { # As 'PHP Configure' in the wizard could be used for our PHP selector AND # for installing PHP interpreters, 'already_configured' should be True # when any PHP interpreter is installed. 'already_configured': any(installed_versions), 'options': { 'default_version': self._php_get_default_version(), 'installed_versions': installed_versions, 'available_versions': self._get_available_versions('php'), 'enable_selector': self._is_php_selector_enabled(), }, 'warnings': self._get_warnings(), } def _is_php_selector_enabled(self): # type: () -> bool """ Return True if Php Selector enabled in UI and could be used """ return bool(check_cagefs_initialized() and self._is_php_selector_enabled_in_config()) def _is_php_selector_enabled_in_config(self): # type: () -> bool """ Return True if Php Selector is enabled for UI in panel specific (DA, Plesk or cPanel) config """ self.app_logger.info("trying to get Php Selector state.") try: from clselector.selectorlib import CloudlinuxSelectorLib # pylint: disable=import-outside-toplevel return CloudlinuxSelectorLib('php').php_selector_is_enabled() except ImportError: return False	7.7 KB	2026-02-17 10:40
📄 python.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 from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed, get_passenger_package_name, is_litespeed_running from clconfig.ui_config_lib import get_ui_config from clwizard.constants import CL_SELECTOR_BIN, MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException, PackageMissingError from clwizard.utils import installed_interpreters_list from .base import WizardInstaller class PythonInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'python.log') _REQUIRED_CL_COMPONENT_SUPPORT = Feature.PYTHON_SELECTOR def _install_python_versions(self, versions): """ Install given python versions :param versions: versions of python packages """ groups = [] for v in versions: package_name = 'alt-python' + v.replace('.', '') groups.append(package_name) self.app_logger.info("Try to install Python package with versions: %s", ','.join(versions)) try: self._install_groups(*groups) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _configure_for_litespeed_server(self): """ In order to make python apps work on Litespeed server we need to do run extra script see docs for details: https://www.litespeedtech.com/support/wiki/doku.php/litespeed_wiki:cloudlinux:enable_passenger :return: """ litespeed_script = '/usr/local/lsws/admin/misc/enable_ruby_python_selector.sh' # we are going to simplify process of making python/ruby apps work under Litespeed # so in future we will not need to run extra script if not os.path.isfile(litespeed_script): return try: self._run_command(['sh', litespeed_script]) except ExternalProgramFailed as e: raise InstallationFailedException() from e @staticmethod def _get_python_default_version(): # type: () -> str try: from clselect.clselectctl import get_default_version # pylint: disable=import-outside-toplevel except ImportError as e: raise PackageMissingError('lvemanager') from e return get_default_version('python') def _set_python_default_version(self, version): # type: (str) -> None self.app_logger.info("trying to set default python version as '%s'", version) try: self._run_command( [ CL_SELECTOR_BIN, 'set', '--interpreter', 'python', '--default-version', version, '--json', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _is_already_configured(self): """ Check that python selector is ready to work All configurations were done: - passenger package is installed We always have python27 installed, so we do not need to check if at least one interpreter is installed If the config file does not exist, we ignore the uiSettings :return: already_configured status :rtype: bool """ return self._is_package_installed(get_passenger_package_name()) and ( not get_ui_config() or not get_ui_config().get('uiSettings', {}).get('hidePythonApp') ) def initial_status(self): installed_python_versions = [] interpreters_list = installed_interpreters_list('python') for interpreter in interpreters_list: if interpreter.installed: installed_python_versions.append(interpreter.version) return { 'already_configured': self._is_already_configured(), 'options': { 'installed_versions': installed_python_versions, 'available_versions': self._get_available_versions('python'), 'default_version': self._get_python_default_version(), }, } def run_installation(self, options): install_versions = options.get('versions', []) default_version = options.get('default_version') if default_version and default_version not in install_versions: self.app_logger.error( "Version %s that specified to be set as default " "must be included in install_versions", default_version, ) raise InstallationFailedException() self._install_passenger() self._install_python_versions(install_versions) # if Litespeed server is running - do some extra configuration if is_litespeed_running(): self._configure_for_litespeed_server() # do not hide python app in web interface try: self._run_command( [ 'cloudlinux-config', 'set', '--json', '--data={"options": {"uiSettings": {"hidePythonApp": false}}}', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e if default_version: self._set_python_default_version(default_version) @classmethod def supported_options(cls): return {'versions', 'default_version'}	5.56 KB	2026-02-17 10:40
📄 ruby.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 from clcommon.const import Feature from clcommon.utils import ExternalProgramFailed, get_passenger_package_name, is_litespeed_running from clconfig.ui_config_lib import get_ui_config from clwizard.constants import MODULES_LOGS_DIR from clwizard.exceptions import InstallationFailedException from clwizard.utils import installed_interpreters_list from .base import WizardInstaller class RubyInstaller(WizardInstaller): LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'ruby.log') _REQUIRED_CL_COMPONENT_SUPPORT = Feature.RUBY_SELECTOR def _install_ruby_versions(self, versions): groups = [] for v in versions: package_name = 'alt-ruby' + v.replace('.', '') groups.append(package_name) self.app_logger.info("Try to install Ruby package with versions: %s", ','.join(versions)) try: self._install_groups(*groups) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _configure_for_litespeed_server(self): """ In order to make ruby apps work on Litespeed server, we need to run an extra script See docs for details: https://www.litespeedtech.com/support/wiki/doku.php/litespeed_wiki:cloudlinux:enable_passenger :return: """ litespeed_script = '/usr/local/lsws/admin/misc/enable_ruby_python_selector.sh' # we are going to simplify process of making python/ruby apps work under Litespeed # so in future we will not need to run extra script if not os.path.isfile(litespeed_script): return try: self._run_command(['sh', litespeed_script]) except ExternalProgramFailed as e: raise InstallationFailedException() from e def _is_already_configured(self): """ Check that the Ruby Selector is ready to work All configurations were done and Passenger is installed We always have at least one ruby package installed, because it's a dependency of the Passenger package, so we can skip that check If the config file does not exist, we ignore the uiSettings :return: already_configured status :rtype: bool """ passenger_installed = self._is_package_installed(get_passenger_package_name()) configs_ok = not get_ui_config() or not get_ui_config().get('uiSettings', {}).get('hideRubyApp') return passenger_installed and configs_ok def initial_status(self): installed_ruby_versions = [] interpreters_list = installed_interpreters_list('ruby') for interpreter in interpreters_list: if interpreter.installed: installed_ruby_versions.append(interpreter.version) return { 'already_configured': self._is_already_configured(), 'options': { 'installed_versions': installed_ruby_versions, 'available_versions': self._get_available_versions('ruby'), }, } def run_installation(self, options): install_versions = options.get('versions', []) self._install_passenger() self._install_ruby_versions(install_versions) # if Litespeed server is running - do some extra configuration if is_litespeed_running(): self._configure_for_litespeed_server() # do not hide ruby app in web interface try: self._run_command( [ 'cloudlinux-config', 'set', '--json', '--data={"options": {"uiSettings": {"hideRubyApp": false}}}', ] ) except ExternalProgramFailed as e: raise InstallationFailedException() from e @classmethod def supported_options(cls): return {'versions'}	3.99 KB	2026-02-17 10:40

Terminal