diff --git a/src/load_generator/command/__main__.py b/src/load_generator/command/__main__.py
index 7504eb6da6d6adea698249240abf2c4e4559297a..bc09607a57e44cf119d062cfc1914bb1be3be8bf 100644
--- a/src/load_generator/command/__main__.py
+++ b/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
diff --git a/src/load_generator/load_gen/Parameters.py b/src/load_generator/load_gen/Parameters.py
index f0de3ea1aa268c520fd214f7f621953289ac5bc9..c0bd6e5f6b1f4fd96be420b6b32f1c290aae2dac 100644
--- a/src/load_generator/load_gen/Parameters.py
+++ b/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
diff --git a/src/load_generator/load_gen/RequestGenerator.py b/src/load_generator/load_gen/RequestGenerator.py
index 791ff740713f193e0187ee34a7980031c1389195..ab8f7e30e7e9de61bcfa7f5c52b7a09deb00ba2a 100644
--- a/src/load_generator/load_gen/RequestGenerator.py
+++ b/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),
diff --git a/src/load_generator/service/LoadGeneratorServiceServicerImpl.py b/src/load_generator/service/LoadGeneratorServiceServicerImpl.py
index d66b0b2c10c5228e0c3d15759fc46b2c0770154d..d358c398f9de8b6c83a9be3b96b3b208b62e924e 100644
--- a/src/load_generator/service/LoadGeneratorServiceServicerImpl.py
+++ b/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:
diff --git a/src/load_generator/tools/ListScalarRange.py b/src/load_generator/tools/ListScalarRange.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6648404767f5a810f1d53d99eaa970fefe9e46b
--- /dev/null
+++ b/src/load_generator/tools/ListScalarRange.py
@@ -0,0 +1,87 @@
+# 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)
diff --git a/src/load_generator/tools/__init__.py b/src/load_generator/tools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..38d04994fb0fa1951fb465bc127eb72659dc2eaf
--- /dev/null
+++ b/src/load_generator/tools/__init__.py
@@ -0,0 +1,13 @@
+# 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.