Edit File: analyzers.py
# 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_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)+")"