Merge pull request #226 from tchaikov/wip-gitcheck-lint

tools/githubcheck: add --lint option

Reviewed-by: Ernesto Puerta <epuertat@redhat.com>

Author: tchaikov

benchmark/benchmark.py

@@ -1,9 +1,7 @@
-import subprocess
 import logging
 
 import settings
 import common
-import monitoring
 import hashlib
 import os
 import json
@@ -12,6 +10,7 @@
 
 logger = logging.getLogger('cbt')
 
+
 class Benchmark(object):
     def __init__(self, archive_dir, cluster, config):
         self.acceptable = config.pop('acceptable', {})
@@ -29,7 +28,7 @@ def __init__(self, archive_dir, cluster, config):
         self.osd_ra = config.get('osd_ra', None)
         self.cmd_path = ''
         self.valgrind = config.get('valgrind', None)
-        self.cmd_path_full = '' 
+        self.cmd_path_full = ''
         self.log_iops = config.get('log_iops', True)
         self.log_bw = config.get('log_bw', True)
         self.log_lat = config.get('log_lat', True)
@@ -53,7 +52,7 @@ def _compare_client_results(self, client_run, self_analyzer, baseline_analyzer):
                    'iops_stddev': 'Stddev IOPS',
                    'latency_avg': 'Average Latency(s)',
                    'cpu_cycles_per_op': 'Cycles per operation'}
-        res_outputs = [] # list of dictionaries containing the self and baseline benchmark results
+        res_outputs = []  # list of dictionaries containing the self and baseline benchmark results
         compare_results = []
         self_analyzer_res = {}
         baseline_analyzer_res = {}
@@ -75,7 +74,7 @@ def _compare_client_results(self, client_run, self_analyzer, baseline_analyzer):
             baseline_getter = getattr(baseline_analyzer, 'get_' + alias)
             baseline_analyzer_res[name] = baseline_getter()
         res_outputs.append(self_analyzer_res)
-        res_outputs.append(baseline_analyzer_res)  
+        res_outputs.append(baseline_analyzer_res)
         for alias, stmt in list(self.acceptable.items()):
             name = aliases[alias]
             result, baseline = [float(j[name]) for j in res_outputs]
@@ -97,16 +96,13 @@ def evaluate(self, baseline):
             runs.append(self.readmode)
         results = []
         for run in runs:
-            out_dirs = [os.path.join(self.out_dir, run),
-                        os.path.join(baseline.out_dir, run)]
             for client in settings.getnodes('clients').split(','):
                 host = settings.host_info(client)["host"]
                 for proc in range(self.concurrent_procs):
                     self_analyzer = self.create_data_analyzer(run, host, proc)
                     baseline_analyzer = baseline.create_data_analyzer(run, host, proc)
                     client_run = '{run}/{client}/{proc}'.format(run=run, client=client, proc=proc)
                     compare_results = self._compare_client_results(client_run, self_analyzer, baseline_analyzer)
-                    rejected = sum(not result.accepted for result in compare_results)
                     results.extend(compare_results)
             # TODO: check results from monitors
         return results
@@ -161,19 +157,20 @@ def cleanup(self):
         pass
 
     def dropcaches(self):
-        nodes = settings.getnodes('clients', 'osds') 
+        nodes = settings.getnodes('clients', 'osds')
 
         common.pdsh(nodes, 'sync').communicate()
         common.pdsh(nodes, 'echo 3 | sudo tee /proc/sys/vm/drop_caches').communicate()
 
     def __str__(self):
         return str(self.config)
 
+
 class DataAnalyzer(ABC):
     def __init__(self, archive_dir, run, host, proc):
         super().__init__()
         self.archive_dir = archive_dir
-    
+
     @abstractmethod
     def get_cpu_cycles_per_op(self):
         pass
@@ -189,7 +186,7 @@ def get_bandwidth(self):
     @abstractmethod
     def get_iops_avg(self):
         pass
-    
+
     @abstractmethod
     def get_iops_stddev(self):
         pass

benchmark/cephtestrados.py

@@ -1,16 +1,13 @@
-import subprocess
+from .benchmark import Benchmark
 import common
 import settings
 import monitoring
 import os
 import time
-import threading
 import logging
 
 logger = logging.getLogger('cbt')
 
-from cluster.ceph import Ceph
-from .benchmark import Benchmark
 
 class CephTestRados(Benchmark):
 
@@ -20,10 +17,14 @@ def __init__(self, archive_dir, cluster, config):
         self.tmp_conf = self.cluster.tmp_conf
 
         self.bools = {}
-        if config.get('ec_pool', False):  self.bools['ec_pool'] = True
-        if config.get('write_fadvise_dontneed', False): self.bools['write_fadvise_dontneed'] = True
-        if config.get('pool_snaps', False): self.bools['pool_snaps'] = True
-        if config.get('write_append_excl', True): self.bools['write_append_excl'] = True
+        if config.get('ec_pool', False):
+            self.bools['ec_pool'] = True
+        if config.get('write_fadvise_dontneed', False):
+            self.bools['write_fadvise_dontneed'] = True
+        if config.get('pool_snaps', False):
+            self.bools['pool_snaps'] = True
+        if config.get('write_append_excl', True):
+            self.bools['write_append_excl'] = True
 
         self.variables = {}
         self.variables['object_size'] = int(config.get('object_size', 4000000))
@@ -35,8 +36,7 @@ def __init__(self, archive_dir, cluster, config):
         self.variables['max_stride_size'] = str(config.get('max_stride_size', self.variables['object_size'] / 5))
         self.variables['max_seconds'] = str(config.get('max_seconds', 0))
 
-
-        self.weights = {'read': 100, 'write':100, 'delete':10}
+        self.weights = {'read': 100, 'write': 100, 'delete': 10}
         for weight in ['snap_create', 'snap_remove', 'rollback', 'setattr', 'rmattr', 'watch', 'copy_from', 'hit_set_list', 'is_dirty', 'cache_flush', 'cache_try_flush', 'cache_evict' 'append', 'write', 'read', 'delete']:
             self.addweight(weight)
         if 'write_append_excl' in self.bools and 'append' in self.weights:
@@ -64,12 +64,12 @@ def exists(self):
         return False
 
     # Initialize may only be called once depending on rebuild_every_test setting
-    def initialize(self): 
+    def initialize(self):
         super(CephTestRados, self).initialize()
 
     def run(self):
         super(CephTestRados, self).run()
-        
+
         # Remake the pool
         self.mkpool()
         self.dropcaches()
@@ -122,7 +122,7 @@ def mkpool(self):
         self.cluster.mkpool('ceph_test_rados', self.pool_profile, 'ceph_test_rados')
         monitoring.stop()
 
-    def recovery_callback(self): 
+    def recovery_callback(self):
         common.pdsh(settings.getnodes('clients'), 'sudo pkill -f ceph_test_rados').communicate()
 
     def __str__(self):

benchmark/cosbench.py

@@ -1,20 +1,18 @@
-import subprocess
 import common
 import settings
 import monitoring
-import os, sys
+import os
+import sys
 import time
-import threading
 import lxml.etree as ET
 import re
-import time
 import logging
 
-from cluster.ceph import Ceph
 from .benchmark import Benchmark
 
 logger = logging.getLogger("cbt")
 
+
 class Cosbench(Benchmark):
 
     def __init__(self, archive_dir, cluster, config):
@@ -32,7 +30,7 @@ def __init__(self, archive_dir, cluster, config):
         self.use_existing = settings.cluster.get('use_existing')
         self.is_teuthology = settings.cluster.get('is_teuthology', False)
 
-        self.run_dir = '%s/osd_ra-%08d/op_size-%s/concurrent_procs-%03d/containers-%05d/objects-%05d/%s' % (self.run_dir, int(self.osd_ra), self.op_size, int(self.total_procs), int(self.containers),int(self.objects), self.mode)
+        self.run_dir = '%s/osd_ra-%08d/op_size-%s/concurrent_procs-%03d/containers-%05d/objects-%05d/%s' % (self.run_dir, int(self.osd_ra), self.op_size, int(self.total_procs), int(self.containers), int(self.objects), self.mode)
         self.out_dir = self.archive_dir
 
     def _filter_ssh_output(self, output):
@@ -62,10 +60,10 @@ def _do_ctrl(self, cmd_fmt, **kwargs):
         return stdout, stderr
 
     def prerun_check(self):
-        #1. check cosbench
+        # 1. check cosbench
         if not self.check_workload_status():
             sys.exit()
-        #2. check rgw
+        # 2. check rgw
         cosconf = {}
         for param in self.config["auth"].split(';'):
             try:
@@ -97,7 +95,7 @@ def prerun_check(self):
         if re.search("AccessDenied", stdout):
             logger.error("Cosbench connect to Radosgw Auth Failed\n%s", stdout)
             sys.exit()
-        #3. check if container and obj created
+        # 3. check if container and obj created
         target_name = "%s-%s-%s" % (self.config["obj_size"], self.config["mode"], self.config["objects_max"])
         container_count = 0
         stdout, stderr = common.pdsh(self.rgw, "swift -A %s -U %s -K %s list" % (cosconf["url"], cosconf["username"], cosconf["password"])).communicate()
@@ -120,11 +118,11 @@ def exists(self):
         return False
 
     def choose_template(self, temp_name, conf):
-        ratio = { "read": 0, "write": 0 }
+        ratio = {"read": 0, "write": 0}
         if conf["mode"] == "read" or conf["mode"] == "write":
             mode = [conf["mode"]]
             ratio[conf["mode"]] = 100
-        elif conf["mode"]  == "mix":
+        elif conf["mode"] == "mix":
             mode = ["read", "write"]
             ratio["read"] = conf["ratio"]
             ratio["write"] = 100 - conf["ratio"]
@@ -135,24 +133,24 @@ def choose_template(self, temp_name, conf):
         operation = []
         for tmp_mode in mode:
             operation.append({
-                "config":"containers=%s;objects=%s;cprefix=%s-%s-%s;sizes=c(%s)%s"
-                %(conf["containers"], conf["objects"], conf["obj_size"], conf["mode"], conf["objects_max"], conf["obj_size_num"], conf["obj_size_unit"]),
-                "ratio":ratio[tmp_mode],
-                "type":tmp_mode
+                "config": "containers=%s;objects=%s;cprefix=%s-%s-%s;sizes=c(%s)%s"
+                % (conf["containers"], conf["objects"], conf["obj_size"], conf["mode"], conf["objects_max"], conf["obj_size_num"], conf["obj_size_unit"]),
+                "ratio": ratio[tmp_mode],
+                "type": tmp_mode
             })
 
         template = {
-            "default":{
+            "default": {
                 "description": conf["mode"],
                 "name": "%s_%scon_%sobj_%s_%dw" % (conf["mode"], conf["containers_max"], conf["objects_max"], conf["obj_size"], conf["workers"]),
-                "storage": {"type":"swift", "config":"timeout=300000" },
-                "auth": {"type":"swauth", "config":"%s" % (conf["auth"])},
+                "storage": {"type": "swift", "config": "timeout=300000"},
+                "auth": {"type": "swauth", "config": "%s" % (conf["auth"])},
                 "workflow": {
                     "workstage": [{
                         "name": "main",
-                        "work": {"rampup":conf["rampup"], "rampdown":conf["rampdown"], "name":conf["obj_size"], "workers":conf["workers"], "runtime":conf["runtime"],
-                            "operation":operation
-                        }
+                        "work": {"rampup": conf["rampup"], "rampdown":conf["rampdown"], "name":conf["obj_size"], "workers":conf["workers"], "runtime":conf["runtime"],
+                                 "operation":operation
+                                 }
                     }]
                 }
             }
@@ -162,19 +160,19 @@ def choose_template(self, temp_name, conf):
 
     def parse_conf(self, conf):
         if "containers" in conf:
-            m = re.findall("(\w{1})\((\d+),(\d+)\)", conf["containers"])
+            m = re.findall(r"(\w{1})\((\d+),(\d+)\)", conf["containers"])
             if m:
                 conf["containers_method"] = m[0][0]
                 conf["containers_min"] = m[0][1]
                 conf["containers_max"] = m[0][2]
         if "objects" in conf:
-            m = re.findall("(\w{1})\((\d+),(\d+)\)", conf["objects"])
+            m = re.findall(r"(\w{1})\((\d+),(\d+)\)", conf["objects"])
             if m:
                 conf["objects_method"] = m[0][0]
                 conf["objects_min"] = m[0][1]
                 conf["objects_max"] = m[0][2]
         if "obj_size" in conf:
-            m = re.findall("(\d+)(\w+)", conf["obj_size"])
+            m = re.findall(r"(\d+)(\w+)", conf["obj_size"])
             if m:
                 conf["obj_size_num"] = m[0][0]
                 conf["obj_size_unit"] = m[0][1]
@@ -205,14 +203,14 @@ def initialize(self):
         if not self.container_prepare_check():
             workstage_init = {
                 "name": "init",
-                "work": {"type":"init", "workers":conf["workers"], "config":"containers=r(1,%s);cprefix=%s-%s-%s" % (conf["containers_max"], conf["obj_size"], conf["mode"], conf["objects_max"])}
+                "work": {"type": "init", "workers": conf["workers"], "config": "containers=r(1,%s);cprefix=%s-%s-%s" % (conf["containers_max"], conf["obj_size"], conf["mode"], conf["objects_max"])}
             }
             workstage_prepare = {
-                "name":"prepare",
+                "name": "prepare",
                 "work": {
-                    "type":"prepare",
-                    "workers":conf["workers"],
-                    "config":"containers=r(1,%s);objects=r(1,%s);cprefix=%s-%s-%s;sizes=c(%s)%s" %
+                    "type": "prepare",
+                    "workers": conf["workers"],
+                    "config": "containers=r(1,%s);objects=r(1,%s);cprefix=%s-%s-%s;sizes=c(%s)%s" %
                     (conf["containers_max"], conf["objects_max"], conf["obj_size"], conf["mode"], conf["objects_max"], conf["obj_size_num"], conf["obj_size_unit"])
                 }
             }
@@ -224,15 +222,15 @@ def initialize(self):
     def container_prepare_check(self):
         return self.container_prepared
 
-    #function use_template, set_leaf and run_content, add_leaf_to_tree all used for generate a cosbench xml.
+    # function use_template, set_leaf and run_content, add_leaf_to_tree all used for generate a cosbench xml.
     def prepare_xml(self, leaves):
         conf = self.config
         root = ET.Element("workload")
         parent = root
         self.add_leaf_to_tree(leaves, parent)
         self.config["xml_name"] = leaves["name"]
         tree = ET.ElementTree(root)
-        tree.write("%s/%s.xml" % (conf["cosbench_xml_dir"], leaves["name"]),pretty_print=True)
+        tree.write("%s/%s.xml" % (conf["cosbench_xml_dir"], leaves["name"]), pretty_print=True)
         logger.info("Write xml conf to %s/%s.xml", conf["cosbench_xml_dir"], leaves["name"])
 
     def add_leaf_to_tree(self, leaves, parent):
@@ -258,7 +256,7 @@ def run(self):
         except KeyboardInterrupt:
             logger.warning("accept keyboard interrupt, cancel this run")
             conf = self.config
-            stdout, stderr = common.pdsh(conf["controller"],'sh %s/cli.sh cancel %s' % (conf["cosbench_dir"], self.runid)).communicate()
+            stdout, stderr = common.pdsh(conf["controller"], 'sh %s/cli.sh cancel %s' % (conf["cosbench_dir"], self.runid)).communicate()
             logger.info("%s", stdout)
 
         self.check_workload_status()
@@ -295,7 +293,7 @@ def check_workload_status(self):
         return True
 
     def check_cosbench_res_dir(self):
-        #check res dir
+        # check res dir
         check_time = 0
         while True:
             stdout, stderr = self._do_ctrl("find {cosbench_dir}/archive -maxdepth 1 -name '{runid}-*'",
@@ -314,13 +312,13 @@ def _run(self):
                                        cosbench_dir=conf["cosbench_dir"],
                                        cosbench_xml_dir=conf["cosbench_xml_dir"],
                                        xml_name=conf["xml_name"])
-        m = re.findall('Accepted with ID:\s*(\w+)', stdout)
+        m = re.findall(r'Accepted with ID:\s*(\w+)', stdout)
         if not m:
             logger.error("cosbench start failing with error: %s", stderr)
             sys.exit()
         self.runid = m[0]
         logger.info("cosbench job start, job number %s", self.runid)
-        wait_time = conf["rampup"]+conf["rampdown"]+conf["runtime"] 
+        wait_time = conf["rampup"] + conf["rampdown"] + conf["runtime"]
         logger.info("====== cosbench job: %s started ======", conf["xml_name"])
         logger.info("wait %d secs to finish the test", wait_time)
         logger.info("You can monitor the runtime status and results on http://localhost:19088/controller")