AlkantarClanX12
Your IP : 3.142.250.86
# 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 argparse
import logging
import datetime
import sys
import os
import subprocess
from bisect import bisect_left
from collections import defaultdict
from typing import Iterable, List
from lxml import etree
from sqlalchemy.exc import SQLAlchemyError
import lvestats
import lvestats.lib.commons.decorators
from clcommon.cpapi.pluginlib import getuser
from lvestats.lib.cloudlinux_statistics import _get_uid_for_select
from lvestats.lib import config, dbengine, lveinfolib, uidconverter
from lvestats.lib.chart.svggraph import SvgChart
from lvestats.lib.chart.rdp import ramerdouglas
from lvestats.lib.commons import dateutil
from lvestats.lib.commons.argparse_utils import period_type2, ParseDatetime
from lvestats.lib.commons.logsetup import setup_logging
from lvestats.lib.chart.polysimplify import VWSimplifier
__author__ = 'shaman'
DEFAULT_SERVER_ID = 'localhost'
IMAGEMAGICK_BINARY = "/opt/alt/alt-ImageMagick/usr/bin/magick"
if not os.path.exists(IMAGEMAGICK_BINARY):
IMAGEMAGICK_BINARY = "/usr/bin/convert"
format_index = 1
class Renderer(object):
"""
Renders data to file
"""
def __init__(self, max_points_on_graph: int = 800, fault_color: str = 'aquamarine'):
self.log = logging.getLogger('Chart Renderer')
self.svg_chart = SvgChart()
self._max_points_on_graph = max_points_on_graph
self._fault_color = fault_color
@staticmethod
def _nop(arg):
return arg
@staticmethod
def _ts_to_str(ts):
# Example: [0]="5 Feb", [1]="Aug 15, 2:35pm"
formats = ['%b-%d', '%b-%d %I:%M%p']
gm = dateutil.unixtimestamp_to_gm_datetime(ts)
lo = dateutil.gm_to_local(gm)
return lo.strftime(formats[format_index])
def set_period_sec(self, period_sec):
global format_index
# 8 days = 8 * 24 * 3600 = 691200 sec
if period_sec >= 691200:
format_index = 0
def _optimisation_ramerdouglas(self, points, epsilon_max=2.0, epsilon_min=0):
epsilon_default = epsilon_max
points_output = points
points_len = 0
for i in range(10):
points_optimised = ramerdouglas(points, epsilon_default)
points_len_previous = points_len
points_len = len(points_optimised)
if points_len == points_len_previous:
# return result if changing epsilon not change points number
return points_output
if points_len >= self._max_points_on_graph:
if i == 0:
# return result if in first iteration points more than max
return points_optimised
epsilon_min = epsilon_default
else:
points_output = points_optimised
epsilon_max = epsilon_default
# correcting epsilon
epsilon_default = (epsilon_max + epsilon_min) / 2.
return points_output
def _optimisation_polysimplify(self, points: Iterable[Iterable[float]]) -> List[List[float]]:
simplifier = VWSimplifier(points)
result = simplifier.from_number(self._max_points_on_graph)
return result
def optimise_points(self, line: Iterable[Iterable[float]]) -> List[List[float]]:
if len(line) > self._max_points_on_graph:
line = self._optimisation_ramerdouglas(line, epsilon_max=1.4)
line = self._optimisation_polysimplify(line)
return line
def get_two_closest(self, line, x_value):
"""
:type x_value: float
:type line: list
"""
pos = bisect_left(line, x_value)
before = line[pos - 1]
after = line[pos]
return pos - 1, before, pos, after
def add_graph(
self,
data,
title,
legend,
x_values,
min_y=None,
max_y=None,
x_labels=None,
generate_n_xlabels=None,
y_labels=None,
y_legend_converter=lambda v: v,
unit=None,
message=None,
faults=None):
"""
:type message: None|str
:type unit: None|str
:type y_legend_converter: (float) -> float
:type max_y: None|float
:type min_y: None|float
:type title: str
:type legend: dict
:type x_values: list
:type faults: (str, str, str)
:type data: defaultdict
"""
colors, datasets, fault_lines, names = self._add_graph(data, faults, legend, x_values)
self.svg_chart.add_graph(
datasets,
colors,
title=title,
minimum_y=min_y,
maximum_y=max_y,
x_legend=x_labels,
x_legend_generate=generate_n_xlabels,
y_legend=y_labels,
y_legend_converter=y_legend_converter,
x_legend_converter=self._ts_to_str,
names=names,
unit=unit,
message=message,
fault_lines=fault_lines,
fault_color=self._fault_color)
def _add_graph(self, data, faults, legend, x_values):
"""
:type legend: dict
:type x_values: list
:type faults: (str, str, str)
:type data: defaultdict
:rtype (list, list, list, list)
"""
datasets = []
names = []
colors = []
datasets_dictionary = {}
for (key, metainfo) in legend.items():
try:
legend_title, color, modifier = metainfo
except ValueError:
legend_title, color = metainfo
modifier = self._nop
y_values = [modifier(y) for y in data[key.lower()]]
# x_values = range(0, len(y_values))
line = list(zip(x_values, y_values))
line_optimised = self.optimise_points(line)
datasets.append(line_optimised)
datasets_dictionary[key.lower()] = line_optimised
names.append(legend_title)
colors.append(color)
fault_lines = self.get_faults_lines(data, datasets_dictionary, faults, x_values)
# add legend
if fault_lines:
names.append('faults')
colors.append(self._fault_color)
del datasets_dictionary
return colors, datasets, fault_lines, names
def get_faults_lines(self, data, datasets_dictionary, faults, x_values):
"""
:type x_values: list
:type faults: (str, str, str)
:type datasets_dictionary: dict
:type data: defaultdict
:rtype list
"""
fault_lines = []
if faults is not None:
fault_name, data_name, limit_name = [x.lower() for x in faults]
if limit_name in datasets_dictionary and data_name in datasets_dictionary:
faults_x = [x for x, y in zip(x_values, data[fault_name]) if y > 0]
average_times, average = list(zip(*datasets_dictionary[data_name]))
limit_times, limit = list(zip(*datasets_dictionary[limit_name]))
for fault in faults_x:
try:
average_dot = self.get_dot(fault, average, average_times)
limit_dot = self.get_dot(fault, limit, limit_times)
if average_dot[1] < limit_dot[1] and (average_dot, limit_dot) not in fault_lines:
fault_lines.append((average_dot, limit_dot))
except IndexError:
self.log.error("Can't get fault line: %s", str(fault))
return fault_lines
def get_dot(self, fault_time, line, line_times):
"""
:type line_times: list
:type line: list
:type fault_time: float
:rtype (float, float)
"""
if fault_time >= line_times[-1]:
return fault_time, line[-1]
if fault_time <= line_times[0]:
return fault_time, line[0]
try:
dot = (fault_time, line[line_times.index(fault_time)])
except ValueError:
before_index, before, after_index, after = self.get_two_closest(line_times, fault_time)
dot_y = (
(fault_time - before)
/ (after - before)
* (line[after_index] - line[before_index])
+ line[before_index]
)
dot = (fault_time, dot_y)
return dot
def add_common_x_legend(self, x_values, n):
self.svg_chart._add_x_legend( # pylint: disable=protected-access
x_values=x_values,
number=n,
x_legend_converter=self._ts_to_str,
)
def add_text_box(self, text, font_size=None):
"""
add empty rectangle with text
"""
self.svg_chart.add_text_box(text, font_size)
def render(self):
return self.svg_chart.dump()
class UserNotFound(Exception):
def __init__(self, user_name, *args, **kwargs):
super().__init__(f'User {user_name} not found', *args, **kwargs)
class ChartMain(object):
def __init__(self, prog_name, prog_desc, cnf):
self.prog_name = prog_name
self.prog_desc = prog_desc
self.log = setup_logging(cnf, prog_name, console_level=logging.ERROR)
self.cfg = cnf
# analog of previous parameter but get from config file
self.is_normalized_user_cpu = config.is_normalized_user_cpu()
@staticmethod
def convert_dbdata_to_dict(data, show_columns):
data_collected = defaultdict(list)
for row in data:
row_dict = dict(zip(show_columns, row))
for (k, v) in row_dict.items():
data_collected[k].append(float(v or 0))
return data_collected
@staticmethod
def convert_lvedata_to_dict(data):
# key -- field name, like 'cpu', 'id', 'created', etc.. value -- list of values
by_key = defaultdict(list)
for (k, values) in data.items():
by_key[k] = [float(v or 0) for v in values]
return by_key
def make_parser(self):
current_server_id = self.cfg.get('server_id', DEFAULT_SERVER_ID)
datetime_now = datetime.datetime.now()
parser = argparse.ArgumentParser(prog=self.prog_name,
add_help=True,
description=self.prog_desc)
parser.add_argument('--version', version=lvestats.__version__,
help='Version number',
dest='version',
action='version')
parser.add_argument('--period',
help='Time period\n'
'specify minutes with m, h - hours, days with d, and values: today, yesterday\n'
'5m - last 5 minutes, 4h - last four hours, 2d - last 2 days, as well as today',
type=lambda value: period_type2(value, datetime_now),
default=None
)
parser.add_argument('--from',
help='Run report from date and time in YYYY-MM-DD HH:MM format\n'
'if not present last 10 minutes are assumed',
action=ParseDatetime,
nargs='+',
dest='ffrom')
parser.add_argument('--to',
help='Run report up to date and time in YYYY-MM-DD HH:MM format\n'
'if not present, reports results up to now',
action=ParseDatetime,
nargs='+',
dest='to')
parser.add_argument('--server',
help='With username or LVE id show only record for that user at given server',
dest='server',
default=current_server_id)
parser.add_argument('--output',
help='Filename to save chart as, if not present, output will be sent to STDOUT',
default='-', dest='output')
parser.add_argument('--show-all',
help='Show all graphs (by default shows graphs for which limits are set)',
dest='show_all',
action='store_true',
default=False)
parser.add_argument('--style',
help='Set graph style',
choices=['admin', 'user'],
dest='style',
default=None)
parser.add_argument('--format',
help='Set graph output format',
choices=['svg', 'png'],
dest='format',
default='png')
parser.add_argument('--for-reseller',
help='Show graph for specific reseller and user (used only with --id key)',
type=str,
dest='for_reseller',
default=None)
# add opt --dpi, --width, --height for backward compatible with old lvechart
parser.add_argument('--dpi', help=argparse.SUPPRESS)
parser.add_argument('--width', help=argparse.SUPPRESS)
parser.add_argument('--height', help=argparse.SUPPRESS)
return parser
def customize_parser(self, parser):
"""
:type parser: argparse.ArgumentParser
:rtype : argparse.ArgumentParser
"""
raise NotImplementedError()
def get_chart_data(self,
engine,
from_ts,
to_ts,
server,
user_id,
show_all=False):
"""
Extracts data from database , in form of a tuple:
(dict, list)
where dict is
{
'cpu': [0, 5, 10 , 95.2, ...] -- values
'io': [0, 5, 10 , 95.2, ...] -- values
'foo': ,
}
and a list of timestamps for all that collected values:
2) [1, 2 ,3 ...]
:param show_all:
:rtype : tuple
:type engine: sqlalchemy.engine
:type from_ts: datetime.datetime
:type to_ts: datetime.datetime
:type server: str
:type user_id: int
"""
raise NotImplementedError()
def add_graphs(self, renderer, data_collected, times, lve_version, show_all, is_user=False):
"""
:rtype : None
:type renderer: Renderer
:type data_collected: dict
:type times: list
:type lve_version: str
:type show_all: bool
:type is_user: bool. True for user, False - admin
"""
raise NotImplementedError()
@lvestats.lib.commons.decorators.no_sigpipe
def main(self, args, debug_engine=None):
parser = self.make_parser()
parser = self.customize_parser(parser)
if debug_engine is not None:
engine = debug_engine
else:
try:
engine = dbengine.make_db_engine(self.cfg)
except dbengine.MakeDbException as e:
sys.stderr.write(str(e) + '\n')
return 1
opts = parser.parse_args(list(args))
if opts.period and any((opts.ffrom, opts.to)):
print("--period and [--from, --to] are mutually exclusive")
return 0
if opts.period:
f, t = opts.period
else:
datetime_now = datetime.datetime.now()
f = opts.ffrom or datetime_now - datetime.timedelta(minutes=10)
t = opts.to or datetime_now
user_id = self._obtain_user_id(engine, opts) if self._has_user_arguments(opts) else os.getuid()
if getuser() != 'root':
if user_id and user_id != os.getuid():
sys.stderr.write('Permission denied\n')
return 1
# LVESTATS-97
# If both params (for_reseller and id or username) are used
# and user_id not in resellers_users, we return `Permission denied` message
if opts.for_reseller:
reseller_name = opts.for_reseller
reseller_users = _get_uid_for_select(reseller_name, user_id)
# if reseller_users is just int, than everything is ok
if isinstance(reseller_users, int):
pass
# if not user's id is in reseller's ids
# neither user is reseller and user's id is reseller's id itself
elif user_id not in reseller_users:
error_msg = (
f'Permission denied. User with id {user_id} does not belong reseller `{reseller_name}`\n'
)
sys.stderr.write(error_msg)
return 1
try:
data_collected, times, period_sec = self.get_chart_data(engine,
f,
t,
opts.server,
user_id=user_id)
except (UserNotFound, SQLAlchemyError) as ex:
sys.stderr.write(str(ex) + '\n')
return 1
rendered_graph = self._render(data_collected, engine, opts, period_sec, times)
self._output(opts, rendered_graph)
return 0
def _render(self, data_collected, engine, opts, period_sec, times):
show_all = opts.show_all
try:
style = opts.style
except AttributeError:
style = None
if style is None:
style = 'admin'
renderer = Renderer()
renderer.set_period_sec(period_sec)
lve_version = lveinfolib.get_lve_version(engine, opts.server)
self.add_graphs(renderer, data_collected, times, lve_version, show_all,
is_user=style == 'user')
rendered_graph = renderer.render()
return rendered_graph
def _output(self, opts, rendered_graph):
if opts.format == 'svg' and opts.output == '-':
# output as SVG
try:
root_node = etree.fromstring(rendered_graph.encode('utf8'))
rendered_graph = etree.tostring(root_node, pretty_print=True)
except (ImportError, ValueError, UnicodeEncodeError) as e:
self.log.debug('Can not use pretty print for svg xml formatting; %s', str(e))
if opts.format == 'png':
# output as PNG
cwd = '/var/lve/tmp' if os.getuid() == 0 else None
with subprocess.Popen(
[IMAGEMAGICK_BINARY, "-", "png:-"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
cwd=cwd
) as proc:
rendered_graph, _ = proc.communicate(input=rendered_graph.encode())
if opts.output == '-':
if isinstance(rendered_graph, bytes):
sys.stdout.buffer.flush() # needed to write directly to buffer
sys.stdout.buffer.write(rendered_graph)
else:
sys.stdout.write(rendered_graph)
else:
try:
if isinstance(rendered_graph, bytes):
write_mode = 'wb'
else:
write_mode = 'w'
with open(opts.output, write_mode) as output:
output.write(rendered_graph)
except IOError:
self.log.error("Unable to create file: %s", opts.output)
def _obtain_user_id(self, engine, opts):
# obtain user id
try:
user_id = opts.user_id
except AttributeError:
user_id = None
try:
user_name = opts.user_name
except AttributeError:
user_name = None
if user_id is None:
user_id = uidconverter.username_to_uid(
username=user_name, local_server_id=self.cfg['server_id'],
server_id=opts.server, db_engine=engine) or -1
return user_id
def _has_user_arguments(self, opts):
return (hasattr(opts, 'user_id') and opts.user_id) or (hasattr(opts, 'user_name') and opts.user_name)