ok
Mini Shell
# 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
# NOTE: At the moment, alt-php versions on Ubuntu are installed as plain
# packages. At some point in the future, they'll need to be installed through
# metapackages instead. This part'll have to be changed then.
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
Zerion Mini Shell 1.0