Refactoring(server-info): moved CPU rate from Rater to CPU

Moved all the folding logic/constants to Folding

netutils_linux_hardware/cli.py

@@ -4,8 +4,9 @@
 
 from six import print_
 
-from netutils_linux_hardware.rater import Rater, FOLDING_NO, FOLDING_DEVICE, FOLDING_SUBSYSTEM, FOLDING_SERVER
 from netutils_linux_hardware.collect import ServerInfoCollect
+from netutils_linux_hardware.folding import Folding
+from netutils_linux_hardware.rater import Rater
 from netutils_linux_hardware.reader import Reader
 
 
@@ -32,12 +33,12 @@ def __parse_args(self):
  default=False)
  self.parser.add_argument('--rate', action='store_true', help='Rates data about the server', default=False)
  self.parser.add_argument('-f', '--folding', action='count', help='-f - device, -ff - subsystem, -fff - server',
- default=FOLDING_NO)
- self.parser.add_argument('--device', action='store_const', const=FOLDING_DEVICE, dest='folding',
+ default=Folding.NO)
+ self.parser.add_argument('--device', action='store_const', const=Folding.DEVICE, dest='folding',
  help='Folds rates details to entire devices')
- self.parser.add_argument('--subsystem', action='store_const', const=FOLDING_SUBSYSTEM, dest='folding',
+ self.parser.add_argument('--subsystem', action='store_const', const=Folding.SUBSYSTEM, dest='folding',
  help='Folds rates details to entire subsystems')
- self.parser.add_argument('--server', action='store_const', const=FOLDING_SERVER, dest='folding',
+ self.parser.add_argument('--server', action='store_const', const=Folding.SERVER, dest='folding',
  help='Folds rates details to entire server')
  self.parser.add_argument('--cpu', action='store_true', help='Show information about CPU', default=False)
  self.parser.add_argument('--memory', action='store_true', help='Show information about RAM', default=False)

netutils_linux_hardware/cpu.py

@@ -1,7 +1,29 @@
 # coding=utf-8
 
+from netutils_linux_hardware.grade import Grade
+from netutils_linux_hardware.rater import extract
 from netutils_linux_hardware.subsystem import Subsystem
 
 
 class CPU(Subsystem):
- pass
+ """ Everything about CPU: layouts, NUMA, HZ, L3, lscpu """
+
+ def __init__(self, data=None):
+ self.data = data
+
+ def parse(self):
+ pass
+
+ def rate(self, rater):
+ cpuinfo = extract(self.data, ['cpu', 'info'])
+ if cpuinfo:
+ return rater.folding.fold({
+ 'CPU MHz': Grade.int(cpuinfo.get('CPU MHz'), 2000, 4000),
+ 'BogoMIPS': Grade.int(cpuinfo.get('BogoMIPS'), 4000, 8000),
+ 'CPU(s)': Grade.int(cpuinfo.get('CPU(s)'), 2, 32),
+ 'Core(s) per socket': Grade.int(cpuinfo.get('Core(s) per socket'), 1, 2),
+ 'Socket(s)': Grade.int(cpuinfo.get('Socket(s)'), 1, 2),
+ 'Thread(s) per core': Grade.int(cpuinfo.get('Thread(s) per core'), 2, 1),
+ 'L3 cache': Grade.int(cpuinfo.get('L3 cache'), 1000, 30000),
+ 'Vendor ID': Grade.str(cpuinfo.get('Vendor ID'), good=['GenuineIntel']),
+ }, rater.folding.SUBSYSTEM)

netutils_linux_hardware/rater.py

@@ -2,14 +2,11 @@
 
 import yaml
 
+from netutils_linux_hardware.cpu import CPU
+from netutils_linux_hardware.folding import Folding
 from netutils_linux_hardware.grade import Grade
 from netutils_linux_hardware.rater_math import extract
 
-FOLDING_NO = 0
-FOLDING_DEVICE = 1
-FOLDING_SUBSYSTEM = 2
-FOLDING_SERVER = 3
-
 
 class Rater(object):
  """ Calculates rates for important system components """
@@ -20,18 +17,10 @@ class Rater(object):
  def __init__(self, data, args):
  self.data = data
  self.args = args
+ self.folding = Folding(args)
  if self.data:
  self.rate()
 
- def fold(self, data, level):
- """ Схлапывает значения в дикте до среднего арифметического """
- if not data:
- return 1
- if self.args.folding < level:
- return data
- result = sum(data.values()) / len(data.keys())
- return result if level < FOLDING_SERVER else {'server': result}
-
  def __str__(self):
  return yaml.dump(self.info, default_flow_style=False).strip()
 
@@ -43,31 +32,17 @@ def rate(self):
  elif key == 'net':
  data[key] = self.__rate(self.rate_netdev, 'net')
  elif key == 'cpu':
- data[key] = self.rate_cpu()
+ data[key] = CPU(self.data).rate(self)
  elif key == 'memory':
  data[key] = self.rate_memory()
  elif key == 'disk':
  data[key] = self.__rate(self.rate_disk, 'disk')
  elif key == 'system':
  data[key] = self.rate_system()
- self.info = self.fold(data, FOLDING_SERVER)
-
- def rate_cpu(self):
- cpuinfo = extract(self.data, ['cpu', 'info'])
- if cpuinfo:
- return self.fold({
- 'CPU MHz': Grade.int(cpuinfo.get('CPU MHz'), 2000, 4000),
- 'BogoMIPS': Grade.int(cpuinfo.get('BogoMIPS'), 4000, 8000),
- 'CPU(s)': Grade.int(cpuinfo.get('CPU(s)'), 2, 32),
- 'Core(s) per socket': Grade.int(cpuinfo.get('Core(s) per socket'), 1, 2),
- 'Socket(s)': Grade.int(cpuinfo.get('Socket(s)'), 1, 2),
- 'Thread(s) per core': Grade.int(cpuinfo.get('Thread(s) per core'), 2, 1),
- 'L3 cache': Grade.int(cpuinfo.get('L3 cache'), 1000, 30000),
- 'Vendor ID': Grade.str(cpuinfo.get('Vendor ID'), good=['GenuineIntel']),
- }, FOLDING_SUBSYSTEM)
+ self.info = self.folding.fold(data, Folding.SERVER)
 
  def rate_memory_device(self, device):
- return self.fold({
+ return self.folding.fold({
  'size': Grade.int(device.get('size', 0), 512, 8196),
  'type': Grade.known_values(device.get('type', 'RAM'), {
  'DDR1': 2,
@@ -76,43 +51,43 @@ def rate_memory_device(self, device):
  'DDR4': 10,
  }),
  'speed': Grade.int(device.get('speed', 0), 200, 4000),
- }, FOLDING_DEVICE)
+ }, Folding.DEVICE)
 
  def rate_memory_devices(self, devices):
  if not devices:
  return 1
- return self.fold(dict((handle, self.rate_memory_device(device))
- for handle, device in devices.items()),
- FOLDING_SUBSYSTEM)
+ return self.folding.fold(dict((handle, self.rate_memory_device(device))
+  for handle, device in devices.items()),
+  Folding.SUBSYSTEM)
 
  def rate_memory_size(self, size):
- return self.fold({
+ return self.folding.fold({
  'MemTotal': Grade.int(size.get('MemTotal'), 2 * (1024 ** 2), 16 * (1024 ** 2)),
  'SwapTotal': Grade.int(size.get('SwapTotal'), 512 * 1024, 4 * (1024 ** 2)),
- }, FOLDING_DEVICE) if size else 1
+ }, Folding.DEVICE) if size else 1
 
  def rate_memory(self):
  meminfo = self.data.get('memory')
  if meminfo:
- return self.fold({
+ return self.folding.fold({
  'devices': self.rate_memory_devices(meminfo.get('devices')),
  'size': self.rate_memory_size(meminfo.get('size')),
- }, FOLDING_SUBSYSTEM)
+ }, Folding.SUBSYSTEM)
 
  def rate_system(self):
  cpuinfo = extract(self.data, ['cpu', 'info'])
  if cpuinfo:
- return self.fold({
+ return self.folding.fold({
  'Hypervisor vendor': Grade.fact(cpuinfo.get('Hypervisor vendor'), False),
  'Virtualization type': Grade.fact(cpuinfo.get('Hypervisor vendor'), False),
- }, FOLDING_SUBSYSTEM)
+ }, Folding.SUBSYSTEM)
 
  def rate_netdev(self, netdev):
  netdevinfo = extract(self.data, ['net', netdev])
  queues = sum(
  len(extract(netdevinfo, ['queues', x])) for x in ('rx', 'rxtx'))
  buffers = netdevinfo.get('buffers') or {}
- return self.fold({
+ return self.folding.fold({
  'queues': Grade.int(queues, 2, 8),
  'driver': {
  'mlx5_core': 10, # 7500 mbit/s
@@ -125,20 +100,20 @@ def rate_netdev(self, netdev):
  'e1000': 3, # 50 mbit/s
  'r8169': 1, 'ATL1E': 1, '8139too': 1, # real trash, you should never use it
  }.get(netdevinfo.get('driver').get('driver'), 2),
- 'buffers': self.fold({
+ 'buffers': self.folding.fold({
  'cur': Grade.int(buffers.get('cur'), 256, 4096),
  'max': Grade.int(buffers.get('max'), 256, 4096),
- }, FOLDING_DEVICE)
- }, FOLDING_DEVICE)
+ }, Folding.DEVICE)
+ }, Folding.DEVICE)
 
  def rate_disk(self, disk):
  diskinfo = extract(self.data, ['disk', disk])
- return self.fold({
+ return self.folding.fold({
  'type': Grade.str(diskinfo.get('type'), ['SDD'], ['HDD']),
  # 50Gb - good, 1Tb - good enough
  'size': Grade.int(diskinfo.get('size'), 50 * (1000 ** 3), 1000 ** 4),
- }, FOLDING_DEVICE)
+ }, Folding.DEVICE)
 
  def __rate(self, func, key):
  items = self.data.get(key)
- return self.fold(dict((item, func(item)) for item in items), FOLDING_SUBSYSTEM) if items else 1
+ return self.folding.fold(dict((item, func(item)) for item in items), Folding.SUBSYSTEM) if items else 1

netutils_linux_hardware/subsystem.py

@@ -17,6 +17,6 @@ def parse(self):
  pass
 
  @abstractmethod
- def rate(self):
+ def rate(self, rater):
  """ Rating every detail in that data """
  pass