Sindbad~EG File Manager

# 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 __future__ import absolute_import
import os

from typing import List, Dict, Tuple  # NOQA

from clwizard.constants import MODULES_LOGS_DIR, CL_SELECTOR_BIN
from .base import (
    WizardInstaller
)
from clwizard.exceptions import InstallationFailedException, PackageMissingError
from clcommon.utils import ExternalProgramFailed
from clconfig.cagefs_statistics_config import check_cagefs_initialized
from clcommon.const import Feature


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:
            raise InstallationFailedException()

    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:
            raise InstallationFailedException()

    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 v in versions:
            # given version in format '5.6' get it's package name
            package_name = 'alt-php' + v.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:
            raise InstallationFailedException()

    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 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
        except ImportError:
            raise PackageMissingError('lvemanager')
        return ClSelect().get_version()[0]

    @staticmethod
    def _php_interpreters_list():
        # type: () -> List
        try:
            from clselect.clselectctl import interpreter_versions_short_summary
        except ImportError:
            raise PackageMissingError('lvemanager')
        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 lot of possible warnings, so just say 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. More details you "
                       "can find in our documentation %(url)s.",
            'context': {'url': 'https://docs.cloudlinux.com/php_selector_installation.html'}
        }]

        return warnings

    def initial_status(self):
        # type: () -> Dict

        installed_versions = []
        for it in self._php_interpreters_list():
            if not it.installed:
                continue
            installed_versions.append(it.version)
        return {
            #  As 'PHP Configure' in 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
            return CloudlinuxSelectorLib('php').php_selector_is_enabled()
        except ImportError:
            return False