Load Generator component:

- Added parametrization of availability, capacity and latency constraints in services and slices

src/load_generator/command/__main__.py

@@ -36,6 +36,9 @@ def main():
         ],
         offered_load  = 50,
         holding_time  = 10,
+        availability_ranges   = [[0.0, 99.9999]],
+        capacity_gbps_ranges  = [[0.1, 100.00]],
+        e2e_latency_ms_ranges = [[5.0, 100.00]],
         dry_mode      = False,           # in dry mode, no request is sent to TeraFlowSDN
         record_to_dlt = False,           # if record_to_dlt, changes in device/link/service/slice are uploaded to DLT
         dlt_domain_id = 'dlt-perf-eval', # domain used to uploaded entities, ignored when record_to_dlt = False

src/load_generator/load_gen/Parameters.py

@@ -13,18 +13,30 @@
 # limitations under the License.
 
 from typing import List, Optional
+from load_generator.tools.ListScalarRange import Type_ListScalarRange
+
+DEFAULT_AVAILABILITY_RANGES   = [[0.0, 99.9999]]
+DEFAULT_CAPACITY_GBPS_RANGES  = [[0.1, 100.00]]
+DEFAULT_E2E_LATENCY_MS_RANGES = [[5.0, 100.00]]
 
 class Parameters:
     def __init__(
         self, num_requests : int, request_types : List[str], offered_load : Optional[float] = None,
-        inter_arrival_time : Optional[float] = None, holding_time : Optional[float] = None, do_teardown : bool = True,
-        dry_mode : bool = False, record_to_dlt : bool = False, dlt_domain_id : Optional[str] = None
+        inter_arrival_time : Optional[float] = None, holding_time : Optional[float] = None,
+        availability_ranges : Type_ListScalarRange = DEFAULT_AVAILABILITY_RANGES,
+        capacity_gbps_ranges : Type_ListScalarRange = DEFAULT_CAPACITY_GBPS_RANGES,
+        e2e_latency_ms_ranges : Type_ListScalarRange = DEFAULT_E2E_LATENCY_MS_RANGES,
+        do_teardown : bool = True, dry_mode : bool = False,
+        record_to_dlt : bool = False, dlt_domain_id : Optional[str] = None
     ) -> None:
         self._num_requests = num_requests
         self._request_types = request_types
         self._offered_load = offered_load
         self._inter_arrival_time = inter_arrival_time
         self._holding_time = holding_time
+        self._availability_ranges = availability_ranges
+        self._capacity_gbps_ranges = capacity_gbps_ranges
+        self._e2e_latency_ms_ranges = e2e_latency_ms_ranges
         self._do_teardown = do_teardown
         self._dry_mode = dry_mode
         self._record_to_dlt = record_to_dlt
@@ -59,6 +71,15 @@ class Parameters:
     @property
     def holding_time(self): return self._holding_time
 
+    @property
+    def availability_ranges(self): return self._availability_ranges
+
+    @property
+    def capacity_gbps_ranges(self): return self._capacity_gbps_ranges
+
+    @property
+    def e2e_latency_ms_ranges(self): return self._e2e_latency_ms_ranges
+
     @property
     def do_teardown(self): return self._do_teardown
 

src/load_generator/load_gen/RequestGenerator.py

@@ -28,6 +28,7 @@ from common.tools.object_factory.Slice import json_slice
 from common.tools.object_factory.Topology import json_topology_id
 from context.client.ContextClient import ContextClient
 from dlt.connector.client.DltConnectorClient import DltConnectorClient
+from load_generator.tools.ListScalarRange import generate_value
 from .Constants import ENDPOINT_COMPATIBILITY, RequestType
 from .DltTools import record_device_to_dlt, record_link_to_dlt
 from .Parameters import Parameters
@@ -244,9 +245,9 @@ class RequestGenerator:
         ]
 
         if request_type == RequestType.SERVICE_L2NM:
-            availability   = round(random.uniform(0.0, 99.9999), ndigits=5)
-            capacity_gbps  = round(random.uniform(0.1, 100.00), ndigits=2)
-            e2e_latency_ms = round(random.uniform(5.0, 100.00), ndigits=2)
+            availability   = generate_value(self._parameters.availability_ranges,   ndigits=5)
+            capacity_gbps  = generate_value(self._parameters.capacity_gbps_ranges,  ndigits=2)
+            e2e_latency_ms = generate_value(self._parameters.e2e_latency_ms_ranges, ndigits=2)
 
             constraints = [
                 json_constraint_sla_availability(1, True, availability),
@@ -293,9 +294,9 @@ class RequestGenerator:
                 request_uuid, endpoint_ids=endpoint_ids, constraints=constraints, config_rules=config_rules)
 
         elif request_type == RequestType.SERVICE_L3NM:
-            availability   = round(random.uniform(0.0, 99.9999), ndigits=5)
-            capacity_gbps  = round(random.uniform(0.1, 100.00), ndigits=2)
-            e2e_latency_ms = round(random.uniform(5.0, 100.00), ndigits=2)
+            availability   = generate_value(self._parameters.availability_ranges,   ndigits=5)
+            capacity_gbps  = generate_value(self._parameters.capacity_gbps_ranges,  ndigits=2)
+            e2e_latency_ms = generate_value(self._parameters.e2e_latency_ms_ranges, ndigits=2)
 
             constraints = [
                 json_constraint_sla_availability(1, True, availability),
@@ -410,9 +411,10 @@ class RequestGenerator:
             json_endpoint_id(json_device_id(dst_device_uuid), dst_endpoint_uuid),
         ]
 
-        availability   = round(random.uniform(0.0, 99.9999), ndigits=5)
-        capacity_gbps  = round(random.uniform(0.1, 100.00), ndigits=2)
-        e2e_latency_ms = round(random.uniform(5.0, 100.00), ndigits=2)
+        availability   = generate_value(self._parameters.availability_ranges,   ndigits=5)
+        capacity_gbps  = generate_value(self._parameters.capacity_gbps_ranges,  ndigits=2)
+        e2e_latency_ms = generate_value(self._parameters.e2e_latency_ms_ranges, ndigits=2)
+
         constraints = [
             json_constraint_sla_availability(1, True, availability),
             json_constraint_sla_capacity(capacity_gbps),

src/load_generator/service/LoadGeneratorServiceServicerImpl.py

@@ -21,6 +21,7 @@ from common.proto.load_generator_pb2_grpc import LoadGeneratorServiceServicer
 from load_generator.load_gen.Parameters import Parameters as LoadGen_Parameters
 from load_generator.load_gen.RequestGenerator import RequestGenerator
 from load_generator.load_gen.RequestScheduler import RequestScheduler
+from load_generator.tools.ListScalarRange import grpc__to__list_scalar_range, list_scalar_range__to__grpc
 from .Constants import REQUEST_TYPE_MAP, REQUEST_TYPE_REVERSE_MAP
 
 LOGGER = logging.getLogger(__name__)
@@ -34,15 +35,18 @@ class LoadGeneratorServiceServicerImpl(LoadGeneratorServiceServicer):
 
     def Start(self, request : Parameters, context : grpc.ServicerContext) -> Empty:
         self._parameters = LoadGen_Parameters(
-            num_requests       = request.num_requests,
-            request_types      = [REQUEST_TYPE_MAP[rt] for rt in request.request_types],
-            offered_load       = request.offered_load if request.offered_load > 1.e-12 else None,
-            holding_time       = request.holding_time if request.holding_time > 1.e-12 else None,
-            inter_arrival_time = request.inter_arrival_time if request.inter_arrival_time > 1.e-12 else None,
-            do_teardown        = request.do_teardown,   # if set, schedule tear down of requests
-            dry_mode           = request.dry_mode,      # in dry mode, no request is sent to TeraFlowSDN
-            record_to_dlt      = request.record_to_dlt, # if set, upload changes to DLT
-            dlt_domain_id      = request.dlt_domain_id, # domain used to uploaded entities (when record_to_dlt = True)
+            num_requests          = request.num_requests,
+            request_types         = [REQUEST_TYPE_MAP[rt] for rt in request.request_types],
+            offered_load          = request.offered_load if request.offered_load > 1.e-12 else None,
+            holding_time          = request.holding_time if request.holding_time > 1.e-12 else None,
+            inter_arrival_time    = request.inter_arrival_time if request.inter_arrival_time > 1.e-12 else None,
+            availability_ranges   = grpc__to__list_scalar_range(request.availability  ),
+            capacity_gbps_ranges  = grpc__to__list_scalar_range(request.capacity_gbps ),
+            e2e_latency_ms_ranges = grpc__to__list_scalar_range(request.e2e_latency_ms),
+            do_teardown           = request.do_teardown,   # if set, schedule tear down of requests
+            dry_mode              = request.dry_mode,      # in dry mode, no request is sent to TeraFlowSDN
+            record_to_dlt         = request.record_to_dlt, # if set, upload changes to DLT
+            dlt_domain_id         = request.dlt_domain_id, # domain used to uploaded entities (when record_to_dlt = True)
         )
 
         LOGGER.info('Initializing Generator...')
@@ -79,6 +83,11 @@ class LoadGeneratorServiceServicerImpl(LoadGeneratorServiceServicer):
         status.parameters.record_to_dlt      = params.record_to_dlt         # pylint: disable=no-member
         status.parameters.dlt_domain_id      = params.dlt_domain_id         # pylint: disable=no-member
         status.parameters.request_types.extend(request_types)               # pylint: disable=no-member
+
+        list_scalar_range__to__grpc(params.availability_ranges,   status.availability  )    # pylint: disable=no-member
+        list_scalar_range__to__grpc(params.capacity_gbps_ranges,  status.capacity_gbps )    # pylint: disable=no-member
+        list_scalar_range__to__grpc(params.e2e_latency_ms_ranges, status.e2e_latency_ms)    # pylint: disable=no-member
+
         return status
 
     def Stop(self, request : Empty, context : grpc.ServicerContext) -> Empty:

src/load_generator/tools/ListScalarRange.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import random
+from typing import List, Optional, Tuple, Union
+
+from common.proto.load_generator_pb2 import ScalarOrRange
+
+# RegEx to validate strings formatted as: '1, 2.3, 4.5  .. 6.7 , .8...9, 10., .11'
+# IMPORTANT: this regex just validates data, it does not extract the pieces of data!
+RE_FLOAT = r'[\ ]*[0-9]*[\.]?[0-9]*[\ ]*'
+RE_RANGE = RE_FLOAT + r'(\.\.' + RE_FLOAT + r')?'
+RE_SCALAR_RANGE_LIST  = RE_RANGE + r'(\,' + RE_RANGE + r')*'
+
+Type_ListScalarRange = List[Union[float, Tuple[float, float]]]
+
+def parse_list_scalar_range(value : str) -> Type_ListScalarRange:
+    str_value = str(value).replace(' ', '')
+    ranges = [[float(value) for value in item.split('..')] for item in str_value.split(',')]
+    return ranges
+
+def list_scalar_range__to__grpc(list_scalar_range : Type_ListScalarRange, obj : List[ScalarOrRange]) -> None:
+    for i,scalar_or_range in enumerate(list_scalar_range):
+        if isinstance(scalar_or_range, (float, str)):
+            _scalar = obj.add()
+            _scalar.scalar = float(scalar_or_range)
+        elif isinstance(scalar_or_range, (list, tuple)):
+            if len(scalar_or_range) == 1:
+                _scalar = obj.add()
+                _scalar.scalar = float(scalar_or_range[0])
+            elif len(scalar_or_range) == 2:
+                _range = obj.add()
+                _range.range.minimum = float(scalar_or_range[0])
+                _range.range.maximum = float(scalar_or_range[1])
+            else:
+                MSG = 'List/tuple with {:d} items in item(#{:d}, {:s})'
+                raise NotImplementedError(MSG.format(len(scalar_or_range), i, str(scalar_or_range)))
+        else:
+            MSG = 'Type({:s}) in item(#{:d}, {:s})'
+            raise NotImplementedError(MSG.format(str(type(scalar_or_range), i, str(scalar_or_range))))
+
+def grpc__to__list_scalar_range(obj : List[ScalarOrRange]) -> Type_ListScalarRange:
+    list_scalar_range = list()
+    for item in obj:
+        item_kind = item.WhichOneof('value')
+        if item_kind == 'scalar':
+            scalar_or_range = float(item.scalar)
+        elif item_kind == 'range':
+            scalar_or_range = (float(item.range.minimum), float(item.range.maximum))
+        else:
+            raise NotImplementedError('Unsupported ScalarOrRange kind({:s})'.format(str(item_kind)))
+        list_scalar_range.append(scalar_or_range)
+    return list_scalar_range
+
+def generate_value(
+    list_scalar_range : Type_ListScalarRange, ndigits : Optional[int] = None
+) -> float:
+    scalar_or_range = random.choice(list_scalar_range)
+    if isinstance(scalar_or_range, (float, str)):
+        value = float(scalar_or_range)
+    elif isinstance(scalar_or_range, (list, tuple)):
+        if len(scalar_or_range) == 1:
+            value = float(scalar_or_range[0])
+        elif len(scalar_or_range) == 2:
+            minimum = float(scalar_or_range[0])
+            maximum = float(scalar_or_range[1])
+            value = random.uniform(minimum, maximum)
+        else:
+            MSG = 'List/tuple with {:d} items in item({:s})'
+            raise NotImplementedError(MSG.format(len(scalar_or_range), str(scalar_or_range)))
+    else:
+        MSG = 'Type({:s}) in item({:s})'
+        raise NotImplementedError(MSG.format(str(type(scalar_or_range), str(scalar_or_range))))
+
+    if ndigits is None: return value
+    return round(value, ndigits=ndigits)

src/load_generator/tools/__init__.py

+# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.