Folding (#181). Added: folding of server-info-rate output

Can be used only manually now.

netutils_linux_hardware/assessor.py

@@ -1,7 +1,16 @@
+# coding: utf-8
+import argparse
+
 import yaml
+
 from netutils_linux_hardware.assessor_math import extract
 from netutils_linux_hardware.grade import Grade
 
+FOLDING_NO = 0
+FOLDING_DEVICE = 1
+FOLDING_SUBSYSTEM = 2
+FOLDING_SERVER = 3
+
 
 class Assessor(object):
     """ Calculates rates for important system components """
@@ -10,25 +19,35 @@ class Assessor(object):
 
     def __init__(self, data):
         self.data = data
+        self.args = self.parse_args()
         if self.data:
             self.assess()
 
+    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()
 
     def assess(self):
-        self.info = {
+        self.info = self.fold({
             'net': self.__assess(self.assess_netdev, 'net'),
             'cpu': self.assess_cpu(),
             'memory': self.assess_memory(),
             'system': self.assess_system(),
             'disk': self.__assess(self.assess_disk, 'disk'),
-        }
+        }, FOLDING_SERVER)
 
     def assess_cpu(self):
         cpuinfo = extract(self.data, ['cpu', 'info'])
         if cpuinfo:
-            return {
+            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),
@@ -37,51 +56,55 @@ def assess_cpu(self):
                 '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)
 
     def assess_memory_device(self, device):
-        return {
-            'size': Grade.int(device.data.get('size', 0), 512, 8196),
-            'type': Grade.known_values(device.data.get('type', 'RAM'), {
+        return self.fold({
+            'size': Grade.int(device.get('size', 0), 512, 8196),
+            'type': Grade.known_values(device.get('type', 'RAM'), {
                 'DDR1': 2,
                 'DDR2': 3,
                 'DDR3': 6,
                 'DDR4': 10,
             }),
-            'speed': Grade.int(device.data.get('speed', 0), 200, 4000),
-        }
+            'speed': Grade.int(device.get('speed', 0), 200, 4000),
+        }, FOLDING_DEVICE)
 
     def assess_memory_devices(self, devices):
-        return dict((handle, self.assess_memory_device(device)) for handle, device in devices.items())
+        if not devices:
+            return 1
+        return self.fold(dict((handle, self.assess_memory_device(device))
+                              for handle, device in devices.items()),
+                         FOLDING_SUBSYSTEM)
 
     def assess_memory_size(self, size):
-        return {
+        return self.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)
 
     def assess_memory(self):
         meminfo = self.data.get('memory')
         if meminfo:
-            return {
+            return self.fold({
                 'devices': self.assess_memory_devices(meminfo.get('devices')),
                 'size': self.assess_memory_size(meminfo.get('size')),
-            }
+            }, FOLDING_SUBSYSTEM)
 
     def assess_system(self):
         cpuinfo = extract(self.data, ['cpu', 'info'])
         if cpuinfo:
-            return {
+            return self.fold({
                 'Hypervisor vendor': Grade.fact(cpuinfo.get('Hypervisor vendor'), False),
                 'Virtualization type': Grade.fact(cpuinfo.get('Hypervisor vendor'), False),
-            }
+            }, FOLDING_SUBSYSTEM)
 
     def assess_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 {
+        return self.fold({
             'queues': Grade.int(queues, 2, 8),
             'driver': {
                 'mlx5_core': 10,  # 7500 mbit/s
@@ -94,21 +117,27 @@ def assess_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': {
+            'buffers': self.fold({
                 'cur': Grade.int(buffers.get('cur'), 256, 4096),
                 'max': Grade.int(buffers.get('max'), 256, 4096),
-            },
-        }
+            }, FOLDING_DEVICE)
+        }, FOLDING_DEVICE)
 
     def assess_disk(self, disk):
         diskinfo = extract(self.data, ['disk', disk])
-        return {
+        return self.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)
 
     def __assess(self, func, key):
         items = self.data.get(key)
         if items:
-            return dict((item, func(item)) for item in items)
+            return self.fold(dict((item, func(item)) for item in items), FOLDING_SUBSYSTEM)
+
+    def parse_args(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-f', '--folding', action='count', help='-f - device, -ff - subsystem, -fff - server',
+                            default=FOLDING_NO)
+        return parser.parse_args()

netutils_linux_hardware/parsers.py

@@ -162,7 +162,7 @@ def __parse(devices):
         for device in devices:
             if 'Memory Device' in device:
                 mem_dev = MemInfoDMIDevice(device)
-                output[mem_dev.handle] = mem_dev
+                output[mem_dev.handle] = mem_dev.data
         return output
 
 

utils/server-info-rate

@@ -9,12 +9,14 @@ from six import print_
 from netutils_linux_hardware.assessor import Assessor
 from netutils_linux_hardware.reader import Reader
 
-def get_datadir():
-    default_data_directory = 'tests/autotune_network.tests/2xE5-2640.i350_and_82599ES.l2_mixed.masterconf'
-    if os.path.isfile(os.path.join(os.getcwd(), 'lspci')):
-        return os.getcwd()
-    return os.environ.get('DATADIR', default_data_directory)
-
+
+def main():
+    cwd = os.getcwd()
+    directory = cwd if os.path.isfile(os.path.join(cwd, 'lspci')) else os.getenv('DATADIR')
+    reader = Reader(directory)
+    assessor = Assessor(reader.info)
+    print_(assessor)
+
 
 if __name__ == '__main__':
-    print_(Assessor(Reader(get_datadir()).info))
+    main()