Esempio n. 1
0
    def update_state(self, expr_data):
        """Update the state of each alarm under this alarm definition."""

        def _calc_state(operand):
            if operand.logic_operator:
                subs = []
                for o in operand.sub_expr_list:
                    subs.append(_calc_state(o))
                return calculator.calc_logic(operand.logic_operator, subs)
            else:
                return expr_data["data"][operand.fmtd_sub_expr_str]["state"]

        for sub_expr in self.sub_expr_list:
            self.update_sub_expr_state(sub_expr, expr_data)
        state_new = _calc_state(self.parse_result)
        if state_new != expr_data["state"]:
            expr_data["state_update_timestamp"] = tu.utcnow_ts()
            expr_data["update_timestamp"] = tu.utcnow_ts()
            expr_data["state"] = state_new
            return True
        else:
            return False
Esempio n. 2
0
 def create_data_item(self, name):
     """If new match_up tuple, create new entry to store metrics value."""
     ts = tu.utcnow_ts()
     self.expr_data_queue[name] = {
         "data": {},
         "state": "UNDETERMINED",
         "create_timestamp": ts,
         "update_timestamp": ts,
         "state_update_timestamp": ts,
     }
     for expr in self.sub_expr_list:
         self.expr_data_queue[name]["data"][expr.fmtd_sub_expr_str] = {
             "state": "UNDETERMINED",
             "metrics": collections.deque(),
             "values": [],
         }
Esempio n. 3
0
 def update_data():
     # inherit previous stored metrics values
     for name in self.expr_data_queue:
         ts = tu.utcnow_ts()
         new_expr_data_queue[name] = {
             "data": {},
             "state": "UNDETERMINED",
             "create_timestamp": self.expr_data_queue[name]["create_timestamp"],
             "update_timestamp": ts,
             "state_update_timestamp": self.expr_data_queue[name]["state_update_timestamp"],
         }
         for i in range(0, len(new_sub_expr_list), 1):
             expr_old = self.sub_expr_list[i].fmtd_sub_expr_str
             expr_new = new_sub_expr_list[i].fmtd_sub_expr_str
             new_expr_data_queue[name]["data"][expr_new] = {
                 "state": "UNDETERMINED",
                 "metrics": (self.expr_data_queue[name]["data"][expr_old]["metrics"]),
                 "values": [],
             }
Esempio n. 4
0
    def update_sub_expr_state(self, expr, expr_data):
        def _update_metrics():
            """Delete metrics not in period."""
            data_list = expr_data["data"][expr.fmtd_sub_expr_str]["metrics"]
            start_time = t_now - (float(expr.period)) * int(expr.periods)
            while len(data_list) != 0 and data_list[0]["timestamp"] < start_time:
                data_list.popleft()

        def _update_state():
            """Update state of a sub expr."""
            data_sub = expr_data["data"][expr.fmtd_sub_expr_str]
            data_list = data_sub["metrics"]
            period = float(expr.period)
            periods = int(expr.periods)
            right = t_now
            left = right - period
            temp_data = []
            value_in_periods = []
            i = len(data_list) - 1
            while i >= 0:
                if data_list[i]["timestamp"] >= left:
                    temp_data.append(float(data_list[i]["value"]))
                else:
                    value = calculator.calc_value(expr.normalized_func, temp_data)
                    value_in_periods.append(value)
                    right = left
                    left = right - period
                    temp_data = []
                    i += 1
                i -= 1
            value = calculator.calc_value(expr.normalized_func, temp_data)
            value_in_periods.append(value)
            for i in range(len(value_in_periods), periods, 1):
                value_in_periods.append(calculator.calc_value(expr.normalized_func, []))
            expr_data["data"][expr.fmtd_sub_expr_str]["values"] = value_in_periods
            expr_data["data"][expr.fmtd_sub_expr_str]["state"] = calculator.compare_thresh(
                value_in_periods, expr.normalized_operator, float(expr.threshold)
            )

        t_now = tu.utcnow_ts()
        _update_metrics()
        _update_state()
Esempio n. 5
0
 def _add_metrics():
     temp = None
     if self.match_by:
         q_name = self.get_matched_data_queue_name(data)
         if q_name:
             temp = self.expr_data_queue[q_name]
     else:
         if None not in self.expr_data_queue:
             self.create_data_item(None)
         temp = self.expr_data_queue[None]
     if temp:
         data_list = temp["data"][expr.fmtd_sub_expr_str]
         data_list["metrics"].append({"value": float(data["value"]), "timestamp": tu.utcnow_ts()})
         return True
     else:
         return False
 def get_metrics(self, name):
     ts = self.test_cases["metrics"][name]
     for t in ts:
         o = t["time_offset"]
         t["timestamp"] = tu.utcnow_ts() + o
         yield json.dumps(t)