Example #1
0
def create_statistic_entity(s_type, actual, expected, state):
    msg = RatedStatisticsEntity()
    msg.statistic_type = s_type
    msg.actual_value = actual
    msg.expected_value = expected
    msg.state = state
    return msg
Example #2
0
    def to_msg_type(self):
        """
        Creates a RatedStatisticsContainer messagetype based on the current data.

        :return: A RatedStatisticsContainer object from the current data.
        """
        r = RatedStatistics()
        r.seuid = self.seuid
        if self.seuid[0] == "h":
            r.host = self.seuid[2:]
        else:
            r.host = self.host
        try:
            r.window_start = self.get_value("window_start")["actual"]
            r.window_stop = self.get_value("window_stop")["actual"]
        except KeyError:
            r.window_start = r.window_stop = None
        for k in self.keys():
            if k in ("host", "node", "node_sub", "node_pub", "topic",
                     "window_start", "window_stop"):
                continue
            re = RatedStatisticsEntity()
            re.statistic_type = k
            re.state = []
            values = self.get_value(k)
            if isinstance(values["actual"], (list, tuple)):
                for i, v in enumerate(values["actual"]):
                    re.actual_value.append(
                        prepare_number_for_representation(v))
                    try:
                        re.state.append(values["state"][i])
                        re.expected_value.append(
                            prepare_number_for_representation(
                                values["expected"][i]))
                    except TypeError:
                        re.state.append(values["state"])
                        re.expected_value.append("?")
            else:
                re.actual_value.append(
                    prepare_number_for_representation(values["actual"]))
                re.state.append(values["state"])
                if values["expected"] is None:
                    re.expected_value.append("?")
                else:
                    re.expected_value.append(
                        prepare_number_for_representation(values["expected"]))
            r.rated_statistics_entity.append(re)
        return r
Example #3
0
    def to_msg_type(self):
        """
        Creates a RatedStatisticsContainer messagetype based on the current data.

        :return: A RatedStatisticsContainer object from the current data.
        """
        r = RatedStatistics()
        r.seuid = self.seuid
        if self.seuid[0] == "h":
            r.host = self.seuid[2:]
        else:
            r.host = self.host
        try:
            r.window_start = self.get_value("window_start")["actual"]
            r.window_stop = self.get_value("window_stop")["actual"]
        except KeyError:
            r.window_start = r.window_stop = None
        for k in self.keys():
            if k in ("host", "node", "node_sub", "node_pub", "topic", "window_start", "window_stop"):
                continue
            re = RatedStatisticsEntity()
            re.statistic_type = k
            re.state = []
            values = self.get_value(k)
            if isinstance(values["actual"], (list, tuple)):
                for i, v in enumerate(values["actual"]):
                    re.actual_value.append(prepare_number_for_representation(v))
                    try:
                        re.state.append(values["state"][i])
                        re.expected_value.append(prepare_number_for_representation(values["expected"][i]))
                    except TypeError:
                        re.state.append(values["state"])
                        re.expected_value.append("?")
            else:
                re.actual_value.append(prepare_number_for_representation(values["actual"]))
                re.state.append(values["state"])
                if values["expected"] is None:
                    re.expected_value.append("?")
                else:
                    re.expected_value.append(prepare_number_for_representation(values["expected"]))
            r.rated_statistics_entity.append(re)
        return r
Example #4
0
def create_statistic_entity(s_type, actual, expected, state):
    msg = RatedStatisticsEntity()
    msg.statistic_type = s_type
    msg.actual_value = actual
    msg.expected_value = expected
    msg.state = state
    return msg
Example #5
0
def create_statistic_entity():
    msg = RatedStatisticsEntity()
    msg.statistic_type = "cpu_usage_mean"
    msg.actual_value = ["56.6"]
    msg.expected_value = ["0 - 50"]
    msg.state = [0]
    return msg
Example #6
0
    def compare_topic(self, data=None):
        """
        Compares Messages about one topic

        :param data: List of Statistics messages
        :return: list of RatedStatistics messages
        """
        if not data:
            data = []
        by_connection = {}
        by_topic = {}
        result = []
        frequency_set = False
        for message in data:
            seuid = SEUID(message)
            if not seuid.identifier in by_connection.keys():
                by_connection[seuid.identifier] = {
                    "window_min": rospy.Time.now(),
                    "window_max": rospy.Time(0),
                    "dropped_msgs": 0,
                    "frequency": 0,
                    "traffic": 0,
                    "bandwidth": 0,
                    "stamp_age_mean": rospy.Duration(0),
                    "stamp_age_stddev": rospy.Duration(0),
                    "stamp_age_max": rospy.Duration(0),
                    "count": 0,
                }
            by_connection[seuid.identifier]["count"] += 1
            window_len = message.window_stop - message.window_start
            if window_len.to_sec() == 0:
                window_len = rospy.Duration(1)
            by_connection[seuid.identifier]["window_min"] = min(
                message.window_start, by_connection[seuid.identifier]["window_min"]
            )
            by_connection[seuid.identifier]["window_max"] = max(
                message.window_stop, by_connection[seuid.identifier]["window_max"]
            )
            if hasattr(message, "delivered_msgs"):
                frequency_set = True
                by_connection[seuid.identifier]["frequency"] += message.delivered_msgs / float(window_len.to_sec())
            by_connection[seuid.identifier]["dropped_msgs"] += message.dropped_msgs
            by_connection[seuid.identifier]["traffic"] += message.traffic
            by_connection[seuid.identifier]["bandwidth"] += message.traffic / float(window_len.to_sec())
            by_connection[seuid.identifier]["stamp_age_max"] = max(
                message.stamp_age_max, by_connection[seuid.identifier]["stamp_age_max"]
            )
            by_connection[seuid.identifier]["stamp_age_mean"] += message.stamp_age_mean
            # TODO by_connection[seuid.identifier]["stamp_age_stddev"]
        for connection in by_connection:
            seuid = SEUID(connection)
            for key in "frequency", "bandwidth", "dropped_msgs", "traffic", "stamp_age_mean":  # average
                by_connection[connection][key] /= by_connection[connection]["count"]

            topic = seuid.get_seuid("topic")
            if not topic in by_topic.keys():
                by_topic[topic] = {
                    "window_min": rospy.Time.now(),
                    "window_max": rospy.Time(0),
                    "dropped_msgs": 0,
                    "frequency": 0,
                    "traffic": 0,
                    "bandwidth": 0,
                    "stamp_age_mean": rospy.Duration(0),
                    "stamp_age_stddev": rospy.Duration(0),
                    "stamp_age_max": rospy.Duration(0),
                    "count": 0,
                }
            by_topic[topic]["count"] += 1
            by_topic[topic]["window_min"] = min(by_connection[connection]["window_min"], by_topic[topic]["window_min"])
            by_topic[topic]["window_max"] = max(by_connection[connection]["window_max"], by_topic[topic]["window_max"])
            if "frequency" in by_connection[connection]:
                frequency_set = True
                by_topic[topic]["frequency"] += by_connection[connection]["frequency"]
            by_topic[topic]["dropped_msgs"] += by_connection[connection]["dropped_msgs"]
            by_topic[topic]["traffic"] += by_connection[connection]["traffic"]
            by_topic[topic]["bandwidth"] += by_connection[connection]["bandwidth"]
            by_topic[topic]["stamp_age_max"] = max(
                by_connection[connection]["stamp_age_max"], by_topic[topic]["stamp_age_max"]
            )
            by_topic[topic]["stamp_age_mean"] += by_connection[connection]["stamp_age_mean"]
            # TODO by_connection[seuid.identifier]["stamp_age_stddev"]
        for topic in by_topic:
            by_topic[topic]["stamp_age_mean"] /= by_topic[topic]["count"]
        for topic, data in by_topic.iteritems():
            specification = self.get(topic)
            r = RatedStatistics()
            r.window_start = data["window_min"]
            r.window_stop = data["window_max"]
            window_len = data["window_max"] - data["window_min"]
            if window_len.to_sec() == 0:
                window_len = rospy.Duration(1)
            r.seuid = topic
            fields = ["dropped_msgs", "traffic", "bandwidth", "stamp_age_max", "stamp_age_mean"]
            fields.remove("traffic")
            if frequency_set:
                fields.append("frequency")
            for f in fields:
                re = RatedStatisticsEntity()
                re.statistic_type = f
                value = data[f]
                re.actual_value.append(str(value))
                limits = self.__get_limits(specification, re.statistic_type)
                re.expected_value.append(str(limits))
                re.state = [self.__compare(value, limits)]
                r.rated_statistics_entity.append(re)
            re = RatedStatisticsEntity()
            re.statistic_type = "alive"
            re.expected_value = ["True"]
            re.actual_value = ["True"]
            re.state = [2]
            r.rated_statistics_entity.append(re)
            result.append(r)
        return result
Example #7
0
    def compare_topic(self, data=None):
        """
        Compares Messages about one topic

        :param data: List of Statistics messages
        :return: list of RatedStatistics messages
        """
        if not data:
            data = []
        by_connection = {}
        by_topic = {}
        result = []
        frequency_set = False
        for message in data:
            seuid = SEUID(message)
            if not seuid.identifier in by_connection.keys():
                by_connection[seuid.identifier] = {
                    "window_min": rospy.Time.now(),
                    "window_max": rospy.Time(0),
                    "dropped_msgs": 0,
                    "frequency": 0,
                    "traffic": 0,
                    "bandwidth": 0,
                    "stamp_age_mean": rospy.Duration(0),
                    "stamp_age_stddev": rospy.Duration(0),
                    "stamp_age_max": rospy.Duration(0),
                    "count": 0,
                }
            by_connection[seuid.identifier]["count"] += 1
            window_len = message.window_stop - message.window_start
            if window_len.to_sec() == 0:
                window_len = rospy.Duration(1)
            by_connection[seuid.identifier]["window_min"] = min(message.window_start, by_connection[seuid.identifier]["window_min"])
            by_connection[seuid.identifier]["window_max"] = max(message.window_stop, by_connection[seuid.identifier]["window_max"])
            if hasattr(message, "delivered_msgs"):
                frequency_set = True
                by_connection[seuid.identifier]["frequency"] += message.delivered_msgs / float(window_len.to_sec())
            by_connection[seuid.identifier]["dropped_msgs"] += message.dropped_msgs
            by_connection[seuid.identifier]["traffic"] += message.traffic
            by_connection[seuid.identifier]["bandwidth"] += message.traffic / float(window_len.to_sec())
            by_connection[seuid.identifier]["stamp_age_max"] = max(message.stamp_age_max, by_connection[seuid.identifier]["stamp_age_max"])
            by_connection[seuid.identifier]["stamp_age_mean"] += message.stamp_age_mean
            #TODO by_connection[seuid.identifier]["stamp_age_stddev"]
        for connection in by_connection:
            seuid = SEUID(connection)
            for key in 'frequency', 'bandwidth', 'dropped_msgs', 'traffic', 'stamp_age_mean': # average
              by_connection[connection][key] /= by_connection[connection]['count']

            topic = seuid.get_seuid('topic')
            if not topic in by_topic.keys():
                by_topic[topic] = {
                    "window_min": rospy.Time.now(),
                    "window_max": rospy.Time(0),
                    "dropped_msgs": 0,
                    "frequency": 0,
                    "traffic": 0,
                    "bandwidth": 0,
                    "stamp_age_mean": rospy.Duration(0),
                    "stamp_age_stddev": rospy.Duration(0),
                    "stamp_age_max": rospy.Duration(0),
                    'count': 0,
                }
            by_topic[topic]['count'] += 1
            by_topic[topic]["window_min"] = min(by_connection[connection]['window_min'], by_topic[topic]["window_min"])
            by_topic[topic]["window_max"] = max(by_connection[connection]['window_max'], by_topic[topic]["window_max"])
            if "frequency" in by_connection[connection]:
                frequency_set = True
                by_topic[topic]["frequency"] += by_connection[connection]['frequency']
            by_topic[topic]["dropped_msgs"] += by_connection[connection]['dropped_msgs']
            by_topic[topic]["traffic"] += by_connection[connection]['traffic']
            by_topic[topic]["bandwidth"] += by_connection[connection]['bandwidth']
            by_topic[topic]["stamp_age_max"] = max(by_connection[connection]['stamp_age_max'], by_topic[topic]["stamp_age_max"])
            by_topic[topic]["stamp_age_mean"] +=  by_connection[connection]['stamp_age_mean']
            #TODO by_connection[seuid.identifier]["stamp_age_stddev"]
        for topic in by_topic:
          by_topic[topic]['stamp_age_mean'] /= by_topic[topic]['count']
        for topic, data in by_topic.iteritems():
            specification = self.get(topic)
            r = RatedStatistics()
            r.window_start = data["window_min"]
            r.window_stop = data["window_max"]
            window_len = data["window_max"] - data["window_min"]
            if window_len.to_sec() == 0:
                window_len = rospy.Duration(1)
            r.seuid = topic
            fields = ["dropped_msgs", "traffic", "bandwidth", "stamp_age_max", "stamp_age_mean"]
            fields.remove("traffic")
            if frequency_set:
                fields.append("frequency")
            for f in fields:
                re = RatedStatisticsEntity()
                re.statistic_type = f
                value = data[f]
                re.actual_value.append(str(value))
                limits = self.__get_limits(specification, re.statistic_type)
                re.expected_value.append(str(limits))
                re.state = [self.__compare(value, limits)]
                r.rated_statistics_entity.append(re)
            re = RatedStatisticsEntity()
            re.statistic_type = "alive"
            re.expected_value = ["True"]
            re.actual_value = ["True"]
            re.state = [2]
            r.rated_statistics_entity.append(re)
            result.append(r)
        return result