NFVBENCH-184: Add a feature (+ options) allowing to change ownership of shared log...

[nfvbench.git] / nfvbench / utils.py

diff --git a/nfvbench/utils.py b/nfvbench/utils.py
index d4482fd..6da14ed 100644 (file)
--- a/nfvbench/utils.py
+++ b/nfvbench/utils.py
@@ -13,6 +13,7 @@
 #    under the License.
 
 import glob
+from math import gcd
 from math import isnan
 import os
 import re
@@ -24,7 +25,7 @@ import fcntl
 from functools import wraps
 import json
 from .log import LOG
-
+from nfvbench.traffic_gen.traffic_utils import multiplier_map
 
 class TimeoutError(Exception):
     pass
@@ -50,7 +51,7 @@ def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):
 
 
 def save_json_result(result, json_file, std_json_path, service_chain, service_chain_count,
-                     flow_count, frame_sizes):
+                     flow_count, frame_sizes, user_id=None, group_id=None):
     """Save results in json format file."""
     filepaths = []
     if json_file:
@@ -70,22 +71,11 @@ def save_json_result(result, json_file, std_json_path, service_chain, service_ch
                           sort_keys=True,
                           separators=(',', ': '),
                           default=lambda obj: obj.to_json())
-
-
-def byteify(data, ignore_dicts=False):
-    # if this is a unicode string, return its string representation
-    if isinstance(data, str):
-        return data.encode('utf-8')
-    # if this is a list of values, return list of byteified values
-    if isinstance(data, list):
-        return [byteify(item, ignore_dicts=ignore_dicts) for item in data]
-    # if this is a dictionary, return dictionary of byteified keys and values
-    # but only if we haven't already byteified it
-    if isinstance(data, dict) and not ignore_dicts:
-        return {byteify(key, ignore_dicts=ignore_dicts): byteify(value, ignore_dicts=ignore_dicts)
-                for key, value in list(data.items())}
-    # if it's anything else, return it in its original form
-    return data
+                # possibly change file ownership
+                if group_id is None:
+                    group_id = user_id
+                if user_id is not None:
+                    os.chown(file_path, user_id, group_id)
 
 
 def dict_to_json_dict(record):
@@ -170,13 +160,6 @@ def get_intel_pci(nic_slot=None, nic_ports=None):
     return pcis
 
 
-multiplier_map = {
-    'K': 1000,
-    'M': 1000000,
-    'G': 1000000000
-}
-
-
 def parse_flow_count(flow_count):
     flow_count = str(flow_count)
     input_fc = flow_count
@@ -188,13 +171,14 @@ def parse_flow_count(flow_count):
     try:
         flow_count = int(flow_count)
     except ValueError:
-        raise Exception("Unknown flow count format '{}'".format(input_fc))
+        raise Exception("Unknown flow count format '{}'".format(input_fc)) from ValueError
 
     return flow_count * multiplier
 
 
 def cast_integer(value):
-    return int(value) if not isnan(value) else value
+    # force 0 value if NaN value from TRex to avoid error in JSON result parsing
+    return int(value) if not isnan(value) else 0
 
 
 class RunLock(object):
@@ -211,8 +195,8 @@ class RunLock(object):
         try:
             self._fd = os.open(self._path, os.O_CREAT)
             fcntl.flock(self._fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        except (OSError, IOError):
-            raise Exception('Other NFVbench process is running. Please wait')
+        except (OSError, IOError) as e:
+            raise Exception('Other NFVbench process is running. Please wait') from e
 
     def __exit__(self, *args):
         fcntl.flock(self._fd, fcntl.LOCK_UN)
@@ -224,3 +208,46 @@ class RunLock(object):
             os.unlink(self._path)
         except (OSError, IOError):
             pass
+
+
+def get_divisors(n):
+    for i in range(1, int(n / 2) + 1):
+        if n % i == 0:
+            yield i
+    yield n
+
+
+def lcm(a, b):
+    """
+    Calculate the maximum possible value for both IP and ports,
+    eventually for maximum possible flow.
+    """
+    if a != 0 and b != 0:
+        lcm_value = a * b // gcd(a, b)
+        return lcm_value
+    raise TypeError(" IP size or port range can't be zero !")
+
+
+def find_tuples_equal_to_lcm_value(a, b, lcm_value):
+    """
+    Find numbers from two list matching a LCM value.
+    """
+    for x in a:
+        for y in b:
+            if lcm(x, y) == lcm_value:
+                yield (x, y)
+
+
+def find_max_size(max_size, tuples, flow):
+    if tuples:
+        if max_size > tuples[-1][0]:
+            max_size = tuples[-1][0]
+            return int(max_size)
+        if max_size > tuples[-1][1]:
+            max_size = tuples[-1][1]
+            return int(max_size)
+
+    for i in range(max_size, 1, -1):
+        if flow % i == 0:
+            return int(i)
+    return 1