ok
Mini Shell
# 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 __future__ import absolute_import
from __future__ import division
import logging
from lvestat import LVEStat
from lvestats.core.plugin import LveStatsPlugin
KB = 1024
FAULTS = ('cpu_fault', 'memphy_fault', 'mem_fault', 'io_fault', 'iops_fault', 'mep_fault', 'nproc_fault')
LIMITS = ('lcpu', 'lmemphy', 'lmem', 'io', 'liops', 'lep', 'lnproc')
STATS = ('cpu_usage', 'memphy', 'mem_usage', 'io_usage', 'iops', 'mep', 'nproc')
LVEUSAGESLOTS = ('lve_version', 'time', 'has_changed_limits', 'has_changed_nproc') + STATS + LIMITS + FAULTS
__author__ = 'iseletsk'
log = logging.getLogger('LVEUsage')
class LVEUsageAnalyzer(LveStatsPlugin):
"""
Calculates lve usage and updates it in lve_data, in field 'lve_usage'
"""
def set_config(self, config):
self.config = config
def execute(self, lve_data):
"""
:param dict lve_data:
"""
# from /proc/lve
new_stats = lve_data['stats']
old_stats = lve_data['old_stats']
del lve_data['old_stats']
old_now = lve_data.get('old_now', None)
lve_data['old_now'] = self.now
total_hz = lve_data['totalHz']
procs = lve_data['procs']
result = {}
for _id, lve_stat in new_stats.items():
u = LVEUsage(lve_version=lve_data['LVE_VERSION'])
lve_stat_old = old_stats.get(_id, None)
u.calc(lve_stat_old, lve_stat, total_hz, self.now - old_now if old_now else None, procs)
# LVES-210: clear all data if EP and NPROC == 0 and all other data not changed
if _id == 0 \
or lve_stat.nproc > 0 \
or lve_stat.mep > 0 \
or (lve_stat_old is not None and u.is_lve_data_changed(lve_stat_old, lve_stat)):
result[_id] = u
lve_usages = lve_data.get('lve_usages', [])
lve_usages.append(result)
lve_data['lve_usages_5s'] = [result]
lve_data['lve_active_ids'] = list(result.keys())
lve_data['lve_usages'] = lve_usages
class LVEUsage(object):
__slots__ = LVEUSAGESLOTS
def __init__(self, lve_version):
self.lve_version = lve_version
self.time = None
self.has_changed_limits = False
self.has_changed_nproc = False
# if LVE_VERSION >= 4
self.cpu_usage = 0
self.cpu_fault = 0
self.mep = 0
self.mem_fault = 0
self.mep_fault = 0
self.mem_usage = 0
self.lep = 0
self.lcpu = 0
self.lmem = 0
# if LVE_VERSION >=6
self.io = 0
self.io_usage = 0
self.io_fault = 0
self.lmemphy = 0
self.memphy = 0
self.memphy_fault = 0
self.lnproc = 0
self.nproc = 0
self.nproc_fault = 0
# if LVE_VERSION >= 8
self.liops = 0
self.iops = 0
self.iops_fault = 0
def init_limits_from_lvestat(self, lvestat: LVEStat, procs):
"""
Prepares LVEUsage obj taking limits from LVEStat
"""
self.lep = lvestat.lep
self.lcpu = self.convert_lcpu_to_new_kernel_format(lvestat.cpu,
self.lve_version,
procs)
# CMT-509: the incorrect LVE I/O units on CMT dashboard
# Proc saves this value is in KBps,
# but we should send it is in Bps,
# because for an active user this value is sent in Bps
self.io = lvestat.io * KB
self.lmemphy = lvestat.lmemphy
self.lnproc = lvestat.lnproc
if self.lve_version >= 8:
self.liops = lvestat.liops
return self
def __repr__(self):
representation = '<'
for k in (k for k in dir(self) if not k.startswith("_")):
v = getattr(self, k)
if isinstance(v, (str, int, float, bool, type(None))):
representation += '%s:%s, ' % (str(k), str(v))
representation += '>'
return representation
def has_interesting_values(self):
if any((self.cpu_usage, self.nproc, self.io_usage, self.iops)):
return True
if any((getattr(self, k) for k in FAULTS)):
return True
return False
def _has_changed_limits(self, new, old):
"""
:type old: lvestat.LVEStat
:type new: lvestat.LVEStat
"""
for attr in LIMITS:
if getattr(new, attr, None) != getattr(old, attr, None):
return True
return False
def _has_changed_nproc(self, new, old):
"""
:type old: lvestat.LVEStat
:type new: lvestat.LVEStat
"""
return old.nproc != new.nproc
def convert_lcpu_to_new_kernel_format(self, lcpu, lve_ver, procs):
"""
New kernel format lcpu is 100 times bigger than previous. So that it's 0-10000
"""
if lve_ver >= 8:
return lcpu
else:
# new_kernel_format = (old_format * 10000 * procs / 100) = old_format * 100 * procs
return lcpu * procs * 100
def is_lve_data_changed(self, old, new):
"""
Check if LVE data is changed
:param old: Previous data
:param new: Current data
:return: True - changes, false - not
"""
# Common data
if old.cpu_usage != new.cpu_usage \
or old.mep != new.mep \
or old.mem_fault != new.mem_fault \
or old.mep_fault != new.mep_fault \
or old.mem_usage != new.mem_usage \
or old.lep != new.lep \
or old.io != new.io \
or old.io_usage != new.io_usage:
return True
# LVE6+ data
if (old.memphy != new.memphy or old.memphy_fault != new.memphy_fault or
old.nproc != new.nproc or old.nproc_fault != new.nproc_fault):
return True
# LVE8+ data
if self.lve_version >= 8 and old.iops != new.iops:
return True
return False
def calc(self, old, new, hz, time, procs):
self.time = time
# LCPU 100% now is 100*100 = 10 000
# LCPU 0% is 0
self.lcpu = self.convert_lcpu_to_new_kernel_format(new.cpu, self.lve_version, procs)
if bool(old):
# Previous data present
self.has_changed_limits = self._has_changed_limits(new, old)
self.has_changed_nproc = self._has_changed_nproc(new, old)
# CPU USAGE is 0-10000*procs
# new_kernel_format = (old_format * 10000 * procs / 100) = old_format * 100 * procs;
# (100 * (new.cpu_usage - self.cpu_usage) / (hz * time)) = old_format
assert time is not None, "oldstats is not None, but time is unknown"
assert time != 0, "oldstats is not None, but time is 0"
if new.cpu_usage > old.cpu_usage:
self.cpu_usage = int(round(10000 * (new.cpu_usage - old.cpu_usage) * procs / (hz * time))) # pylint: disable=round-builtin
if new.mem_fault > old.mem_fault:
self.mem_fault = new.mem_fault - old.mem_fault
if new.mep_fault > old.mep_fault:
self.mep_fault = new.mep_fault - old.mep_fault
if new.memphy_fault > old.memphy_fault:
self.memphy_fault = new.memphy_fault - old.memphy_fault
if new.nproc_fault > old.nproc_fault:
self.nproc_fault = new.nproc_fault - old.nproc_fault
if new.io_usage > old.io_usage:
# bytes per second
self.io_usage = int(round(KB * (new.io_usage - old.io_usage) / time)) # pylint: disable=round-builtin
if self.lve_version >= 8:
if new.iops > old.iops:
self.iops = int(round((new.iops - old.iops) / time)) # pylint: disable=round-builtin
if self.cpu_usage < 0:
self.cpu_usage = 0
elif self.cpu_usage >= self.lcpu > 0:
self.cpu_usage = self.lcpu
self.cpu_fault += 1
self.lmem = new.lmem
if self.mem_fault > 0 or new.mem_usage > new.lmem > 0:
self.mem_usage = new.lmem
else:
self.mem_fault = 0
self.mem_usage = new.mem_usage
self.lep = new.lep
if self.mep_fault > 0 or new.mep > new.lep > 0:
self.mep = new.lep
else:
self.mep_fault = 0
self.mep = new.mep
if self.lve_version >= 8:
self.liops = new.liops
if self.iops >= self.liops > 0:
self.iops = self.liops
self.iops_fault += 1
self.io = KB * new.io # limit in bytes per second
if self.io_usage < 0:
self.io_usage = 0
elif self.io_usage >= self.io > 0:
self.io_usage = self.io
self.io_fault += 1
self.lmemphy = new.lmemphy
self.lnproc = new.lnproc
if self.memphy_fault > 0 or new.memphy > new.lmemphy > 0:
self.memphy = new.lmemphy
else:
self.memphy_fault = 0
self.memphy = new.memphy
if self.nproc_fault > 0 or new.nproc > new.lnproc > 0:
self.nproc = new.lnproc
else:
self.nproc_fault = 0
self.nproc = new.nproc
def __str__(self):
return "(cpu_usage="+str(self.cpu_usage)+", mep="+str(self.mep)+")"
def __getitem__(self, key):
return getattr(self, key)
Zerion Mini Shell 1.0