<h2>Edit File: mod_lsapi_stat.py</h2><form method="post"><textarea name="content" rows="20" cols="80"># Copyright (c) Cloud Linux GmbH &amp; Cloud Linux Software, Inc 2010-2018 All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os
import json
import traceback
import subprocess
import configparser
import exec_command
from lve_diagnostic import get_cp
from dashboard_malfunctions import criu_settings_malfunctions
from dashboard_malfunctions import lsapi_settings_malfunctions
from dashboard_malfunctions import liblsapi_malfunctions
from stat_utils import cpanel_whmapi, plesk_bin_php_handler, dump_loaded_modules, dump_lsapi, query_strings
from stat_utils import get_da_domains, get_da_php_options, read_da_config, liblsapi_path, pretty_version_keys, count_domains, StatUtilsException
import selector_usage_lib


class ModLsapiStatException(Exception):
    pass


def get(as_json=False):
    &quot;&quot;&quot;
    Return statistics data
    :param as_json: return json string if True, dict otherwise
    :return: statistics data dict(
                `controlPanel`: EA3/EA4/Plesk/DirectAdmin/Unknown CP,
                `criu`: dict(
                        `status`: running/stopped,
                        `version`: version
                    ),
                `domainStat`: dict(
                        `version`: `domains_num`,
                        ...
                    ) or dict(`error`: description) if some error occurred,
                `lsapiConf`: dict(
                        lsapi_with_connection_pool: on/off,
                        lsapi_criu: on/off
                    )
            ) or its json-packed version
    &quot;&quot;&quot;
    error = None
    stats = {}
    control_panel = get_cp()
    try:
        if control_panel.name == &#039;cPanel&#039;:
            if os.path.exists(&#039;/etc/cpanel/ea4/is_ea4&#039;):
                stats[&#039;domainStat&#039;] = get_cpanel_ea4_stat()
            else:
                error = &#039;mod_lsapi domains stat is currently unsupported for EA3&#039;
        elif control_panel.name == &#039;Plesk&#039;:
            stats[&#039;domainStat&#039;] = get_plesk_stat()
        elif control_panel.name == &#039;DirectAdmin&#039;:
            stats[&#039;domainStat&#039;] = get_da_stat()
        else:
            error = &#039;mod_lsapi domains stat is currently unsupported for {0}&#039;.format(control_panel.name)
    except ModLsapiStatException as e:
        error = str(e)

    if error is not None:
        stats[&#039;domainStat&#039;] = dict()
        stats[&#039;domainStatError&#039;] = error

    stats[&#039;controlPanel&#039;] = str(control_panel)
    stats.update(get_lsapi_conf())
    stats.update(get_crui_stat())

    stats.update({&#039;totalDomain&#039;: sum(stats[&#039;domainStat&#039;].values())})
    analyze_malfunctions(stats)

    if as_json:
        return json.dumps(stats, sort_keys=True)
    else:
        return stats


def get_cpanel_ea4_stat(lsapi_only=True, with_selector=True):
    &quot;&quot;&quot;
    Collect mod_lsapi statistics for cPanel EA4 through WHM API
    :param lsapi_only: return only lsapi domains statistics if True, or full statistics if False
    :param with_selector: take into account the statistics of php selector
    :return: if lsapi_only return lsapi domains per version
                stat dict(
                    `version`: `domains_num`,
                    ...
                )
            else return full statistics per handler
                stat dict(
                    `handler`: {`version`: `domains_num`, ... }
                    ...
                )
    &quot;&quot;&quot;
    domains_per_version = dict()  # to store `version`: `domains_list`
    handlers_stat = dict()  # to store `handler`: {`version`: `domains_num`, ...}
    domain_users = dict()  # to store `domain`: `user` correspondence
    try:
        # get all vhosts along with versions
        vhosts_data = cpanel_whmapi(&#039;php_get_vhost_versions&#039;).get(&#039;versions&#039;)
        for vhost in vhosts_data:
            domains_per_version.setdefault(vhost.get(&#039;version&#039;), set()).add(vhost.get(&#039;vhost&#039;))
            domain_users[vhost.get(&#039;vhost&#039;)] = vhost.get(&#039;account&#039;)
        # get handlers for versions
        handlers_data = cpanel_whmapi(&#039;php_get_handlers&#039;).get(&#039;version_handlers&#039;)
        version_handlers = dict([(h.get(&#039;version&#039;), h.get(&#039;current_handler&#039;)) for h in handlers_data])
        all_versions = list(version_handlers.keys())

        # map {version: domains_list} to handlers, domains count in place
        for ver, handler in version_handlers.items():
            handlers_stat.setdefault(handler, dict()).update({ver: domains_per_version.get(ver, set())})

        # reinspect handlers stat against selector
        if with_selector:
            s_checked_version_handlers = selector_usage_lib.ea4_selector_check(domains_per_version, domain_users, handlers_stat)
            handlers_stat = s_checked_version_handlers

        # update structure with versions, which are not used by one handler, e.g. `ver: 0 domains`
        for h, v in handlers_stat.items():
            v.update(dict.fromkeys(set(all_versions).difference(list(v.keys())), set()))
    except (KeyError, TypeError, StatUtilsException):
        raise ModLsapiStatException(&#039;&#039;.join(traceback.format_exc().split(&#039;\n&#039;)))

    # return only number of domains
    return count_domains(handlers_stat, all_versions, lsapi_only)


def get_plesk_stat(lsapi_only=True, with_selector=True):
    &quot;&quot;&quot;
    Collect mod_lsapi statistics for Plesk
    Collects lsapi domains ONLY
    :param lsapi_only: return only lsapi domains statistics if True, or full statistics if False
    :param with_selector: take into account the statistics of php selector
    :return: if lsapi_only return lsapi domains per version dict(
                    `version`: `domains_num`
                    ...
                )
            else return stats with handler dict(
                    `lsapi`: {`version`: `domains_num`, ... }
                )
    &quot;&quot;&quot;
    handler_tmpl = &#039;alt-php{v}&#039;
    custom_version = &#039;alt-php56&#039;
    domain_version_stat = dict()
    try:
        all_handlers = plesk_bin_php_handler(&#039;list&#039;)
        # on Plesk mod_lsapi is used only through handlers x-httpd-lsphp-*, which are added by --setup
        lsphp_handlers = [h for h in all_handlers if &#039;lsphp&#039; in h.get(&#039;id&#039;)]
        for handler in lsphp_handlers:
            handler_id = handler.get(&#039;id&#039;)
            php_version = &#039;&#039;.join(handler.get(&#039;fullVersion&#039;).split(&#039;.&#039;)[:-1])
            domains = set([d.get(&#039;domain&#039;) for d in plesk_bin_php_handler(&#039;get-usage&#039;, id=handler_id)])
            # x-httpd-lsphp-custom domains are to be checked withon selector
            if &#039;custom&#039; in handler_id:
                version_id = &#039;custom&#039;
                custom_version = handler_tmpl.format(v=php_version)
            else:
                version_id = handler_tmpl.format(v=php_version)
            domain_version_stat[version_id] = domains
        # PLACE SELECTOR CHECK HERE (should be done for custom handler)
        if with_selector:
            domain_version_stat = selector_usage_lib.plesk_selector_check(domain_version_stat, custom_version)
    except (KeyError, TypeError, AttributeError, StatUtilsException, selector_usage_lib.SelectorStatException):
        raise ModLsapiStatException(&#039;&#039;.join(traceback.format_exc().split(&#039;\n&#039;)))
    # return only number of domains
    result_stat = {
        &#039;lsapi&#039;: {k: len(v) for k, v in domain_version_stat.items()}
    }
    return result_stat[&#039;lsapi&#039;] if lsapi_only else result_stat


def get_da_stat(lsapi_only=True, with_selector=True):
    &quot;&quot;&quot;
    Collect lsapi domains statistics fro DirectAdmin
    :param lsapi_only: return only lsapi domains statistics if True, or full statistics if False
    :param with_selector: take into account the statistics of php selector
    :return: if lsapi_only return lsapi domains per version
                stat dict(
                    `version`: `domains_num`,
                    ...
                )
            else return full statistics per handler
                stat dict(
                    `handler`: {`version`: `domains_num`, ... }
                    ...
                )
    &quot;&quot;&quot;
    domain_conf_path = &#039;/usr/local/directadmin/data/users/{user}/domains/{domain}.conf&#039;
    handler_stat = dict()
    try:
        # get php settings from option.conf
        php_options = get_da_php_options()
        php1_ver = php_options[1][&#039;version&#039;]
        php2_ver = php_options[2][&#039;version&#039;]
        php1_handler = php_options[1][&#039;handler&#039;]
        php2_handler = php_options[2][&#039;handler&#039;]

        php1_label = pretty_version_keys(php1_ver)
        php2_label = pretty_version_keys(php2_ver)

        # get user: domains correspondence
        user_domains = get_da_domains()
        joined = set()
        [joined.update(v) for v in user_domains.values()]
        # analyze options.conf settings for versions
        if php2_ver == &#039;no&#039;:
            # no secondary php set, assume all domains use primary
            version_stat = {php1_label: joined}
            handler_stat[php1_handler] = {php1_label: joined}
        elif php1_ver == &#039;no&#039;:
            # no primary php set, assume all domains use secondary
            version_stat = {php2_label: joined}
            handler_stat[php2_handler] = {php2_label: joined}
        else:
            version_stat = {php1_label: set(), php2_label: set()}
            # if both php releases in options.conf are set, that means that DA PHP selector is enabled
            for user, domains in user_domains.items():
                # find php release settings for each domain
                for domain in domains:
                    config_path = domain_conf_path.format(user=user, domain=domain)
                    try:
                        # try to find which version domain uses as primary
                        conf_parser, global_section = read_da_config(config_path)
                        php_setting = conf_parser.getint(global_section, &#039;php1_select&#039;)
                        version = pretty_version_keys(php_options[php_setting][&#039;version&#039;])
                        version_stat.get(version).add(domain)
                    except configparser.NoOptionError:
                        # means that domain do not use DA PHP selector and uses primary php version from options.conf
                        version_stat.get(php1_label).add(domain)
            # if both php releases in options.conf are set, that means that DA PHP selector is enabled
            # create per-handler statistics
            if php1_handler == php2_handler:
                handler_stat[php1_handler] = {php1_label: version_stat[php1_label],
                                              php2_label: version_stat[php2_label]}
            else:
                handler_stat[php1_handler] = {php1_label: version_stat[php1_label],
                                              php2_label: set()}
                handler_stat[php2_handler] = {php2_label: version_stat[php2_label],
                                              php1_label: set()}

        if with_selector:
            selector_updated = selector_usage_lib.da_selector_check(version_stat.get(php1_label), user_domains, php1_label)
            handler_stat.get(php1_handler).update(selector_updated)
    except (KeyError, TypeError, AttributeError, StatUtilsException):
        raise ModLsapiStatException(&#039;&#039;.join(traceback.format_exc().split(&#039;\n&#039;)))

    # return only number of domains
    return count_domains(handler_stat, [php1_label, php2_label], lsapi_only)


def get_crui_stat():
    &quot;&quot;&quot;
    Get criu service info
    :return: dict(
                `criu`: dict(
                    `status`: running/stopped,
                    `version`: version
                )
            )
    &quot;&quot;&quot;
    criu_version = &#039;&#039;.join(exec_command.exec_command(&#039;/usr/sbin/criu -V&#039;))

    try:
        subprocess.check_call([&#039;/sbin/service&#039;, &#039;criu&#039;, &#039;status&#039;], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        criu_service_status = &#039;running&#039;
    except subprocess.CalledProcessError:
        criu_service_status = &#039;stopped&#039;

    return {
        &#039;criu&#039;: {
            &#039;status&#039;: criu_service_status,
            &#039;version&#039;: criu_version.split(&#039; &#039;)[1] if criu_version else &#039;not installed&#039;
        }
    }


def get_lsapi_conf():
    &quot;&quot;&quot;
    Retrieve lsapi configuration:
    - crui
    - connection pool
    and versions of module and library
    :return: dict(
                lsapiConf: dict(
                    lsapi_with_connection_pool: on/off,
                    lsapi_criu: on/off
                ),
                modVersion: version,
                libVersion: version
            )
    &quot;&quot;&quot;
    # Plesk carries upstream apache 2.4.6, which says
    # `Passing arguments to httpd using apachectl is no longer supported.`
    # have to query with httpd instead of apachectl
    apache_conf = dump_lsapi()
    apache_modules = dump_loaded_modules()
    mod_status = apache_modules.get(&#039;lsapi_module&#039;, None)
    return {
        &#039;lsapiConf&#039;: {
            &#039;lsapi_criu&#039;: apache_conf.get(&#039;lsapi_criu&#039;, &#039;off&#039;),
            &#039;lsapi_with_connection_pool&#039;: apache_conf.get(&#039;lsapi_with_connection_pool&#039;, &#039;off&#039;)
        },
        &#039;modVersion&#039;: apache_conf.get(&#039;version&#039;, None),
        &#039;libVersion&#039;: query_strings(liblsapi_path(), &#039;liblsapi_version&#039;),
        &#039;modStatus&#039;: &#039;disabled&#039; if not mod_status else &#039;enabled&#039;
    }


def analyze_malfunctions(stats_dict):
    &quot;&quot;&quot;
    Detect configuration malfunctions and update resulting statistics dict accordingly
    For now only criu malfunctions are presented
    See malfunctions in dashboard_malfunctions.py module
    :param stats_dict: resulting statistics dict
    &quot;&quot;&quot;
    malfunctions = list()

    def add_malfunction(malfunc_dict, key):
        try:
            # try to detect one malfunction
            malfunctions.append(malfunc_dict[key])
        except KeyError:
            # no malfunction found
            pass

    criu_settings = &#039;{opt}_{serv}&#039;.format(opt=stats_dict[&#039;lsapiConf&#039;][&#039;lsapi_criu&#039;],
                                          serv=stats_dict[&#039;criu&#039;][&#039;status&#039;])

    lsapi_settings = stats_dict[&#039;modStatus&#039;]
    # for further extension of similar malfunctions:
    # malfuncs = tuple of malfunctions
    # keys = tuple of according keys
    # for malfunc, k in zip(malfuncs, keys):
    #     add_malfunction(malfunc, k)
    add_malfunction(liblsapi_malfunctions, stats_dict[&#039;libVersion&#039;])
    add_malfunction(lsapi_settings_malfunctions, lsapi_settings)
    add_malfunction(criu_settings_malfunctions, criu_settings)

    # no need in `malfunctions` field if there are no malfunctions
    if not malfunctions:
        return
    else:
        stats_dict.update({&#039;malfunctions&#039;: malfunctions})
</textarea><br><input type="hidden" name="edit_file" value="mod_lsapi_stat.py"><input type="submit" value="Save"></form>