# 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
from collections import namedtuple
from typing import Tuple, Optional, Type, List, Iterator # NOQA
from lxml import etree # NOQA
from clcommon.clpwd import ClPwd
from .ve_config import get_xml_config_etree
Limits = namedtuple('Limits', ['cpu', 'ncpu', 'io', 'vmem', 'pmem', 'nproc', 'ep', 'iops'])
InheritedLimits = namedtuple('InheritedLimits', ['cpu', 'ncpu', 'io', 'vmem', 'pmem', 'nproc', 'ep', 'iops'])
EMPTY_LIMITS = Limits(
None, None, None, None, None, None, None, None
)
# users whose owner is admin we mark with owner='root'
# in order to simplify matching user<->package
# let's use owner='root' for admin packages too
DEFAULT_PROVIDER = 'root'
class XmlConfigReader:
"""
This class parses our xml into user-friendly primitive
structures (dicts, tuples, namedtuples)
This class may do:
- data conversion (cpu & ncpu in config -> speed)
- validation
This class should NOT:
- take care of user/package/reseller existence
- write anything to xml
"""
def __init__(self, _xml_config_etree=None):
self.clpwd = ClPwd()
if _xml_config_etree is None:
self._xml_config = get_xml_config_etree()
else:
self._xml_config = _xml_config_etree
self._users_map = dict(self._users_limits())
self._packages_map = dict(self._packages_limits())
self._resellers_limits_map = dict(self._resellers_limits())
self._resellers_defaults_map = dict(self._resellers_defaults())
def version(self):
# type: () -> int
return int(self._xml_config.find('version').text)
def defaults(self):
# type: () -> Limits
return self._parse_limits_section(
self._xml_config.find('defaults'))
@staticmethod
def _get_attribute_by_xpath_or_none(element, xpath, type_=int):
# type: (etree.ElementBase, str, Type) -> Optional[object]
try:
value, = element.xpath(xpath)
return type_(value)
except (AttributeError, ValueError):
return None
@classmethod
def _parse_limits_section(cls, element):
# type: (etree.ElementBase) -> Limits
return Limits(
cpu=cls._get_attribute_by_xpath_or_none(element, 'cpu/@limit', str),
ncpu=cls._get_attribute_by_xpath_or_none(element, 'ncpu/@limit'),
io=cls._get_attribute_by_xpath_or_none(element, 'io/@limit'),
vmem=cls._get_attribute_by_xpath_or_none(element, 'mem/@limit'),
pmem=cls._get_attribute_by_xpath_or_none(element, 'pmem/@limit'),
nproc=cls._get_attribute_by_xpath_or_none(element, 'nproc/@limit'),
ep=cls._get_attribute_by_xpath_or_none(element, 'other/@maxentryprocs'),
iops=cls._get_attribute_by_xpath_or_none(element, 'iops/@limit'),
)
def get_user_limits(self, user_id):
# type: (int) -> Limits
return self._users_map.get(user_id)
def get_package_limits(self, name, owner=DEFAULT_PROVIDER):
# type: (str, str) -> Limits
return self._packages_map.get((name, owner))
def get_reseller_default_limits(self, name):
# type: (str) -> Limits
return self._resellers_defaults_map.get(name)
def get_reseller_limits(self, name):
# type: (str) -> Limits
return self._resellers_limits_map.get(name)
def users_lve_ids(self):
# type: () -> List[int]
result = []
for lve in self._xml_config.findall('lve'):
# lve tag has user attribute instead id attribute if use command lvectl --save-username
if lve.get('id') is None:
try:
result.append(self.clpwd.get_uid(lve.get('user')))
except self.clpwd.NoSuchUserException:
# We skip limits record with attribute `user`
# if that user isn't exists in system
pass
else:
result.append(int(lve.get('id')))
return result
def _users_limits(self):
# type: () -> Tuple[int, Limits]
for lve in self._xml_config.findall('lve'):
uid = lve.get('id')
uid = self.clpwd.get_uid(lve.get('user')) if uid is None else int(uid)
limits = self._parse_limits_section(lve)
yield uid, limits
def _packages_limits(self):
# type: () -> Tuple[Tuple[str, str], Limits]
ve_package = self._xml_config.findall("package")
for package in ve_package:
name = package.get('id')
owner = package.get('reseller') or None
limits = self._parse_limits_section(package)
yield (name, owner or DEFAULT_PROVIDER), limits
def _resellers_limits(self):
# type: () -> Tuple[str, Limits]
ve_reseller = self._xml_config.findall('reseller')
for reseller in ve_reseller:
name = reseller.get('user')
limits = self._parse_limits_section(reseller)
yield (name, limits)
def _resellers_defaults(self):
# type: () -> Tuple[str, Limits]
ve_defaults = self._xml_config.findall('reseller/defaults')
for defaults in ve_defaults:
name = defaults.find('..').get('user')
defaults = self._parse_limits_section(defaults)
yield (name, defaults)
|