Mini Shell
# -*- coding: utf-8 -*-
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2018 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
# mysql_governor.py - module for interfacing with dbctl utility for get/set MySQL limits and user's status
import os
import xml.dom.minidom as xml
import subprocess
import json
from xml.parsers.expat import ExpatError
from typing import Tuple, Optional, Dict # NOQA
from packaging.version import Version
from clcommon.clexception import FormattedException
from clcommon.utils_cmd import run_command, ExternalProgramFailed
class GovernorStatus:
ENABLED = 'enabled'
ERROR = 'error'
DISABLED = 'disabled'
class MySQLGovException(FormattedException):
pass
class MySQLGovernorDisabled(MySQLGovException):
"""
Exception raised when dbgovernor daemon is offline
"""
def __init__(self):
super().__init__({
'message':
"%(util)s is disabled in the system. "
"Please, run \"%(command)s\" to start the service",
'context': {
'util': 'MySQL governor',
'command': 'service db_governor restart'
}
})
class MySQLGovernorAbsent(MySQLGovException):
"""
Exception raised when dbgovernor isn't installed
"""
def __init__(self):
super().__init__({
'message': "%(util)s not present in system",
'context': {'util': 'Governor'}
})
def _get_exc_message(param):
return {
'message': "Invalid %(param)s parameter",
'context': {'param': param}
}
class MySQLGovernor:
"""
MysqlGovernor library
"""
# Constants to calculate individial limits for cpu(current, short, middle period)
# and read(current, short, middle, long periods)
# cpu:
# c, s = c*95%, m = c*87%, l = c*75%
# io (read == write):
# c = io / 2, s = c*83%, m = c*76%, l = c*59%
# refer to LU-167
IO_PERCENTS = (0.83, 0.76, 0.59) # percents for calculate read/write limits
CPU_PERCENTS = (0.95, 0.87, 0.75) # percents for calculate cpu limits
_UTILITY_PATH = "/usr/sbin/dbctl"
_PACKAGE_UTILITY_PATH = "/usr/share/lve/dbgovernor/governor_package_limitting.py"
_GOVERNOR_BINARY_PATH = "/usr/sbin/db_governor"
_CONTAINER_PATH = "/etc/container/mysql-governor.xml" # available for root only
_CONTAINER_PATH_V2 = "/var/run/mysql-governor-config.xml" # available for everyone; governor-mysql >= 1.1-14
_S_DEFAULT = 'DEFAULT'
def __init__(self):
# List of ignored users in governor
self._governor_ignored_users = None
# MySQL Governor limits cache
# Dictionary format: user_name -> (cpu_limit: int, io_limit: int, cpu_limit_marked: str, io_limit_marked: str)
# cpu_limit: int, io_limit: int - "old" limits, without package differs marks. For backward compatibility
# Both are integers always, IO limit - KB/s
# cpu_limit_marked: str, io_limit_marked: str - "new" limits, with package differs marks.
# Both are strings always, IO limit - KB/s
# Examples: (150, 3072, '150', '3072'), (200, 3072, '*200', '3072'), etc
self._governor_limits = None
# Error flag
self._is_governor_error = False
# MySQL Governor presence flag
self._is_governor_present = os.path.isfile(self._UTILITY_PATH)
self._governor_mode = self._detect_governor_mode()
self._governor_version = self.get_governor_version()
def get_governor_mode(self):
return self._governor_mode
def _detect_governor_mode(self):
if self._is_governor_present:
try:
governor_cfg = self._get_xml_config()
return governor_cfg.getElementsByTagName('lve')[0].getAttribute('use')
except (MySQLGovException, IndexError):
return None
else:
return None
def _run_dbctl_with_args(self, args, check_exit_code=False):
"""
Run dbctl utility with given arguments and handle common errors:
- governor is down: MySQLGovernorDisabled
:param check_exit_code: whether we should raise exception
when dbctl returs code != 0
"""
ret_code, std_out, std_err = run_command(
[self._UTILITY_PATH] + list(args),
return_full_output=True)
if "can't connect to socket" in std_out:
# Governor not started
self._is_governor_error = True
self._governor_limits = None
self._governor_ignored_users = None
raise MySQLGovernorDisabled()
elif check_exit_code and (ret_code or std_err):
raise MySQLGovException({'message': "dbctl error: %(output)s",
'context': {'output': std_err}})
return ret_code, std_out, std_err
def get_governor_status(self):
# type: () -> Tuple[str, Optional[MySQLGovException]]
return self._detect_governor_status()
def _detect_governor_status(self):
# type: () -> Tuple[str, Optional[MySQLGovException]]
if self.is_governor_present():
try:
self._load_info()
except MySQLGovException as e:
return GovernorStatus.ERROR, e
except ExternalProgramFailed as e:
return GovernorStatus.ERROR, MySQLGovException({
'message': str(e)
})
else:
return GovernorStatus.ENABLED, None
return GovernorStatus.DISABLED, None
def _get_xml_config(self):
# type: () -> xml.Document
config_path = self._get_config_path()
try:
with open(config_path, 'r', encoding='utf-8') as f:
return xml.parseString(f.read())
except (IOError, OSError) as e:
self._is_governor_error = True
raise MySQLGovException(
{'message': "An error occured while loading governor "
"config from %(path)s. Error: %(error)s",
'context': {'path': config_path, 'error': str(e)}}
) from e
except ExpatError as e:
self._is_governor_error = True
raise MySQLGovException(
{'message': "An error occured while parsing governor "
"config from %(path)s. Error: %(error)s",
'context': {'path': config_path, 'error': str(e)}}
) from e
@staticmethod
def _load_ignore_users_from_xml(governor_cfg):
"""
Loads information about igrored users
:type governor_cfg: xml.Document
:return: list of ignore users
"""
ignore_users_list = []
try:
gov_data = governor_cfg.getElementsByTagName("governor")[0]
except IndexError as e:
raise MySQLGovException({
'message': 'Malformed mysql-governor config. '
'Unable to find element \'%(element)s\'.',
'context': {'element': 'governor'}
}) from e
users_data_list = gov_data.getElementsByTagName("user")
for user_data in users_data_list:
user_mode = user_data.getAttribute("mode")
if user_mode == "ignore":
# ignore_users_list.append(user_data.getAttribute("mysql_name"))
# ignore only system users
if user_data.getAttribute("name"):
ignore_users_list.append(user_data.getAttribute("name"))
return ignore_users_list
def _calc_rw_io_limits(self, io):
"""
Calculate db R/W IO limits based on governor version
:param io: requested limits in MB/s
:return: string values suitable to pass to "dbctl set ..."
"""
# Only Governor >= 1.2-18 has support for limits in bytes
# This check should be removed when new Governor will be in stable repo
if self._is_governor_newer_then('1.2-17'):
io_limits = io * 2 ** 20 # MB to Bytes
limits_tmpl = "%sb,%sb,%sb,%sb"
else:
io_limits = io # Use MBytes as is
if io_limits == 1:
# This should prevent dropping to defaults even for old
# Governor, and just set 1MB instead
io_limits = 2
limits_tmpl = "%s,%s,%s,%s"
read = limits_tmpl % self._percentage(int(io_limits // 2),
self.IO_PERCENTS)
write = limits_tmpl % self._percentage(int(io_limits // 2),
self.IO_PERCENTS)
return read, write
def get_governor_version(self):
if not self.is_governor_present():
return None
try:
res = subprocess.check_output([self._GOVERNOR_BINARY_PATH, '--version'], text=True)
# example of valid output
# res = 'governor-mysql version 1.2-36'
version = res.strip().split(' ')[2]
return version
except (subprocess.CalledProcessError, OSError):
return None
def _is_governor_newer_then(self, version):
current = self._governor_version
if not current:
return False # assume "No" if we can't determine version
return Version(version) < Version(current)
@staticmethod
def _parse_line(line):
"""
Convert data line from dbctl to list
:param line:
Data line could be like:
"default\t400/380/350/300\t953/791/724/562\t953/791/724/562"
or:
"default 400/380/350/300 1000/830/760/590 1000/830/760/590"
depending on --kb/mb/bb option passed to dbctl
:return: list: ['default', '400/380/350/300', '953/791/724/562', '953/791/724/562']
"""
return [part for part in line.split() if part]
@staticmethod
def _percentage(value, percents):
"""
Calculate full list of governor limits by one value and percents koeff
"""
res = [value]
for k in percents:
res.append(int(value*k))
return tuple(res)
def is_governor_present(self):
"""
Get governor presence flag
:return:
"""
return self._is_governor_present
def get_governor_status_by_username(self, username):
"""
Get MySQL governor status for supplied user
:param username: Username for get status
:return: Governor status: "watched"/"ignored" or None if error
"""
# Load Governor data
self._load_info()
if username in self._governor_ignored_users:
return 'ignored'
return 'watched'
def get_limits_by_user(self, username, with_package_mark: bool = False) -> Tuple[int, int]:
"""
Get MySQL governor limits for supplied user
:param username: Username for read limits
:param with_package_mark: False - without package limits difference mark (for compatibility with non-package
governor, used in cloudlinux-top/cloudlinux-statistics),
True - with package limits difference mark
:return: Tuple (CPU limit, IO limit).
Examples:
(150, 3072) - with_package_mark == False
('*150', '3072') - with_package_mark == True
('*150', '*4096') - with_package_mark == True
* - user has individual limits, differ from package limit
MySQLGovException will be thrown if governor not present or error
"""
# Load Governor data if need
self._load_info()
if username in self._governor_limits:
user_cpu_limit, user_io_limit_kb, user_cpu_limit_marked, user_io_limit_marked =\
self._governor_limits[username]
else:
user_cpu_limit, user_io_limit_kb, user_cpu_limit_marked, user_io_limit_marked = \
self._governor_limits['default']
if with_package_mark:
limits_for_return = (user_cpu_limit_marked, user_io_limit_marked)
else:
limits_for_return = (user_cpu_limit, user_io_limit_kb)
return limits_for_return
def set_governor_status_for_user(self, username, status):
"""
Set MySQLGovernor status for single user
:param: `str` username: Username for set status
:param: `bool` status: True for "monitor", False for "ignore"
:return: `bool`: operation status result
"""
self._load_info()
status_cmd = "monitor" if status else "ignore"
ret, std_out, std_err = self._run_dbctl_with_args([status_cmd, username])
if std_err or ret:
exc_message = {'message': "Set governor status error(%(ret)s): %(output)s",
'context': {'ret': ret, 'output': std_err or std_out}}
raise MySQLGovException(exc_message)
return 0
def set_restricted_status_for_user(self, username, status):
"""
Set user restricted with dbctl utility
:param: `str` username: Username for set restricted status
:param: `bool` status: True for "restricted", False for "unrestricted"
:return: `bool`: operation status result
"""
self._load_info()
status_cmd = "restrict" if status else "unrestrict"
if username in ["root", "admin"]:
username = "default"
ret, std_out, std_err = self._run_dbctl_with_args([status_cmd, username])
if std_err or ret:
exc_message = {'message': "Set user restrict error(%(ret)s): %(output)s",
'context': {'ret': ret, 'output': std_err or std_out}}
raise MySQLGovException(exc_message)
return 0
def set_unrestricted_status_for_all_users(self):
"""
Set user restricted with dbctl utility
:return: `bool`: operation status result
"""
self._load_info()
ret, std_out, std_err = self._run_dbctl_with_args(["unrestrict-all"])
if std_err or ret:
exc_message = {'message': "Set all users unrestrict status error(%(ret)s): %(output)s",
'context': {'ret': ret, 'output': std_err or std_out}}
raise MySQLGovException(exc_message)
return 0
def get_restrict_status_by_username(self, username):
"""
Get MySQL governor status for supplied user
:param username: Username for get status
:return: Governor restricted status: "restricted"/"unrestricted"
"""
# Load Governor data
self._load_info()
if username in ["root", "admin"]:
username = "default"
if username in self._governor_restricted_users:
return 'restricted'
return 'unrestricted'
def set_limits_for_user(self, username, cpu=None, io=None):
# this function interface for full edit mode
# def set_limits_for_user(self, username, cpu=None, io=None, read=None,
# write=None):
"""
Set MySQLGovernor limits for user
:param: username `str`: username for set limits
:param: `int`|`list` cpu: governor cpu limit. when it param int -
calculate by percentage other params
:param: `int`|`list` io: io value means that read and write limits similar
:param: `int`|`list` read: read limit
:param: `int`|`list` write: write limit
:return: 0
"""
if cpu is None and io is None: # and read is None and write is None:
return 0
self._load_info()
cmd = ["set", username]
if cpu is not None:
if isinstance(cpu, int):
cpu = ",".join(map(str, self._percentage(cpu, self.CPU_PERCENTS)))
else:
raise MySQLGovException(_get_exc_message('cpu'))
# uncomment this lines for add full edit mode
# elif isinstance(cpu, (list, tuple)) and len(cpu) == 4:
# cpu = ",".join(map(str, cpu))
# else:
# raise MySQLGovException(_get_exc_message('cpu'))
cmd.append(f"--cpu={cpu}")
if io is not None:
# uncomment this line for add full edit mode
# if io is not None or read is not None or write is not None:
if isinstance(io, int):
read, write = self._calc_rw_io_limits(io)
else:
raise MySQLGovException(_get_exc_message('io'))
# uncomment this lines for add full edit mode
# elif isinstance(io, (list, tuple)) and len(io) == 4:
# read = write = ",".join(map(str, io))
# else:
# if isinstance(read, int):
# read = "%s,%s,%s,%s" % (read, read*0.83, read*0.76, read*0.59)
# elif isinstance(read, (list, tuple)) and len(read) == 4:
# read = ",".join(map(str, read))
# if isinstance(write, int):
# write = "%s,%s,%s,%s" % (write, write*0.83, write*0.76, write*0.59)
# elif isinstance(write, (list, tuple)) and len(write) == 4:
# write = ",".join(map(str, write))
# else:
# raise MySQLGovException(_get_exc_message('limit'))
cmd.append(f"--read={read}")
cmd.append(f"--write={write}")
try:
ret, std_out, std_err = self._run_dbctl_with_args(cmd)
except ExternalProgramFailed as e:
raise MySQLGovException(str(e)) from e
if std_err or ret:
exc_message = {'message': "Set all users unrestrict status error(%(ret)s): %(output)s",
'context': {'ret': ret, 'output': std_err or std_out}}
raise MySQLGovException(exc_message)
# Reset users limits cache
self._governor_limits = None
return 0
def _get_package_raw_limits_from_utility(self, package_name: Optional[str]) -> dict:
"""
Retrieve MySQL Governor package limits
:param package_name: Package name. If None, get all packages name
:return: Dict with limits. Example:
{'pack1': {'cpu': 100, 'io': 900}, 'pack2': {'cpu': 100, 'io': 900}}
"""
if package_name:
cmd_list = [self._PACKAGE_UTILITY_PATH, 'get',
f"--package={package_name.encode().decode('unicode-escape')}",
'--format=kb']
else:
cmd_list = [self._PACKAGE_UTILITY_PATH, 'get', '--all', '--format=kb']
ret_code, std_out, std_err = run_command(cmd_list, return_full_output=True)
if ret_code != 0 or std_err:
raise MySQLGovException({
'message': "'%(cmd)s' failed, stderr is: %(stderr)s",
'context': {'cmd': ' '.join(cmd_list), 'stderr': std_err}
})
try:
package_data_from_util = json.loads(std_out)
except (json.JSONDecodeError, ) as e:
raise MySQLGovException({
'message': "%(util)s output invalid, error is: %(error)s",
'context': {'util': self._PACKAGE_UTILITY_PATH, 'error': str(e)}
}) from e
return package_data_from_util
def _calc_package_limits_from_raw(self, cpu_limits_list: list, read_limits_list: list,
write_limits_list: list) -> Tuple[int, int]:
"""
Calculate package limits from raw governor limits
:param cpu_limits_list: CPU limits list
:param read_limits_list: Read limits list
:param write_limits_list: Write limits list
:return: Tuple: (cpu_limit, io_limit)
"""
return int(cpu_limits_list[0]), self._get_user_io_limit(str(read_limits_list[0]), str(write_limits_list[0]))
def get_package_limits(self, package_name: Optional[str] = None) -> Optional[Dict]:
"""
Retrieve MySQL Governor package limits
:param package_name: Package name. If None, get all packages name
:return: Dict with limits. Example:
{'pack1': {'cpu': 100, 'io': 900}, 'pack2': {'cpu': 100, 'io': 900}}
"""
try:
package_data_from_util = self._get_package_raw_limits_from_utility(package_name)
except MySQLGovException: # pylint: disable=try-except-raise
raise
# Convert limits from governor
packages_data = {}
for pack_name, pack_limits in package_data_from_util.items():
cpu_limit, io_limit = self._calc_package_limits_from_raw(pack_limits['cpu'], pack_limits['read'],
pack_limits['write'])
packages_data[pack_name] = {'cpu': cpu_limit, 'io': io_limit}
return packages_data
def reset_user_limits_to_defaults(self, username: str, limit_names: list):
"""
Reset users limits to default
:param username: User name ro reset limits
:param limit_names: Limit names list to reset
"""
# /usr/share/lve/dbgovernor/governor_package_limitting.py reset_individual \
# --user=res1 --limits=mysql-cpu,mysql-io
limits_string = ','.join(limit_names)
cmd_list = [self._PACKAGE_UTILITY_PATH, 'reset_individual', f'--user={username}',
f'--limits={limits_string}']
ret_code, _, std_err = run_command(cmd_list, return_full_output=True)
# For reliability we check both retcode and std_err
if ret_code != 0 or std_err:
raise MySQLGovException({
'message': "'%(cmd)s' is failed, stderr is: %(stderr)s",
'context': {'cmd': ' '.join(cmd_list), 'stderr': std_err}
})
def _set_governor_limits_to_cpanel_package( # pylint: disable=too-many-branches
self,
package_name: str,
cpu_limit: Optional[int],
io_limit: Optional[int]
):
"""
Set MySQL Governor to cPanel package file. If limits not changed, package file will not be written
:param package_name: Package name
:param cpu_limit: MySQL CPU limit to set
:param io_limit: MySQL IO limit to set
"""
from clcommon.utils import get_file_lines, write_file_lines # pylint: disable=import-outside-toplevel
package_path = f'/var/cpanel/packages/{package_name}'
try:
cpanel_package_lines = get_file_lines(package_path)
except (OSError, IOError, ):
return
if len(cpanel_package_lines) == 0:
return
lines_to_write = []
is_change_made = False
# Find and change limit lines:
# lve_mysql_cpu=4000
# lve_mysql_io=4096
for line in cpanel_package_lines:
if line.startswith('lve_mysql_cpu') and cpu_limit is not None:
parts = line.strip().split('=')
if len(parts) != 2:
continue
if cpu_limit == 0:
s_cpu_limit = self._S_DEFAULT
else:
s_cpu_limit = str(cpu_limit)
s_old_cpu_limit = parts[1].strip()
if s_old_cpu_limit != s_cpu_limit:
lines_to_write.append(f'lve_mysql_cpu={s_cpu_limit}\n')
is_change_made = True
else:
# MYSQL CPU limit unchanged, save old line
lines_to_write.append(f'{line}\n')
elif line.startswith('lve_mysql_io') and io_limit is not None:
if io_limit == 0:
s_io_limit = self._S_DEFAULT
else:
s_io_limit = str(io_limit)
parts = line.strip().split('=')
if len(parts) != 2:
continue
value = parts[1].strip()
if value != s_io_limit:
lines_to_write.append(f'lve_mysql_io={s_io_limit}\n')
is_change_made = True
else:
# MYSQL IO limit unchanged, save old line
lines_to_write.append(f'{line}\n')
else:
lines_to_write.append(line)
if is_change_made:
write_file_lines(package_path, lines_to_write, 'w')
def _apply_package_limits_to_cpanel(self, package_name: str, cpu_limit: Optional[int], io_limit: Optional[int]):
"""
Apply all MySQL Governor packages limits to cpanel package file. In not cPanel, do nothing
:param package_name: Package name to update
:param cpu_limit: MySQL CPU limit to set, None - not change
:param io_limit: MySQL IO limit to set, None - not change
"""
from clcommon.cpapi import getCPName # pylint: disable=import-outside-toplevel
if getCPName() != 'cPanel':
return
self._set_governor_limits_to_cpanel_package(package_name, cpu_limit, io_limit)
def set_package_limits(self, package_name: str, cpu_limit: Optional[int] = None,
io_limit: Optional[int] = None):
"""
Set limits for Governor package
:param package_name: Package name for set
:param cpu_limit: MySQL CPU limit to set
:param io_limit: MySQL CPU limit to set
"""
# Argument validation
# /usr/share/lve/dbgovernor/governor_package_limitting.py set --package pack2 --cpu=200,201,202,203
# --read=500,501,502,503 --write=400,401,402,403
if package_name is None or cpu_limit is None and io_limit is None:
raise MySQLGovException("MySQLGovernor.set_package_limits arguments error: "
"Package name and at least one limit "
f"should be provided. Current arguments: package name: {package_name}; "
f"cpu limit is {cpu_limit}; IO limit is {io_limit};")
cmd_list = [self._PACKAGE_UTILITY_PATH, 'set', '--package', package_name]
# Check arguments and prepare command line parameters for governor utility
if cpu_limit is not None:
if isinstance(cpu_limit, int):
cpu = ",".join(map(str, self._percentage(cpu_limit, self.CPU_PERCENTS)))
else:
raise MySQLGovException(_get_exc_message('cpu_limit'))
cmd_list.append(f"--cpu={cpu}")
if io_limit is not None:
if isinstance(io_limit, int):
read, write = self._calc_rw_io_limits(io_limit)
else:
raise MySQLGovException(_get_exc_message('io_limit'))
cmd_list.append(f"--read={read}")
cmd_list.append(f"--write={write}")
ret_code, std_out, std_err = run_command(cmd_list, return_full_output=True)
if ret_code != 0 or std_err:
raise MySQLGovException({
'message': "'%(command)s' is failed, stdout is: '%(stdout)s', stderr is: '%(stderr)s'",
'context': {'command': ' '.join(cmd_list), 'stdout': std_out, 'stderr': std_err}
})
# Apply limits to cPanel package
self._apply_package_limits_to_cpanel(package_name, cpu_limit, io_limit)
def _get_config_path(self):
"""
Get config path for mysql-governor;
:rtype: str|None
"""
if os.path.isfile(self._CONTAINER_PATH_V2):
return self._CONTAINER_PATH_V2
return self._CONTAINER_PATH
def _read_ignore_users(self):
"""Load ignore users list from container file"""
try:
governor_xml = self._get_xml_config()
self._governor_ignored_users = \
self._load_ignore_users_from_xml(governor_xml)
except MySQLGovException:
self._governor_limits = None
self._governor_ignored_users = None
raise
def _load_info(self):
"""
Loads users info from MySQL governor
:return: None
"""
# Exit if governor data already loaded
if self._governor_ignored_users is not None and self._governor_limits is not None:
return
# Exit if governor not present
if not self._is_governor_present:
self._is_governor_error = True
raise MySQLGovernorAbsent()
utility_exc_message = {'message': "%(utility)s output is invalid",
'context': {'utility': self._UTILITY_PATH}}
self._read_ignore_users()
# Load governor limits
is_kb_limits_ok, gov_data_str = self._run_dbctl_list()
_, gov_restricted_str, _ = \
self._run_dbctl_with_args(['list-restricted'], check_exit_code=True)
self._governor_restricted_users = [
line.split()[0] for line in gov_restricted_str.strip().split('\n')[1:]
]
# Parse dbctl output
gov_data_lines = gov_data_str.split('\n')
self._governor_limits = self._parse_dbctl_data_lines(gov_data_lines, is_kb_limits_ok, utility_exc_message)
# Check default settings presence
if 'default' not in self._governor_limits:
self._is_governor_error = True
self._governor_limits = None
self._governor_ignored_users = None
exc_message = {
'message': "There is no %(what)s found in %(where)s",
'context': {'what': 'default settings', 'where': f'{self._UTILITY_PATH} output'}
}
raise MySQLGovException(exc_message)
@staticmethod
def _get_user_io_limit(read_limit: str, write_limit: str):
"""
Calculates the io limit.
Handles the situation when user's write or read io limit is less than 1mb/s (PTCLLIB-85).
:type write_limit: str
:type read_limit: str
:rtype: int
"""
try:
user_io_limit = int(read_limit) + int(write_limit)
except ValueError:
if read_limit == write_limit == "<1":
user_io_limit = 1
elif write_limit == "<1":
user_io_limit = int(read_limit)
else:
user_io_limit = int(write_limit)
return user_io_limit
def _run_dbctl_list(self, _is_incorrect_syntax=False):
"""
Executes dbctl list-marked --kb or dbctl list-marked
:param _is_incorrect_syntax: True is emulate dbctl error. Only for testing!
:return: Cortege (is_kb_limits_ok, stdout_str), where
is_kb_limits_ok == True, if dbctl returned limits in KB, else - False
stdout_str - dbctl stdout string
"""
ret_code, gov_data_str, _ = self._run_dbctl_with_args(
['list-marked', '--kb'], check_exit_code=True)
# Check is KB limits supported
is_kb_limits_ok = True
if _is_incorrect_syntax or 'Incorrect syntax' in gov_data_str:
# --kb option not supported, call without it
_, gov_data_str, _ = self._run_dbctl_with_args(
['list'], check_exit_code=True)
is_kb_limits_ok = False
return is_kb_limits_ok, gov_data_str
def _parse_dbctl_data_lines(self, data_lines_list, is_kb_limits_ok: bool, utility_exc_message: dict) -> dict:
"""
Converts data lines from dbctl stdout to dictionary
:param data_lines_list: List of lines from dbctl stdout
:param is_kb_limits_ok: Is limits already in KB/s
:param utility_exc_message: Message dict for exception
:return: Tuple(dict, dict) dbctl data dictionary. Example:
{'default': (400, 1953124, '400', '1953124'),
'cltest1': (350, 2025138, '*350', '2025138')
}
"""
governor_limits = {}
for line in data_lines_list:
line = line.strip()
# Pass header line and empty lines
if not line or 'cpu(%)' in line:
continue
# List: [0] - username, [1] - CPU limits, [2] - read limits, [3] - write limits, [4] - package limits marks
user_limits_list = MySQLGovernor._parse_line(line)
# Data format verification
if len(user_limits_list) != 5 or len(user_limits_list[4]) != 2:
self._is_governor_error = True
self._governor_limits = None
self._governor_ignored_users = None
raise MySQLGovException(utility_exc_message)
cpu_limits_list = user_limits_list[1].split('/') # '400/380/350/300'
read_limits_list = user_limits_list[2].split('/') # '1000/830/760/590'
write_limits_list = user_limits_list[3].split('/') # '1000/830/760/590'
if len(cpu_limits_list) != 4 or len(read_limits_list) != 4 or len(write_limits_list) != 4:
self._is_governor_error = True
self._governor_limits = None
self._governor_ignored_users = None
raise MySQLGovException(utility_exc_message)
user_name = user_limits_list[0]
# Determine CPU limit as [0] limit
user_cpu_limit = int(cpu_limits_list[0])
# Determine IO limit as read_limit[0] + write_limit[0]
user_io_limit = self._get_user_io_limit(read_limits_list[0], write_limits_list[0])
# limit if is_kb_limits_ok else limit*1024
user_io_limit_kb = user_io_limit if is_kb_limits_ok else user_io_limit*1024
# Process package differ marks
# Package limits marks are placed in user_limits_list[4] and shows as '+-' (for example)
# There are 2 marks always, each or '-' or '+'
# 1st mark - CPU limit
# 2nd mark - IO limit
# If mark is '-' - package limit, if '+' - individual (should be marked by '*')
marks = user_limits_list[4]
if marks[0] == '+':
user_cpu_limit_marked = f'*{cpu_limits_list[0]}'
else:
user_cpu_limit_marked = cpu_limits_list[0]
if marks[1] == '+':
user_io_limit_marked = f'*{user_io_limit_kb}'
else:
user_io_limit_marked = str(user_io_limit_kb)
# Add limits to dictionary
governor_limits[user_name] = (user_cpu_limit, user_io_limit_kb, user_cpu_limit_marked, user_io_limit_marked)
return governor_limits
Zerion Mini Shell 1.0