^^&&^^

Edit File: 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 __future__ import absolute_import
import os
from contextlib import contextmanager
from typing import Dict, List  # NOQA

from clcommon.const import Feature
from clcommon.utils import (
    ExternalProgramFailed,
    is_ea4,
    is_litespeed_running,
    is_testing_enabled_repo,
)
from clwizard.constants import MODULES_LOGS_DIR
from clwizard.exceptions import InstallationFailedException
from cldetectlib import is_da, get_apache_modules, get_boolean_param
from .base import (
    WizardInstaller
)

_DA_CUSTOMBUILD = '/usr/local/directadmin/custombuild/build'

class LsapiInstaller(WizardInstaller):
    LOG_FILE = os.path.join(MODULES_LOGS_DIR, 'lsapi.log')
    GENERAL_PACKAGE_LIST = ['liblsapi', 'liblsapi-devel', ]
    EA4_LSAPI_PACKAGE = 'ea-apache24-mod_lsapi'
    GENERAL_LSAPI_PACKAGE = 'mod_lsapi'
    UTILITY = '/usr/bin/switch_mod_lsapi'
    _REQUIRED_CL_COMPONENT_SUPPORT = Feature.LSAPI

def __init__(self):
        super(LsapiInstaller, self).__init__()
        self.lsapi_packages = self.GENERAL_PACKAGE_LIST[:]
        if is_ea4():
            self.lsapi_packages.append(self.EA4_LSAPI_PACKAGE)
        else:
            self.lsapi_packages.append(self.GENERAL_LSAPI_PACKAGE)
        self.apache_modules = get_apache_modules() or []  # type: List[str]

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 package base 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 for set option `cloudlinux_beta` in DA custombuild
        @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
        :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 lsapi in 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):
        # type: () -> List
        """
        Get a list of warnings that should be shown in wizard before the module
        installation.
        """
        warnings = []  # type: List[Dict]
        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):
        # type: () -> List
        """
        Get a list of possible blockers to disable module in Wizard UI.
        """
        blockers = []
        if is_litespeed_running():
            blockers.append(
                {
                    'message': 'The server is running under Litespeed.'
                               ' mod_lsapi works with 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 = {
            '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