Edit

[EDIT] FILE: proctitle.py

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

import logging
import os
import pwd
import re
import time

from lvestats.lib.commons.fileutil import open_nofollow
from lvestats.lib.commons.func import get_all_user_domains, normalize_domain

class Proctitle(object):
    """
    Class for working with mod_procurl files
    """

def __init__(self, shm_dir="/dev/shm/"):
        self.now = 0
        self.log = logging.getLogger('Proctitle')
        self.SHM_DIR = shm_dir
        self.FILE_PATTERN = re.compile(r"apache_title_shm_[0-9]+_[0-9]+_[0-9]+$", re.IGNORECASE)
        self._web_server_uids = self._get_web_server_uids()
        self.parsed_data = self._get_all_data()

def _get_web_server_uids(self):
        """
        Collect UIDs of all known web server usernames.

When hostinglimits_module is enabled, SHM files may be owned by
        'nobody' even though 'apache' also exists on the system.  Returning
        only the first match would reject every file owned by 'nobody',
        silently disabling proctitle data collection.
        """
        uids = set()
        for username in ('apache', 'httpd', 'nobody'):
            try:
                uids.add(pwd.getpwnam(username).pw_uid)
            except KeyError:
                continue
        if not uids:
            self.log.warning("Cannot determine web server UID; no shm files will be processed")
        return frozenset(uids)

def _open_apache_owned(self, file_name):
        """
        Open *file_name* rejecting symlinks at every path component,
        verify ownership via fstat on the same fd, and return a file
        object ready for reading.  The caller receives the same
        underlying descriptor — no close-then-reopen — so there is
        no TOCTOU window.

:return: open file object if owned by a web server user, None otherwise
        :raises OSError: if any path component is a symlink or does not exist
        """
        fd = open_nofollow(file_name)
        try:
            if os.fstat(fd).st_uid not in self._web_server_uids:
                return None
            f = os.fdopen(fd, 'r', encoding='utf-8')
            fd = -1  # os.fdopen owns the fd now
            return f
        finally:
            if fd != -1:
                os.close(fd)

def _get_all_data(self):
        """
        1) Get all files in the self.SHM_DIR that mathes to the regexp self.FILE_PATTERN
        2) Read every file to the first \x00 simbol
        3) If apache process is iddle file content equals to httpd, else it should contain 5 values separated by space
        4) Split every interesting line and return
        :return:
        list of the lists
        [[Timestamp, Domain, Http type, Path, Http version],...]
        """
        result = []
        if os.path.exists(self.SHM_DIR):
            files = filter(self.FILE_PATTERN.search, os.listdir(self.SHM_DIR))
            self.now = time.time()
            for file in files:
                try:
                    file_name = os.path.join(self.SHM_DIR, file)
                    http_stats = self._open_apache_owned(file_name)
                    if http_stats is None:
                        continue
                    with http_stats:
                        http_stats_line = http_stats.readline()
                    http_stats_line = http_stats_line.split('\x00')[0]
                    if not http_stats_line == "httpd":
                        http_stats_line_split = http_stats_line.split(" ")
                        if len(http_stats_line_split) == 5:
                            result.append(http_stats_line_split + [file.split("_")[-3]])
                        else:
                            self.log.debug("Number of values in file %s is not equal to 5", file)
                except (IOError, OSError) as e:
                    self.log.debug(str(e))
        return result

def get_user_data(self, username):
        """
        Returns information about processed by user pages.
        :param username:
        :return:
        list of the lists
        [[Pid, Domain, Path, Http type, Http version, Time],...]
        """
        all_domains = get_all_user_domains(username)
        normalized_domains = set(map(normalize_domain, all_domains))
        result = []
        for data in self.parsed_data:
            if normalize_domain(data[1]) in normalized_domains:
                result.append([
                    data[5],
                    data[1],
                    data[2],
                    data[3],
                    data[4],
                    f"{self.now - float(data[0]):.1f}",
                ])
        return result

CANCEL