AlkantarClanX12
Your IP : 3.147.78.242
# -*- coding: utf-8 -*-
# lve_stats2_reseller_lib.py - lve-stats reseller library for cloudlinux-config library
# 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 os
import subprocess
from clcommon.utils import mod_makedirs
from . import lve_stats2_lib
from .clconfig_utils import (
boolean_to_yes_no,
is_positive_int,
min_num_notify_converter,
repack_dict,
str_to_boolean,
time_convertor_to_dict,
time_unit_to_letter,
)
from .lve_stats2_lib import LveStats2Exception, StatsNotifierConfig, StatsNotifierDir, faults_dict
ResellerStatsNotifierDir = StatsNotifierDir + '/resellers.d/'
reseller_notify_dict = {
'NOTIFY_RESELLER_ON_TOTAL_FAULTS': 'notifyReseller',
'NOTIFY_RESELLER_ON_CUSTOMERS_FAULTS': 'notifyResellerOnCustomers',
'NOTIFY_CUSTOMERS_ON_FAULTS': 'notifyCustomers'
}
reseller_number_notify_dict = {
'NOTIFY_MIN_FAULTS_RESELLER': 'reseller',
'NOTIFY_MIN_FAULTS_CUSTOMER': 'customer'
}
reseller_notify_time_dict = {
'NOTIFY_INTERVAL_RESELLER': 'reseller',
'NOTIFY_INTERVAL_CUSTOMER': 'customer'
}
# For unit tests
def _open(file_name, mode='r'):
return open(file_name, mode=mode, encoding='utf-8')
def _create_default_reseller_config():
"""
Creates default StatsNotifier config for reseller
"""
admin_config = lve_stats2_lib.get_notification().get('faultsNotification')
admin_faults = {key: admin_config['faultsToInclude'][key] for key in (
'mem', 'iops', 'io', 'nproc', 'concurrentConnections', 'cpu'
)}
return {'faultsNotification':
{'notifyResellerOnCustomers': admin_config['notifyResellers'],
'minimumNumberOfFaultsToNotify': {
'reseller': admin_config['minimumNumberOfFaultsToNotify']['admin'],
'customer': admin_config['minimumNumberOfFaultsToNotify']['user']},
'notifyReseller': admin_config['notifyResellers'],
'notify': {'reseller': {'unitOfTime': admin_config['notify']['admin']['unitOfTime'],
'period': admin_config['notify']['admin']['period']},
'customer': {'unitOfTime': admin_config['notify']['user']['unitOfTime'],
'period': admin_config['notify']['user']['period']}
},
'faultsToInclude': admin_faults,
'notifyCustomers': admin_config['notifyResellerCustomers']
}}
def get_notification(reseller, defaults=False):
"""
Retrieves lve-stats2 notifications parameters for resellers
:param bool defaults: True if we want get defaults when config is not set, else False
:param str reseller: reseller name, if we want notifications parameters for a reseller
:return: dict. For example:
{'faultsNotification': {'notifyResellerCustomers': True,
'notifyResellers': True,
'minimumNumberOfFaultsToNotify': {'admin': 0, 'user': 0},
'notifyAdmin': True,
'notify': {'admin': {'unitOfTime': 'hours', 'period': 12},
'user': {'unitOfTime': 'hours', 'period': 12}
},
'faultsToInclude': {'mem': True, 'iops': False, 'io': False,
'nproc': False, 'concurrentConnections': False,
'cpu': True},
'notifyCustomers': False
}
}
"""
if reseller is None:
raise ValueError('reseller can`t be None')
config_path = os.path.join(ResellerStatsNotifierDir, f"{reseller}_StatsNotifier.cfg")
if not os.path.exists(config_path):
return _create_default_reseller_config() if defaults else {}
try:
f = _open(config_path)
config = f.readlines()
f.close()
except (IOError, OSError) as e:
raise LveStats2Exception({'message': "%(lvestats_cfg)s read error: " + str(e),
'context': {'lvestats_cfg': config_path}}) from e
config_dict = {}
for line in config:
if line.startswith('#') or line.strip() == '':
continue
key, value = line.split('=')
config_dict[key] = value.strip()
notify_d = reseller_notify_dict
faults_d = faults_dict
number_notify_d = reseller_number_notify_dict
notify_time_d = reseller_notify_time_dict
faults_notification_dict = repack_dict(notify_d, config_dict, str_to_boolean)
faults_include_dict = repack_dict(faults_d, config_dict, str_to_boolean)
min_num_notify = repack_dict(number_notify_d, config_dict, min_num_notify_converter, default=1)
period_notify = repack_dict(notify_time_d, config_dict, time_convertor_to_dict)
faults_notification_dict['faultsToInclude'] = faults_include_dict
faults_notification_dict['minimumNumberOfFaultsToNotify'] = min_num_notify
faults_notification_dict['notify'] = period_notify
return {"faultsNotification": faults_notification_dict}
def set_notification(parameters_dict, reseller):
"""
Sets lve-stats2 notifications parameters
:param parameters_dict: Parametres to set. For example:
{u'notifyResellers': True,
u'faultsToInclude': {u'mem': True, u'iops': False, u'io': False, u'nproc': False,
u'concurrentConnections': False, u'cpu': True},
u'minimumNumberOfFaultsToNotify': {u'admin': 0, u'user': 0},
u'notifyAdmin': True,
u'notify': {u'admin': {u'unitOfTime': u'hours', u'period': 12},
u'user': {u'unitOfTime': u'hours', u'period': 12}
},
u'notifyResellerCustomers': True,
u'notifyCustomers': False
}
:param str reseller: either reseller name or None
"""
# Do nothing, if admin's lvestats2 notifier config not found
# either parameters_dict is empty and we shouldn't change anything
if not os.path.exists(StatsNotifierConfig) or len(parameters_dict) == 0:
return
notifier_params = {}
if reseller is None:
raise ValueError('reseller can`t be None')
config_path = os.path.join(ResellerStatsNotifierDir, f"{reseller}_StatsNotifier.cfg")
if not os.path.exists(config_path):
notifier_params.update(_create_default_reseller_config())
else:
notifier_params.update(get_notification(reseller=reseller))
# create directory and empty config if not exists
if not os.path.exists(os.path.dirname(config_path)):
mod_makedirs(os.path.dirname(config_path), 0o755)
if not os.path.exists(config_path):
_open(config_path, 'w').close()
# Read notifier config
try:
f = _open(config_path)
config_lines = [line.strip() for line in f.readlines()]
f.close()
except (IOError, OSError) as e:
raise LveStats2Exception({'message': "%(lvestats_cfg)s read error: " + str(e),
'context': {'lvestats_cfg': StatsNotifierConfig}}) from e
# Fill parameters to change lve-stats config
faults_config_map = {'NOTIFY_CPU': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/cpu'),
'NOTIFY_NPROC': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/nproc'),
'NOTIFY_IO': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/io'),
'NOTIFY_MEMORY': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/mem'),
'NOTIFY_EP': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/concurrentConnections'),
'NOTIFY_IOPS': (lambda x: boolean_to_yes_no(x), 'faultsToInclude/iops')}
faults_config_map.update({
'NOTIFY_INTERVAL_RESELLER': (lambda x, y: f"{is_positive_int(x)}{time_unit_to_letter(y)}",
'notify/reseller/period',
'notify/reseller/unitOfTime'),
'NOTIFY_INTERVAL_CUSTOMER': (lambda x, y: f"{is_positive_int(x)}{time_unit_to_letter(y)}",
'notify/customer/period',
'notify/customer/unitOfTime'),
'NOTIFY_RESELLER_ON_TOTAL_FAULTS': (lambda x: boolean_to_yes_no(x), 'notifyReseller'),
'NOTIFY_RESELLER_ON_CUSTOMERS_FAULTS': (lambda x: boolean_to_yes_no(x), 'notifyResellerOnCustomers'),
'NOTIFY_CUSTOMERS_ON_FAULTS': (lambda x: boolean_to_yes_no(x), 'notifyCustomers'),
'NOTIFY_MIN_FAULTS_RESELLER': 'minimumNumberOfFaultsToNotify/reseller',
'NOTIFY_MIN_FAULTS_CUSTOMER': 'minimumNumberOfFaultsToNotify/customer'})
new_config = {}
def get_val_by_path(path):
path_parts = path.split('/')
try:
point = parameters_dict
for part in path_parts:
point = point[part]
except KeyError:
point = notifier_params['faultsNotification']
for part in path_parts:
point = point[part]
return point
for key, val in faults_config_map.items():
try:
if isinstance(val, str):
new_config[key] = get_val_by_path(val)
else:
new_config[key] = val[0](*(get_val_by_path(x) for x in val[1:]))
except KeyError:
continue
# to do not change iter object while iterate it
config_to_write = [line.strip() for line in config_lines]
try:
for idx, line in enumerate(config_lines):
# Pass comment lines
if line.startswith('#') or line.strip() == '':
continue
try:
key, value = line.split('=')
except ValueError as e:
raise LveStats2Exception({
'message': '%(lvestats_cfg)s format error: ' + f'{idx + 1}: {line}',
'context': {'lvestats_cfg': config_path}}) from e
if key in new_config:
# Parameter must be changed
config_to_write[idx] = f"{key}={new_config[key]}"
# Remove used parameter
del new_config[key]
except (KeyError, IndexError) as e:
raise LveStats2Exception({'message': "%(lvestats_cfg)s format error: " + str(e),
'context': {'lvestats_cfg': config_path}}) from e
# Add absent options
for key, value in new_config.items():
config_to_write.append(f"{key}={value}")
# Write config back to file
try:
with open(config_path, 'w', encoding='utf-8') as f:
f.writelines('\n'.join(config_to_write))
except (IOError, OSError) as e:
raise LveStats2Exception({'message': "%(lvestats_cfg)s write error: " + str(e),
'context': {'lvestats_cfg': config_path}}) from e
# Restart lvestats server
# /sbin/service lvestats reload
subprocess.run('/sbin/service lvestats reload &>/dev/null &',
shell=True, executable='/bin/bash', check=False)