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/LICENSE.TXT

from __future__ import absolute_import
from itertools import chain

from future.utils import itervalues, iterkeys, iteritems

from cllimitslib_v2 import LimitsDataStorage, DEFAULTS
from clveconfig.ve_config_reader import DEFAULT_PROVIDER
from collections import defaultdict
from typing import Dict, Tuple, List, Optional, Union, Any  # NOQA

from .base import BaseValidator, ENTITY_USER, ENTITY_PACKAGE, ENTITY_RESELLER, ENTITY_DEFAULTS  # NOQA
from .ep_nproc_validator import EpNprocValidator
from cllimits import LveCtl


class LimitsValidator(object):

    # This dict contains keys which are old names of entities
    # and contais values which are new names of entities.
    # Old names will be replaced by new names for improve readability of error message
    dict_of_replaced_names_of_entities = {
        'user': 'User(s)',
        'package': 'Package(s)',
        'reseller': 'Reseller(s)',
        'defaults': 'Defaults of resellers'
    }
    # This dict contains keys which are old ids of entities
    # and contais values which are new ids of entities.
    # Old ids will be replaced by ids names for improve readability of error message
    dict_of_replaced_ids_of_entities = {
        'defaults': 'Hoster defaults limits'
    }
    # This list contains ids entities which will be deleted
    # for improve readability of error message
    list_of_deleted_ids_of_entities = [
        DEFAULTS
    ]

    # This dict contais keys which are old specific messages and
    # contains values which are new specific message
    # Old specific msgs will be replaced by new for improve readability of error message
    dict_of_replaced_specific_messages = {
        'inherited from Global': 'inherited from Hoster'
    }

    def __init__(self, _limits_data_storage=None, validators=None):
        # type: (Optional[LimitsDataStorage], Optional[List[BaseValidator]]) -> None
        self.limits_provider = _limits_data_storage or LimitsDataStorage()
        self._list_validators = validators or [
            EpNprocValidator(self.limits_provider),
        ]  # type: List[BaseValidator]

        self.message_dict = {
            'common_msg': None,
            'specific_msg': None,
            'affected_entity': None,
            'entity_id': None,
        }

    @staticmethod
    def _format_message_string_from_single_msg_dict(msg_dict):
        # type: (Dict[str, str, str, str]) -> str
        """
        Format message string from single message dict.
        That function should be used for formatting message while validation input limits
        """

        common_msg = msg_dict['common_msg']
        specific_msg = msg_dict['specific_msg']
        affected_entity = msg_dict['affected_entity']
        entity_id = msg_dict['entity_id']

        if affected_entity is not None and entity_id is not None:
            if entity_id == DEFAULTS:
                msg_about_affect = 'Hoster defaults limits is affected'
            elif affected_entity == ENTITY_DEFAULTS:
                msg_about_affect = 'Defaults limits of Reseller "{}" are affected.'.format(entity_id)
            elif affected_entity == ENTITY_USER:
                msg_about_affect = 'Limits of user with LVE ID "{}" are affected.'.format(entity_id)
            elif affected_entity == ENTITY_RESELLER:
                msg_about_affect = 'Limits of Reseller "{}" are affected.'.format(entity_id)
            else:
                msg_about_affect = 'Limits of package "{}" are affected.'.format(entity_id)
        else:
            msg_about_affect = ''
        if specific_msg is None:
            specific_msg = ''

        result_msg = '{} {} {}'.format(
            common_msg,
            msg_about_affect,
            specific_msg,
        )

        return result_msg

    def _call_validators_and_process_result(self, only_input_limits, *args, **kwargs):
        # type: (bool, *Any, **Any) -> Tuple[bool, List]
        """
        Call each validator from validators list and processing results
        args and kwargs are argumets for calling of validator
        We validate limits which already are recorded in ve.cfg if only_input_limits is False.
        We validate limits which we want to set if only_input_limits is True
        We return aggregated result as bool value and list of messages
        which explain which limits are wrong and who holds those
        """

        msg_list = list()
        total_result = True
        for validator in self._list_validators:
            if only_input_limits:
                result, msg_dict = validator.validate_input_limits(*args, **kwargs)
            else:
                result, msg_dict = validator.validate_existing_limits(*args, **kwargs)
            total_result &= result
            msg_list.append(msg_dict)
        return total_result, msg_list

    def validate_input_limits(self, entity_type, entity_id, input_limits, reseller=DEFAULT_PROVIDER):
        # type: (str, Union[str, int], Dict, str) -> Tuple[bool, List]

        check_reseller_defaults = False
        if entity_type == ENTITY_USER:
            validated_entity = self.limits_provider.get_user_by_uid(int(entity_id))
        elif entity_type == ENTITY_PACKAGE:
            validated_entity = self.limits_provider.get_package_by_name_and_reseller(str(entity_id), str(reseller))
        elif entity_type == ENTITY_RESELLER:
            validated_entity = self.limits_provider.get_reseller_by_name(str(entity_id))
        elif entity_type == ENTITY_DEFAULTS:
            if entity_id != DEFAULTS:
                validated_entity = self.limits_provider.get_reseller_by_name(str(entity_id))
            else:
                validated_entity = entity_id
            check_reseller_defaults = True
        else:
            validated_entity = None

        total_result, msg_list = self._call_validators_and_process_result(
            True,
            validated_entity,
            input_limits,
            check_reseller_defaults,
        )
        msg_list = [self._format_message_string_from_single_msg_dict(msg_dict) for msg_dict in msg_list]

        return total_result, msg_list

    def _validate_users(self):
        # type: () -> List[Tuple[bool, List[Dict]]]

        users = itervalues(self.limits_provider.users)
        result = [self._call_validators_and_process_result(False, user) for user in users]

        return result

    def _validate_packages(self):
        # type: () -> List[Tuple[bool, List[Dict]]]

        packages = itervalues(self.limits_provider.packages)
        result = [self._call_validators_and_process_result(False, package) for package in packages]

        return result

    def _validate_resellers(self):
        # type: () -> List[Tuple[bool, List[Dict]]]

        resellers = itervalues(self.limits_provider.resellers)
        # We should validate only activated resellers,
        # because not activated resellers don't have any limits.
        result = [self._call_validators_and_process_result(False, reseller) for reseller in resellers
                  if reseller.defaults is not None]

        return result

    def _validate_defaults(self):
        # type: () -> List[Tuple[bool, List[Dict]]]

        result = []
        for default_name in iterkeys(self.limits_provider.defaults):
            default_entity = self.limits_provider.resellers.get(default_name, DEFAULTS)
            # We should validate only defaults which belong to activated resellers,
            # because not activated resellers don't have any limits.
            if default_entity != DEFAULTS and default_entity.defaults is None:
                continue
            result.append(self._call_validators_and_process_result(False, default_entity))
        return result

    def _replace_specific_msgs(self, specific_msg):
        # type: (str) -> str
        """
        Replacing some specific messages for improve readability of error message
        """
        for old_spec_msg, new_spec_msg in iteritems(self.dict_of_replaced_specific_messages):
            if specific_msg is None:
                break
            specific_msg = specific_msg.replace(old_spec_msg, new_spec_msg)

        return specific_msg

    def _replace_ids_of_entities(self, entity_id):
        # type: (str) -> str
        """
        Replacing some ids of entities for improve readability of error message
        """
        if entity_id in self.dict_of_replaced_ids_of_entities:
            return self.dict_of_replaced_ids_of_entities[entity_id]
        else:
            return entity_id

    def _replace_names_of_entities(self, entity_name):
        # type: (str) -> str
        """
        Replacing some names of entities for improve readability of error message
        """
        if entity_name in self.dict_of_replaced_names_of_entities:
            return self.dict_of_replaced_names_of_entities[entity_name]
        else:
            return entity_name

    def _format_message_string_for_existing_limits(self, total_result_list):
        # type: (List[Dict[str, str, str, str]]) -> str
        """
        Format message string from result of execution of validation the existing limits
        """

        total_result_dict = defaultdict(lambda: defaultdict(list))
        total_msg = None

        # We are groupping affected entities (entity_id) by name of check (common_msg)
        # and type of affected entity (affected_entity).
        for msg_dict in total_result_list:
            name_of_check = msg_dict['common_msg']
            type_of_affected_entity = self._replace_names_of_entities(msg_dict['affected_entity'])
            entity_id = self._replace_ids_of_entities(msg_dict['entity_id'])
            # Deleting some ids of entities for improve readability of error message
            if entity_id in self.list_of_deleted_ids_of_entities:
                continue
            total_result_dict[name_of_check][type_of_affected_entity].append({
                'entity_id': entity_id,
                'specific_msg': self._replace_specific_msgs(msg_dict['specific_msg'])
            })

        for common_msg, entities_dict in iteritems(total_result_dict):
            total_msg = '{}{}\n'.format(
                '' if total_msg is None else total_msg,
                common_msg,
            )
            for entity_type, list_entity_dicts in iteritems(entities_dict):
                affected_entities = list()

                # make string as `entity_1 (specific_msg_1), entity_2, entity_3, entity_4 (specific_msg)
                for entity_dict in list_entity_dicts:
                    if entity_dict['specific_msg'] is None:
                        affected_entity = entity_dict['entity_id']
                    else:
                        affected_entity = '{} ({})'.format(
                            entity_dict['entity_id'],
                            entity_dict['specific_msg']
                        )
                    affected_entities.append(affected_entity)
                affected_entities = ', '.join(str(item) for item in set(affected_entities))

                total_msg = '{}{}: {}\n'.format(
                    total_msg,
                    entity_type.capitalize(),
                    affected_entities,
                )

        return total_msg

    def validate_existing_limits(self):
        # type: () -> Optional[str]

        total_result_list = [
            msg_dict for result, msg_dict_list in chain(
                self._validate_users(),
                self._validate_packages(),
                self._validate_resellers(),
                self._validate_defaults(),
            ) for msg_dict in msg_dict_list if not result
        ]

        total_msg = self._format_message_string_for_existing_limits(total_result_list)
        return total_msg

    @staticmethod
    def is_low_pmem_limit_present() -> bool:
        """
        Check is Low PMEM limit present
        :return True/False
        """
        _lvectl = LveCtl()
        _panel_uids_list = _lvectl.get_panel_users_uid_list()
        _lvectl._load_info(False)
        for uid in _panel_uids_list:
            if uid == 0:
                # skip defaults
                continue
            limits = _lvectl.get_limits_by_user_id(uid)
            # limits example:
            # {'cpu': {'all': '100'}, 'io': {'all': '1024'}, 'vmem': '0', 'ep': '20', 'pmem': '*268435456',
            # 'nproc': '100', 'iops': '*4096'}
            try:
                # Extract PMEM limit
                pmem_limit_bytes = int(limits['pmem'].replace('*', ''))
                if pmem_limit_bytes != 0 and pmem_limit_bytes < 512 * 1024 * 1024:
                    # PMEM limit not unlimited and < 512 MB - error
                    return True
            except ValueError:
                pass
        return False