add get_avg_delay_dsitribution

use it for assign_realistic_timestamps

code/Attack/MembersMgmtCommAttack.py

@@ -306,18 +306,18 @@ class MembersMgmtCommAttack(BaseAttack.BaseAttack):
                         else:
                             bot_configs[bot]["TTL"] = self.statistics.process_db_query("most_used(ttlValue)")
 
-        def assign_realistic_timestamps(messages: list, external_ids: set, local_ids: set, avg_delay_local: float,
-                                        avg_delay_external: float, zero_reference: float):
+        def assign_realistic_timestamps(messages: list, external_ids: set, local_ids: set, avg_delay_local: list,
+                                        avg_delay_external: list, zero_reference: float):
             """
             Assigns realistic timestamps to a set of messages
 
             :param messages: the set of messages to be updated
             :param external_ids: the set of bot ids, that are outside the network, i.e. external
             :param local_ids: the set of bot ids, that are inside the network, i.e. local
-            :param avg_delay_local: the avg_delay between the dispatch and the reception of a packet between local
-                                    computers
-            :param avg_delay_external: the avg_delay between the dispatch and the reception of a packet between a local
-                                       and an external computer
+            :param avg_delay_local: the avg_delay distribution between the dispatch and the reception of a packet
+                                    between local computers
+            :param avg_delay_external: the avg_delay distribution between the dispatch and the reception of a packet
+                                       between a local and an external computer
             :param zero_reference: the timestamp which is regarded as the beginning of the pcap_file and therefore
                                    handled like a timestamp that resembles 0
             """
@@ -357,13 +357,13 @@ class MembersMgmtCommAttack(BaseAttack.BaseAttack):
                     # avg delay
                     if req_msg.src in external_ids or req_msg.dst in external_ids:
                         # external communication
-                        respns_msg.time = req_msg.time + avg_delay_external + uniform(-0.1 * avg_delay_external,
-                                                                                      0.1 * avg_delay_external)
+                        external_dist = Lea.fromSeq(avg_delay_external)
+                        respns_msg.time = req_msg.time + float(external_dist.random()) * 0.001
 
                     else:
                         # local communication
-                        respns_msg.time = req_msg.time + avg_delay_local + uniform(-0.1 * avg_delay_local,
-                                                                                   0.1 * avg_delay_local)
+                        local_dist = Lea.fromSeq(avg_delay_local)
+                        respns_msg.time = req_msg.time + float(local_dist.random()) * 0.001
 
                     updated_msgs.append(respns_msg)
                     last_response[(req_msg.src, req_msg.dst)] = respns_msg.time
@@ -562,7 +562,7 @@ class MembersMgmtCommAttack(BaseAttack.BaseAttack):
         zero_reference = self.get_param_value(Param.INJECT_AT_TIMESTAMP) - messages[0].time
 
         # calculate the average delay values for local and external responses
-        avg_delay_local, avg_delay_external = self.statistics.get_avg_delay_local_ext()
+        avg_delay_local, avg_delay_external = self.statistics.get_avg_delay_distributions()
 
         # set timestamps
         assign_realistic_timestamps(messages, external_ids, local_ids, avg_delay_local, avg_delay_external,

code/Core/Statistics.py

@@ -856,10 +856,9 @@ class Statistics:
         else:
             return None
 
-    def get_avg_delay_local_ext(self):
+    def get_avg_delay_distributions(self):
         """
-        Calculates the average delay of a packet for external and local communication, based on the tcp handshakes
-        :return: tuple consisting of avg delay for local and external communication, (local, external)
+        :return: tuple consisting of avg delay distributions for local and external communication
         """
 
         conv_delays = self.stats_db.process_user_defined_query(
@@ -878,54 +877,16 @@ class Statistics:
                 else:
                     local_conv.append(conv)
 
-            # calculate avg local and external delay by summing up the respective delays and dividing them by the
-            # number of conversations
-            avg_delay_external = 0.0
-            avg_delay_local = 0.0
-            default_ext = False
-            default_local = False
-
-            if local_conv:
-                for conv in local_conv:
-                    avg_delay_local += conv[2]
-                avg_delay_local = (avg_delay_local / len(local_conv)) * 0.001  # ms
-            else:
-                # no local conversations in statistics found
-                avg_delay_local = 0.055
-                default_local = True
-
-            if external_conv:
-                for conv in external_conv:
-                    avg_delay_external += conv[2]
-                avg_delay_external = (avg_delay_external / len(external_conv)) * 0.001  # ms
-            else:
-                # no external conversations in statistics found
-                avg_delay_external = 0.09
-                default_ext = True
-        else:
-            # if no statistics were found, use these numbers
-            avg_delay_external = 0.09
-            avg_delay_local = 0.055
-            default_ext = True
-            default_local = True
-
-        # check whether delay numbers are consistent
-        if avg_delay_local > avg_delay_external:
-            avg_delay_external = avg_delay_local * 1.2
-
-        # print information, that (default) values are used, that are not collected from the Input PCAP
-        if default_ext or default_local:
-            if default_ext and default_local:
-                print("Warning: Could not collect average delays for local or external communication, using "
-                      "following values:")
-            elif default_ext:
-                print("Warning: Could not collect average delays for external communication, using following values:")
-            elif default_local:
-                print("Warning: Could not collect average delays for local communication, using following values:")
-        print("Avg delay of external communication: {0}s,  Avg delay of local communication: {1}s".format(
-            avg_delay_external, avg_delay_local))
-
-        return avg_delay_local, avg_delay_external
+            local_dist = []
+            for conv in local_conv:
+                local_dist.append(conv[2])
+
+            external_dist = []
+            for conv in external_conv:
+                external_dist.append(conv[2])
+
+            return local_dist, external_dist
+        return [], []
 
     def get_filtered_degree(self, degree_type: str):
         """