Elep

# coding:utf-8

# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2022 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT

from typing import Tuple, Union

from docopt import DocoptExit, docopt
from schema import Schema, And, Use, Or, SchemaError

from clcommon.const import Feature
from clcommon.cpapi import is_panel_feature_supported

from .utils import VALUES_STR

PROG_NAME = "cloudlinux-limits"

AVAILABLE_LVE_KEYS = {"speed", "nproc", "pmem", "vmem", "maxEntryProcs", "io", "iops"}
AVAILABLE_LVP_KEYS = {"speed", "nproc", "pmem", "maxEntryProcs", "io", "iops"}
AVAILABLE_QUOTA_KEYS = {"inodes"}
AVAILABLE_MYSQL_KEYS = {"mysql-cpu", "mysql-io"}
AVAILABLE_KEYS = AVAILABLE_LVE_KEYS | AVAILABLE_QUOTA_KEYS | AVAILABLE_MYSQL_KEYS | AVAILABLE_LVP_KEYS
AVAILABLE_DEFAULTS = AVAILABLE_KEYS | {"all"}
if is_panel_feature_supported(Feature.LVE):
    AVAILABLE_LIMITS = AVAILABLE_KEYS | {"mysql-gov", "mysql-restrict", "cagefs"}
else:
    AVAILABLE_LIMITS = AVAILABLE_QUOTA_KEYS | {"cagefs"}
AVAILABLE_MYSQL_KEYS_ALL = AVAILABLE_MYSQL_KEYS | {"mysql-restrict", "mysql-unrestrict-all", "mysql-gov"}
ADMIN_ONLY_OPTIONS = ["--mysql-restrict", "--mysql-unrestrict-all", "--mysql-gov", "--mysql-io",
                      "--mysql-cpu", "--cagefs", "--inodes"]

def _default_keys_validate(keys):
    """
    Validate limits keys for --default
    """
    return len(set(keys) - AVAILABLE_DEFAULTS) == 0

def _limits_keys_validate(keys):
    """
    Validate limits keys
    """
    return len(set(keys.split(",")) - set(AVAILABLE_LIMITS)) == 0

# uncomment this for add full edit mode
# gov_int_list = And(Use(lambda x:x.split(",")), lambda x:len(x) == 4,
#                    Use(lambda x:map(int, x)))
global_schema = Schema({
    "set": bool,
    "get": bool,
    "disable-reseller-limits": bool,
    "enable-reseller-limits": bool,
    "--json": And(bool, lambda x: x, error="use --json option, other modes currently unsupported"),
    "--human-readable-numbers": bool,
    "--unlimited": bool,
    "--default": Or(None, And(Use(lambda x: x.split(',')), _default_keys_validate), error="Invalid keys"),
    "--save-all-parameters": bool,
    "--lve-id": Or(None, And(Use(int), lambda x: int(x) >= 0),
                   And(Use(lambda x: str(x).lower()),
                       lambda x: x == "default"),
                   error="--lve-id must be non-negative integer value or 'default'"),
    "--reseller-id": Or(None, And(Use(int), lambda x: int(x) >= 0),
                        error="--reseller-id must be non-negative integer value"),
    "--reseller-name": Or(None, And(str, lambda x: not x.isdigit()), error="Invalid reseller name"),
    "--all": bool,
    "--for-reseller": Or(None, And(str, lambda x: not x.isdigit()), error="Invalid reseller name"),
    "--username": Or(None, str),
    "--domain": Or(None, str),
    "--limits": Or(None, _limits_keys_validate, error="Invalid keys"),
    "--mysql-gov": Or(None, lambda x: x in ["ignored", "watched"],
                      error=f"{VALUES_STR}: 'ignored', 'watched'"),
    "--cagefs": Or(None, lambda x: x in ["enabled", "disabled"],
                   error=f"{VALUES_STR}: 'enabled', 'disabled'"),
    "--mysql-restrict": Or(None, lambda x: x in ["restricted", "unrestricted"],
                           error=f"{VALUES_STR}: 'restricted', 'unrestricted'"),
    "--mysql-unrestrict-all": bool,
    "--speed": Or(None, str),
    "--pmem": Or(None, str),
    "--vmem": Or(None, str),
    "--nproc": Or(None, str),
    "--io": Or(None, str),
    "--iops": Or(None, str),
    "--maxEntryProcs": Or(None, str),
    "--mysql-cpu": Or(None, And(Use(int), lambda x: x >= 0),
                      error="--mysql-cpu must be non-negative integer value"),
    # uncomment this for add full edit mode
    # "--mysql-io": Or(None, And(Use(int), lambda x:x >= 0), gov_int_list,
    "--mysql-io": Or(None, And(Use(int), lambda x: x >= 0),
                     error="--mysql-io must be non-negative integer value"),
    # uncomment this for add full edit mode
    # "--mysql-read": Or(None, And(Use(int), lambda x:x >= 0), gov_int_list,
    #                    error="--mysql-read must be non-negative integer value or 4 int numbers with comma"),
    # "--mysql-write": Or(None, And(Use(int), lambda x:x >= 0), gov_int_list,
    #                     error="--mysql-write must be non-negative integer value or 4 int numbers with comma"),
    "--inodes": Or(None, str),
    "--help": bool,
})

USAGE_CMDS = (
    "set [--json] (--lve-id <int> | --username <str>) (--unlimited) [--for-reseller <str>]",

"set [--json] (--lve-id <int> | --username <str> | --reseller-name <str>) (--default <str>)",

"set [--json] (--lve-id <int> | --username <str>) "
    "(--mysql-gov <ignored,watched> | --cagefs <enabled,disabled> | --mysql-restrict <restricted,unrestricted>)",

"set [--json] (--mysql-unrestrict-all)",

"set [--json] (--lve-id <int> | --username <str>) "
    "[--speed <str> --io <str> --nproc <str> --pmem <str> --vmem <str> --iops <str> --inodes <N,M> "
    "--maxEntryProcs <str> --mysql-cpu <int> --mysql-io <int> --save-all-parameters]",

"set [--json] (--lve-id <int> | --username <str> | --reseller-name <str>) "
    "[--speed <str> --io <str> --nproc <str> --pmem <str> --vmem <str> --iops <str> --maxEntryProcs <str>] "
    "[--default <str>] [--for-reseller <str>]",

"set [--json] (--reseller-name <str>) (--unlimited)",

"[get] [--json] [--lve-id <int> | --username <str> | --reseller-name <str> | --domain <str>] "
    "[--limits=<keys>] [--human-readable-numbers] [--for-reseller <str>]",

"disable-reseller-limits (--reseller-id <int> | --reseller-name <str>) [--json]",

"enable-reseller-limits ((--reseller-id <int> | --reseller-name <str>) | --all) [--json]",

"(-h | --help)",
)
USAGE = "\n    ".join(f"{PROG_NAME} {cmd}" for cmd in USAGE_CMDS).strip()

class CloudlinuxLimitsOptsParser:
    """
    Parse arguments for cloudlinux-limits command
    :param argv: sys.argv
    :param _is_json_need: sys.argv contains --json key
    :return cortege: (error_flag, s_message)
    """
    docstring = f"""Utility to get/set any Cloudlinux limits

Usage:
    {USAGE}

Options:
    --json                              Return data in JSON format.
    --lve-id <int>                      LVE id. will display record only for that LVE id.
    --username <str>                    Execute command only for specific user.
    --reseller-name <str>               Execute command only for specific reseller.
    --reseller-id <int>                 Execute command only for specific reseller.
    --all                               Execute command for all resellers
    --for-reseller <str>                Use supplied reseller for get/set data.
    --domain <str>                      Show data only for specific domain
    --limits <keys>                     Available keys: speed,nproc,pmem,vmem,maxEntryProcs,io,
                                                        iops,mysql-gov,mysql-cpu,mysql-io,cagefs,inodes
    --human-readable-numbers            Return PMEM and VMEM limits in KBytes, MBytes or GBytes
    --unlimited                         Set all limits to unlimited.
    --default [limits]                  Reset limits to the Package defaults.
                                        List of comma-separated limits to reset them to default or "all"
    --mysql-gov <ignored|watched>       Monitor or ignore by MySQL governor.
    --cagefs <enabled|disabled>         Enable or disable CageFS for a user.
    --mysql-restrict <[un]restricted>   Set user restrict status with dbctl (restricted or unrestricted).
    --mysql-unrestrict-all              Unrestrict all restricted users with dbctl.
    --speed <str>                       Limit CPU usage for LVE | LVP.
    --pmem <str>                        Limit physical memory usage for applications inside LVE | LVP.
    --vmem <str>                        Limit virtual memory for applications inside LVE.
    --nproc <str>                       Limit number of processes for LVE | LVP.
    --io <str>                          Define io limits for LVE | LVP (KB/s).
    --iops <str>                        Limit io per second for LVE | LVP.
    --maxEntryProcs <str>               Limit number of entry processes for LVE | LVP.
    --mysql-cpu <int>                   Set MySQL governor CPU limit (pct).
    --mysql-io <int>                    Set MySQL governor IO limit (read + write MB/s)
    --inodes <N,M>                      Set inode limits. N - soft, M - hard.
    --save-all-parameters               Save all parameters even if they match with defaults settings.
    -h, --help                          Show this help message and exit
"""

# add this parameters to docstring when need add read/write/cpu full edit mode
    # this line for Usage block
    # {0} set [--json] (--lve-id <int> | --username <str>) \
    #     [--speed <int> --io <int> --nproc <int> --pmem <int> --vmem <int> --iops <int> --inodes <N,M> \
    #     --maxEntryProcs <int> --mysql-cpu <int:int,int,int,int> --mysql-read <int:int,int,int,int> \
    #     --mysql-write <int:int,int,int,int> --mysql-io <int:int,int,int,int> --save-all-parameters]
    # this lines for Options block
    # --mysql-cpu <int:int,int,int,int>    Set MySQL governor CPU limit (pct).
    # --mysql-io <int:int,int,int,int>     Set MySQL governor IO limit (read + write KB/s)
    # --mysql-read <int:int,int,int,int>   Set MySQL governor read limit (KB/s)
    # --mysql-write <int:int,int,int,int>  Set MySQL governor write limit (KB/s)

commands = ("set", "get", "disable-reseller-limits", "enable-reseller-limits")

@staticmethod
    def _is_option_compatible_with_admins(option: str, argv: list) -> Tuple[bool, str]:
        """
        Checks options compatibility with admin options
        :return: Cortege (flag, message)
        flag: True/False - compatible/not compatible
        message - comment if flag is False
        """
        option_found = False
        admin_option_name = ""
        for arg in argv:
            if arg.startswith(option):
                option_found = True
                continue
            if not admin_option_name:
                for admin_option in ADMIN_ONLY_OPTIONS:
                    if arg.startswith(admin_option):
                        admin_option_name = admin_option
        if option_found and admin_option_name:
            return False, f"ERROR: option '{admin_option_name}' is not compatible with '--for-reseller'"
        return True, ""

def _perform_checks_before_docopt(self, argv: list) -> Tuple[bool, str]:
        """
        Performs checks before parsing arguments
        """
        is_compatible, message = self._is_option_compatible_with_admins("--for-reseller", argv)
        return is_compatible, message

def _perform_checks_after_docopt(self, args: dict) -> Tuple[bool, str]:
        """
        Performs checks after parsing arguments
        """
        # cloudlinux-limits set/get --json --reseller-name=reseller --for-reseller=reseller -- ERROR
        if args["--reseller-name"] and args["--for-reseller"]:
            return False, "ERROR: '--reseller-name' and '--for-reseller' cannot be used together"
        return True, ""

def _apply_docopt(self, argv: list, is_json: bool) -> Tuple[dict, str]:
        """
        Applies docopt to parse utility arguments.
        Performs checks before and after parsing
        """
        ok, message = self._perform_checks_before_docopt(argv)
        if not ok:
            return {}, message
        try:
            args = docopt(self.docstring, argv)
        except DocoptExit:
            s_error_string = "ERROR: Invalid parameter passed or required parameter is missing"
            if not is_json:
                s_error_string += "\n\n" + self.docstring
            return {}, s_error_string

ok, message = self._perform_checks_after_docopt(args)
        if not ok:
            return {}, message
        return args, ""

@staticmethod
    def _get_schema() -> Schema:
        """
        Returns schema that should be used to validate parsed arguments
        """
        return global_schema

@staticmethod
    def _validate_schema(schema: Schema, args: dict) -> Tuple[dict, str]:
        """
        Validate parsed arguments with provided schema
        """
        try:
            args = schema.validate(args)
        except SchemaError as e:
            return {}, str(e)
        return args, ""

def parse_args(self, argv: list, is_json: bool = False) -> Tuple[bool, Union[str, dict]]:
        """
        Parses and validates arguments passed to the utility
        """
        args, message = self._apply_docopt(argv, is_json)
        if not args:
            return False, message
        # if command was not specified, use `get` command
        if not any(args.get(command) for command in self.commands):
            args["get"] = True

schema = self._get_schema()
        args, message = self._validate_schema(schema, args)
        if not args:
            return False, message
        return True, args

class CloudlinuxLimitsNoLveOptsParser(CloudlinuxLimitsOptsParser):
    docstring = f"""Utility to get/set any Cloudlinux limits

Usage:
    {PROG_NAME} set [--json] (--lve-id <int> | --username <str>) (--cagefs <enabled,disabled>)
    {PROG_NAME} set [--json] (--lve-id <int> | --username <str>) (--unlimited)
    {PROG_NAME} set [--json] (--lve-id <int> | --username <str>) (--default <str>)
    {PROG_NAME} set [--json] (--lve-id <int> | --username <str>) [--inodes <N,M> --save-all-parameters]
    {PROG_NAME} [get] [--json] [--lve-id <int> | --username <str> | --domain <str>] [--limits=<keys>]
    {PROG_NAME} (-h | --help)

Options:
    --json                              Return data in JSON format.
    --lve-id <int>                      LVE id. will display record only for that LVE id.
    --username <str>                    Execute command only for specific user.
    --cagefs <enabled|disabled>         Enable or disable CageFS for a user.
    --unlimited                         Set supported limits to unlimited.
    --default [limits]                  Reset supported limits to the Package defaults.
                                        List of comma-separated limits to reset them to default or "all"
    --domain <str>                      Show data only for specific domain
    --limits <keys>                     Available keys: inodes
    --inodes <N,M>                      Set inode limits. N - soft, M - hard.
    --save-all-parameters               Save all parameters even if they match with defaults settings.
    -h, --help                          Show this help message and exit
"""

commands = ("set", "get")

def _perform_checks_before_docopt(self, argv: list) -> Tuple[bool, str]:
        # no checks to be performed
        return True, ""

def _perform_checks_after_docopt(self, args: dict) -> Tuple[bool, str]:
        # no checks to be performed
        return True, ""

@staticmethod
    def _get_schema() -> Schema:
        # limit schema to the given options only, other options are not needed
        schema_options = {"set", "get", "--json", "--lve-id", "--username", "--cagefs", "--domain",
                          "--unlimited", "--default", "--limits", "--inodes", "--save-all-parameters", "--help"}
        options = {
            option: value for option, value in global_schema.schema.items()
            if option in schema_options
        }
        return Schema(options)

def parse_args(self, argv: list, is_json: bool = False) -> Tuple[bool, Union[str, dict]]:
        ok, args = super().parse_args(argv, is_json)
        if not ok:
            return False, args
        # fill parsed arguments dictionary with params from global schema
        # using negative values (False or None)
        # do this because these parametes can be checked in the utility
        for key, value in global_schema.schema.items():
            args.setdefault(key, False if value is bool else None)
        return True, args