yardstick/benchmark/scenarios/availability/monitor/basemonitor.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd. and others
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9 from __future__ import absolute_import
  10 import pkg_resources
  11 import logging
  12 import multiprocessing
  13 import time
  14 import os
  15 import yardstick.common.utils as utils
  16
  17 from yardstick.common.yaml_loader import yaml_load
  18
  19 LOG = logging.getLogger(__name__)
  20
  21 monitor_conf_path = pkg_resources.resource_filename(
  22     "yardstick.benchmark.scenarios.availability",
  23     "monitor_conf.yaml")
  24
  25
  26 class MonitorMgr(object):
  27     """docstring for MonitorMgr"""
  28
  29     def __init__(self, data):
  30         self._monitor_list = []
  31         self.monitor_mgr_data = data
  32
  33     def init_monitors(self, monitor_cfgs, context):
  34         LOG.debug("monitorMgr config: %s", monitor_cfgs)
  35
  36         for monitor_cfg in monitor_cfgs:
  37             monitor_type = monitor_cfg["monitor_type"]
  38             monitor_cls = BaseMonitor.get_monitor_cls(monitor_type)
  39
  40             monitor_number = monitor_cfg.get("monitor_number", 1)
  41             if monitor_number > 1:
  42                 monitor_cls = BaseMonitor.get_monitor_cls("multi-monitor")
  43
  44             monitor_ins = monitor_cls(monitor_cfg, context,
  45                                       self.monitor_mgr_data)
  46             if "key" in monitor_cfg:
  47                 monitor_ins.tag = monitor_ins.key = monitor_cfg["key"]
  48             elif monitor_type == "openstack-cmd":
  49                 monitor_ins.tag = monitor_cfg["command_name"].replace(" ", "-")
  50             elif monitor_type == "process":
  51                 monitor_ins.tag = monitor_type + "_" + monitor_cfg["process_name"]
  52             self._monitor_list.append(monitor_ins)
  53
  54     def __getitem__(self, item):
  55         for obj in self._monitor_list:
  56             if obj.key == item:
  57                 return obj
  58         raise KeyError("No such monitor instance of key - %s" % item)
  59
  60     def start_monitors(self):
  61         for _monotor_instace in self._monitor_list:
  62             _monotor_instace.start_monitor()
  63
  64     def wait_monitors(self):
  65         for monitor in self._monitor_list:
  66             monitor.wait_monitor()
  67
  68     def verify_SLA(self):
  69         sla_pass = True
  70         for monitor in self._monitor_list:
  71             sla_pass = sla_pass & monitor.verify_SLA()
  72         return sla_pass
  73
  74     def store_result(self, result):
  75         for monitor in self._monitor_list:
  76             monitor_result = monitor.get_result()
  77             for k, v in monitor_result.items():
  78                 result[monitor.tag + "_" + k] = v
  79
  80
  81 class BaseMonitor(multiprocessing.Process):
  82     """docstring for BaseMonitor"""
  83     monitor_cfgs = {}
  84
  85     def __init__(self, config, context, data):
  86         if not BaseMonitor.monitor_cfgs:
  87             with open(monitor_conf_path) as stream:
  88                 BaseMonitor.monitor_cfgs = yaml_load(stream)
  89         multiprocessing.Process.__init__(self)
  90         self._config = config
  91         self._context = context
  92         self._queue = multiprocessing.Queue()
  93         self._event = multiprocessing.Event()
  94         self.monitor_data = data
  95         self.setup_done = False
  96         self.tag = ""
  97         self.intermediate_variables = {}
  98
  99     @staticmethod
 100     def get_monitor_cls(monitor_type):
 101         """return monitor class of specified type"""
 102
 103         for monitor in utils.itersubclasses(BaseMonitor):
 104             if monitor_type == monitor.__monitor_type__:
 105                 return monitor
 106         raise RuntimeError("No such monitor_type: %s" % monitor_type)
 107
 108     def get_script_fullpath(self, path):
 109         base_path = os.path.dirname(monitor_conf_path)
 110         return os.path.join(base_path, path)
 111
 112     def run(self):
 113         LOG.debug("config:%s context:%s", self._config, self._context)
 114
 115         self.setup()
 116         monitor_time = self._config.get("monitor_time", 0)
 117
 118         total_time = 0
 119         outage_time = 0
 120         total_count = 0
 121         outage_count = 0
 122         first_outage = 0
 123         last_outage = 0
 124
 125         begin_time = time.time()
 126         while True:
 127             total_count = total_count + 1
 128
 129             one_check_begin_time = time.time()
 130             exit_status = self.monitor_func()
 131             one_check_end_time = time.time()
 132
 133             if exit_status is False:
 134                 outage_count = outage_count + 1
 135
 136                 outage_time = outage_time + (
 137                     one_check_end_time - one_check_begin_time)
 138
 139                 if not first_outage:
 140                     first_outage = one_check_begin_time
 141
 142                 last_outage = one_check_end_time
 143
 144             if self._event.is_set():
 145                 LOG.debug("the monitor process stop")
 146                 break
 147
 148             if one_check_end_time - begin_time > monitor_time:
 149                 LOG.debug("the monitor max_time finished and exit!")
 150                 break
 151
 152         end_time = time.time()
 153         total_time = end_time - begin_time
 154
 155         self._queue.put({"total_time": total_time,
 156                          "outage_time": last_outage - first_outage,
 157                          "last_outage": last_outage,
 158                          "first_outage": first_outage,
 159                          "total_count": total_count,
 160                          "outage_count": outage_count})
 161
 162     def start_monitor(self):
 163         self.start()
 164
 165     def wait_monitor(self):
 166         self.join()
 167         self._result = self._queue.get()
 168         LOG.debug("the monitor result:%s", self._result)
 169
 170     def setup(self):  # pragma: no cover
 171         pass
 172
 173     def monitor_func(self):  # pragma: no cover
 174         pass
 175
 176     def verify_SLA(self):
 177         pass
 178
 179     def get_result(self):
 180         return self._result