Load Generator component: (d3350bae) · Commits · TFS / controller

src/load_generator/command/main.py

+3 −0

Original line number	Diff line number	Diff line
		@@ -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

+23 −2

Original line number	Diff line number	Diff line
		@@ -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

+11 −9

Original line number	Diff line number	Diff line
		@@ -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

+18 −9

Original line number	Diff line number	Diff line
		@@ -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__)
		@@ -39,6 +40,9 @@ class LoadGeneratorServiceServicerImpl(LoadGeneratorServiceServicer):
		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
		@@ -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

0 → 100644

+87 −0

Original line number	Diff line number	Diff line
		# 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)