FM / utils

/opt/imunify360/venv/versions/imunify-core-8.12.1-2/defence360agent/utils/

/opt/imunify360/venv/versions/imunify-core-8.12.1-2/defence360agent/utils

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
antivirus_mode.py	497	0644	edit dl rm
async_utils.py	718	0644	edit dl rm
benchmark.py	538	0644	edit dl rm
buffer.py	1945	0644	edit dl rm
check_db.py	7901	0644	edit dl rm
check_lock.py	856	0644	edit dl rm
cli.py	9273	0644	edit dl rm
common.py	14757	0644	edit dl rm
completions.py	9988	0644	edit dl rm
config.py	1695	0644	edit dl rm
cronjob.py	902	0644	edit dl rm
doctor.py	5503	0644	edit dl rm
fd_ops.py	7573	0644	edit dl rm
hyperscan.py	149	0644	edit dl rm
importer.py	2722	0644	edit dl rm
ipecho.py	3247	0644	edit dl rm
json.py	953	0644	edit dl rm
kwconfig.py	1756	0644	edit dl rm
net.py	595	0644	edit dl rm
net_transport.py	12400	0644	edit dl rm
parsers.py	11879	0644	edit dl rm
resource_limits.py	5158	0644	edit dl rm
safe_fileops.py	10064	0644	edit dl rm
safe_sequence.py	363	0644	edit dl rm
serialization.py	2410	0644	edit dl rm
sshutil.py	15174	0644	edit dl rm
subprocess.py	1570	0644	edit dl rm
support.py	5329	0644	edit dl rm
threads.py	1005	0644	edit dl rm
validate.py	4375	0644	edit dl rm
whmcs.py	7784	0644	edit dl rm
wordpress_mu_plugin.py	1440	0644	edit dl rm
zipsafe.py	720	0644	edit dl rm
_shutil.py	1028	0644	edit dl rm
__init__.py	66773	0644	edit dl rm

Edit: /opt/imunify360/venv/versions/imunify-core-8.12.1-2/defence360agent/utils/resource_limits.py (5158B)

import asyncio
import logging

from contextlib import suppress
from enum import Enum
from os import fsdecode
from pathlib import Path
from typing import List, Optional, Tuple

from defence360agent.utils import OsReleaseInfo

logger = logging.getLogger(__name__)

RUN_WITH_INTENSITY = "/usr/libexec/run-with-intensity"

LVECTL_BIN_PATH = Path("/usr/sbin/lvectl")
PROC_LVE_LIST_PATH = Path("/proc/lve/list")
PROC_PATH = Path("/proc")
CGROUP_PATH = Path("/sys/fs/cgroup")

# cgroup v1 reports "no limit" as a page counter near its maximum
_CGROUP_V1_NO_LIMIT = 1 << 50

class LimitsMethod(Enum):
    NICE = "nice"
    LVE = "lve"
    CGROUPS = "cgroups"

async def get_current_method() -> LimitsMethod:
    """Returns limit method, used in run-with-intensity tool."""
    proc = await asyncio.create_subprocess_exec(
        RUN_WITH_INTENSITY,
        "show",
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE,
    )

stdout, stderr = await proc.communicate()
    stdout = fsdecode(stdout).strip()

if stdout == "nice":
        return LimitsMethod.NICE
    if stdout == "lve":
        return LimitsMethod.LVE
    if stdout == "cgroups":
        return LimitsMethod.CGROUPS
    raise LookupError(
        "Parsing of used limitation method failed\nstdout: {}\nstderr: {}"
        .format(stdout, fsdecode(stderr).strip())
    )

async def create_subprocess(
    cmd: List[str],
    key: str,
    intensity_cpu: int,
    intensity_io: int,
    **subprocess_kwargs
) -> asyncio.subprocess.Process:
    """
    Creates asyncio.Process with limited resources (cpu & io),
    using run-with-intensity tool.

:param cmd: command to execute
    :param intensity_cpu: cpu intensity limit
    :param intensity_io: io intensity limit
    :param subprocess_kwargs: keyword arguments for create_subprocess_exec func
    :return: executed Process
    """
    limits_cmd = [
        RUN_WITH_INTENSITY,
        "run",
        "--intensity-cpu",
        str(intensity_cpu),
        "--intensity-io",
        str(intensity_io),
    ]
    limits_cmd.extend(["--key", key])

return await asyncio.create_subprocess_exec(
        *(limits_cmd + cmd), **subprocess_kwargs
    )

def _status_field_kb(pid: int, field: str) -> Optional[int]:
    try:
        status = (PROC_PATH / str(pid) / "status").read_text()
    except OSError:
        return None
    for line in status.splitlines():
        name, _, value = line.partition(":")
        if name == field:
            with suppress(IndexError, ValueError):
                return int(value.split()[0])
    return None

def _child_pids(pid: int) -> List[int]:
    children: List[int] = []
    try:
        threads = sorted((PROC_PATH / str(pid) / "task").iterdir())
    except OSError:
        return children
    for thread in threads:
        try:
            listed = (thread / "children").read_text()
        except OSError:
            continue
        with suppress(ValueError):
            children.extend(int(child) for child in listed.split())
    return children

def _process_tree(pid: int) -> List[int]:
    tree, pending = [], [pid]
    while pending:
        current = pending.pop()
        tree.append(current)
        pending.extend(_child_pids(current))
    return tree

def peak_rss_kb(pid: int) -> Optional[int]:
    """Peak RSS of the process and its descendants, summed, in kB."""
    total = None
    for process in _process_tree(pid):
        peak = _status_field_kb(process, "VmHWM")
        if peak is not None:
            total = (total or 0) + peak
    return total

def _cgroup_limit_bytes(path: Path) -> Optional[int]:
    try:
        value = path.read_text().strip()
    except OSError:
        return None
    if value == "max":
        return None
    with suppress(ValueError):
        limit = int(value)
        if limit < _CGROUP_V1_NO_LIMIT:
            return limit
    return None

def memory_bound_kb(pid: int) -> Optional[Tuple[int, str]]:
    """The cgroup memory limit the process runs under, in kB, and its source."""
    try:
        cgroups = (PROC_PATH / str(pid) / "cgroup").read_text()
    except OSError:
        return None
    for line in cgroups.splitlines():
        _, _, rest = line.partition(":")
        controllers, _, cgroup = rest.partition(":")
        relative = cgroup.lstrip("/")
        if not controllers:
            limit = _cgroup_limit_bytes(CGROUP_PATH / relative / "memory.max")
            source = "cgroup v2"
        elif "memory" in controllers.split(","):
            limit = _cgroup_limit_bytes(
                CGROUP_PATH / "memory" / relative / "memory.limit_in_bytes"
            )
            source = "cgroup v1"
        else:
            continue
        if limit is not None:
            return limit // 1024, source
    return None

def is_lve_active() -> bool:
    """Checks that LVE-utils is active resource limiter."""
    # to avoid possible errors such as DEF-11941
    # make sure that OS is CL
    return PROC_LVE_LIST_PATH.exists() and OsReleaseInfo.is_cloudlinux()

def has_lvectl() -> bool:
    """Checks that LVE-utils is installed."""
    return LVECTL_BIN_PATH.exists()

cmd: