Load Generator component:

- Added logic to filter src/dst candidate device and endpoint
- Corrected DLT recording logic

src/load_generator/command/__main__.py

@@ -34,6 +34,8 @@ def main():
             RequestType.SLICE_L2NM,
             RequestType.SLICE_L3NM,
         ],
+        device_regex=r'.+',
+        endpoint_regex=r'.+',
         offered_load  = 50,
         holding_time  = 10,
         availability_ranges   = [[0.0, 99.9999]],

src/load_generator/load_gen/Parameters.py

@@ -20,16 +20,27 @@ from load_generator.tools.ListScalarRange import Type_ListScalarRange
 
 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,
+        self,
+        num_requests : int,
+        request_types : List[str],
+        device_regex : Optional[str] = None,
+        endpoint_regex : Optional[str] = None,
+        offered_load : Optional[float] = 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,
-        max_workers : int = DEFAULT_MAX_WORKERS, do_teardown : bool = True, dry_mode : bool = False,
-        record_to_dlt : bool = False, dlt_domain_id : Optional[str] = None
+        max_workers : int = DEFAULT_MAX_WORKERS,
+        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._device_regex = r'.*' if (device_regex is None or len(device_regex) == 0) else device_regex
+        self._endpoint_regex = r'.*' if (endpoint_regex is None or len(endpoint_regex) == 0) else endpoint_regex
         self._offered_load = offered_load
         self._inter_arrival_time = inter_arrival_time
         self._holding_time = holding_time
@@ -62,6 +73,12 @@ class Parameters:
     @property
     def request_types(self): return self._request_types
 
+    @property
+    def device_regex(self): return self._device_regex
+
+    @property
+    def endpoint_regex(self): return self._endpoint_regex
+
     @property
     def offered_load(self): return self._offered_load
 

src/load_generator/load_gen/RequestGenerator.py

@@ -83,13 +83,21 @@ class RequestGenerator:
             if self._parameters.record_to_dlt:
                 dlt_domain_id = TopologyId(**json_topology_id('dlt-perf-eval'))
 
+            re_device = re.compile(r'^{:s}$'.format(self._parameters.device_regex))
+            re_endpoint = re.compile(r'^{:s}$'.format(self._parameters.endpoint_regex))
+
             devices = context_client.ListDevices(Empty())
             for device in devices.devices:
+                if self._parameters.record_to_dlt:
+                    record_device_to_dlt(dlt_connector_client, dlt_domain_id, device.device_id)
+
+                if re_device.match(device.name) is None: continue
                 device_uuid = device.device_id.device_uuid.uuid
                 self._device_data[device_uuid] = grpc_message_to_json(device)
 
                 _endpoints = self._available_device_endpoints.setdefault(device_uuid, set())
                 for endpoint in device.device_endpoints:
+                    if re_endpoint.match(endpoint.name) is None: continue
                     endpoint_uuid = endpoint.endpoint_id.endpoint_uuid.uuid
                     endpoints = self._device_endpoint_data.setdefault(device_uuid, dict())
                     endpoints[endpoint_uuid] = grpc_message_to_json(endpoint)
@@ -98,12 +106,12 @@ class RequestGenerator:
                     _endpoints.add(endpoint_uuid)
                     self._endpoint_ids_to_types.setdefault((device_uuid, endpoint_uuid), endpoint_type)
                     self._endpoint_types_to_ids.setdefault(endpoint_type, set()).add((device_uuid, endpoint_uuid))
-                
-                if self._parameters.record_to_dlt:
-                    record_device_to_dlt(dlt_connector_client, dlt_domain_id, device.device_id)
 
             links = context_client.ListLinks(Empty())
             for link in links.links:
+                if self._parameters.record_to_dlt:
+                    record_link_to_dlt(dlt_connector_client, dlt_domain_id, link.link_id)
+
                 for endpoint_id in link.link_endpoint_ids:
                     device_uuid = endpoint_id.device_id.device_uuid.uuid
                     endpoint_uuid = endpoint_id.endpoint_uuid.uuid
@@ -119,9 +127,6 @@ class RequestGenerator:
                     endpoint_key = (device_uuid, endpoint_uuid)
                     if endpoint_key not in endpoints_for_type: continue
                     endpoints_for_type.discard(endpoint_key)
-            
-                    if self._parameters.record_to_dlt:
-                        record_link_to_dlt(dlt_connector_client, dlt_domain_id, link.link_id)
 
     def dump_state(self) -> None:
         with self._lock:

src/load_generator/service/LoadGeneratorServiceServicerImpl.py

@@ -37,6 +37,8 @@ class LoadGeneratorServiceServicerImpl(LoadGeneratorServiceServicer):
         self._parameters = LoadGen_Parameters(
             num_requests          = request.num_requests,
             request_types         = [REQUEST_TYPE_MAP[rt] for rt in request.request_types],
+            device_regex          = request.device_regex,
+            endpoint_regex        = request.endpoint_regex,
             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,
@@ -79,6 +81,8 @@ class LoadGeneratorServiceServicerImpl(LoadGeneratorServiceServicer):
 
         stat_pars = status.parameters                               # pylint: disable=no-member
         stat_pars.num_requests       = params.num_requests          # pylint: disable=no-member
+        stat_pars.device_regex       = params.device_regex          # pylint: disable=no-member
+        stat_pars.endpoint_regex     = params.endpoint_regex        # pylint: disable=no-member
         stat_pars.offered_load       = params.offered_load          # pylint: disable=no-member
         stat_pars.holding_time       = params.holding_time          # pylint: disable=no-member
         stat_pars.inter_arrival_time = params.inter_arrival_time    # pylint: disable=no-member