diff --git a/src/service/service/service_handlers/l2nm_openconfig/ConfigRules.py b/src/service/service/service_handlers/l2nm_openconfig/ConfigRules.py
index f12c9ab984205b9057dd1507114e5bc17d8deaa6..8d08d6bdd1050d52614d2a2369ddcd26d69613d7 100644
--- a/src/service/service/service_handlers/l2nm_openconfig/ConfigRules.py
+++ b/src/service/service/service_handlers/l2nm_openconfig/ConfigRules.py
@@ -20,58 +20,63 @@ def setup_config_rules(
     service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str,
     service_settings : TreeNode, endpoint_settings : TreeNode
 ) -> List[Dict]:
+    
+    if service_settings  is None: return []
+    if endpoint_settings is None: return []
+
+    json_settings          : Dict = service_settings.value
+    json_endpoint_settings : Dict = endpoint_settings.value
 
     json_settings          : Dict = {} if service_settings  is None else service_settings.value
     json_endpoint_settings : Dict = {} if endpoint_settings is None else endpoint_settings.value
 
-    mtu                 = json_settings.get('mtu',                 1450 )    # 1512
+    #mtu                 = json_settings.get('mtu',                 1450 )    # 1512
     #address_families    = json_settings.get('address_families',    []   )    # ['IPV4']
     #bgp_as              = json_settings.get('bgp_as',              0    )    # 65000
     #bgp_route_target    = json_settings.get('bgp_route_target',    '0:0')    # 65000:333
 
-    router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'
+    #router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'
     #route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0'    )  # '60001:801'
-    sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1
+    #sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1
     vlan_id             = json_endpoint_settings.get('vlan_id',             1        )  # 400
     #address_ip          = json_endpoint_settings.get('address_ip',          '0.0.0.0')  # '2.2.2.1'
     #address_prefix      = json_endpoint_settings.get('address_prefix',      24       )  # 30
-    remote_router       = json_endpoint_settings.get('remote_router',       '0.0.0.0')  # '5.5.5.5'
-    circuit_id          = json_endpoint_settings.get('circuit_id',          '000'    )  # '111'
+    remote_router       = json_endpoint_settings.get('remote_router',       '5.5.5.5')  # '5.5.5.5'
+    circuit_id          = json_endpoint_settings.get('circuit_id',          '111'    )  # '111'
 
     if_cirid_name         = '{:s}.{:s}'.format(endpoint_uuid, str(circuit_id))
     network_instance_name = 'ELAN-AC:{:s}'.format(str(circuit_id))
     connection_point_id   = 'VC-1'
 
     json_config_rules = [
-        json_config_rule_set(
-            '/network_instance[default]',
-            {'name': 'default', 'type': 'DEFAULT_INSTANCE', 'router_id': router_id}),
-
-        json_config_rule_set(
-            '/network_instance[default]/protocols[OSPF]',
-            {'name': 'default', 'identifier': 'OSPF', 'protocol_name': 'OSPF'}),
-
-        json_config_rule_set(
-            '/network_instance[default]/protocols[STATIC]',
-            {'name': 'default', 'identifier': 'STATIC', 'protocol_name': 'STATIC'}),
-
+        
         json_config_rule_set(
             '/network_instance[{:s}]'.format(network_instance_name),
-            {'name': network_instance_name, 'type': 'L2VSI'}),
+            {'name': network_instance_name, 
+             'type': 'L2VSI'}),
 
         json_config_rule_set(
-            '/interface[{:s}]/subinterface[{:d}]'.format(if_cirid_name, sub_interface_index),
-            {'name': if_cirid_name, 'type': 'l2vlan', 'index': sub_interface_index, 'vlan_id': vlan_id}),
+            '/interface[{:s}]/subinterface[0]'.format(if_cirid_name),
+            {'name': if_cirid_name, 
+             'type': 'l2vlan', 
+             'index': 0, 
+             'vlan_id': vlan_id}),
 
         json_config_rule_set(
             '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_cirid_name),
-            {'name': network_instance_name, 'id': if_cirid_name, 'interface': if_cirid_name,
-            'subinterface': sub_interface_index}),
+            {'name': network_instance_name, 
+             'id': if_cirid_name, 
+             'interface': if_cirid_name,
+             'subinterface': 0
+            }),
 
         json_config_rule_set(
             '/network_instance[{:s}]/connection_point[{:s}]'.format(network_instance_name, connection_point_id),
-            {'name': network_instance_name, 'connection_point': connection_point_id, 'VC_ID': circuit_id,
-             'remote_system': remote_router}),
+            {'name': network_instance_name, 
+             'connection_point': connection_point_id, 
+             'VC_ID': circuit_id,
+             'remote_system': remote_router
+            }),
     ]
     return json_config_rules
 
@@ -88,9 +93,9 @@ def teardown_config_rules(
     #bgp_as              = json_settings.get('bgp_as',              0    )    # 65000
     #bgp_route_target    = json_settings.get('bgp_route_target',    '0:0')    # 65000:333
 
-    router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'
+    #router_id           = json_endpoint_settings.get('router_id',           '0.0.0.0')  # '10.95.0.10'
     #route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0'    )  # '60001:801'
-    sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1
+    #sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0        )  # 1
     #vlan_id             = json_endpoint_settings.get('vlan_id',             1        )  # 400
     #address_ip          = json_endpoint_settings.get('address_ip',          '0.0.0.0')  # '2.2.2.1'
     #address_prefix      = json_endpoint_settings.get('address_prefix',      24       )  # 30
@@ -102,33 +107,16 @@ def teardown_config_rules(
     connection_point_id   = 'VC-1'
 
     json_config_rules = [
-        json_config_rule_delete(
-            '/network_instance[{:s}]/connection_point[{:s}]'.format(network_instance_name, connection_point_id),
-            {'name': network_instance_name, 'connection_point': connection_point_id}),
+        
 
-        json_config_rule_delete(
-            '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_cirid_name),
-            {'name': network_instance_name, 'id': if_cirid_name, 'interface': if_cirid_name,
-            'subinterface': sub_interface_index}),
-
-        json_config_rule_delete(
-            '/interface[{:s}]/subinterface[{:d}]'.format(if_cirid_name, sub_interface_index),
-            {'name': if_cirid_name, 'index': sub_interface_index}),
 
         json_config_rule_delete(
             '/network_instance[{:s}]'.format(network_instance_name),
             {'name': network_instance_name}),
-
-        json_config_rule_delete(
-            '/network_instance[default]/protocols[STATIC]',
-            {'name': 'default', 'identifier': 'STATIC', 'protocol_name': 'STATIC'}),
-
-        json_config_rule_delete(
-            '/network_instance[default]/protocols[OSPF]',
-            {'name': 'default', 'identifier': 'OSPF', 'protocol_name': 'OSPF'}),
-
+        
         json_config_rule_delete(
-            '/network_instance[default]',
-            {'name': 'default', 'type': 'DEFAULT_INSTANCE', 'router_id': router_id}),
+            '/interface[{:s}]'.format(if_cirid_name), {
+            'name': if_cirid_name,
+        }),
     ]
     return json_config_rules
diff --git a/src/service/service/service_handlers/l2nm_openconfig/L2NMOpenConfigServiceHandler.py b/src/service/service/service_handlers/l2nm_openconfig/L2NMOpenConfigServiceHandler.py
index 23df44413c17e66a631988eb6256316badf0d554..6c41ac785da5705ebcf1bdb20c732392c8757836 100644
--- a/src/service/service/service_handlers/l2nm_openconfig/L2NMOpenConfigServiceHandler.py
+++ b/src/service/service/service_handlers/l2nm_openconfig/L2NMOpenConfigServiceHandler.py
@@ -86,12 +86,12 @@ class L2NMOpenConfigServiceHandler(_ServiceHandler):
 
                 json_config_rules = setup_config_rules(
                     service_uuid, connection_uuid, device_uuid, endpoint_uuid, settings, endpoint_settings)
-
-                device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
-                del device.device_config.config_rules[:]
-                for json_config_rule in json_config_rules:
-                    device.device_config.config_rules.append(ConfigRule(**json_config_rule))
-                self.__task_executor.configure_device(device)
+                if len(json_config_rules) > 0:
+                    device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
+                    del device.device_config.config_rules[:]
+                    for json_config_rule in json_config_rules:
+                        device.device_config.config_rules.append(ConfigRule(**json_config_rule))
+                    self.__task_executor.configure_device(device)
                 results.append(True)
             except Exception as e: # pylint: disable=broad-except
                 LOGGER.exception('Unable to SetEndpoint({:s})'.format(str(endpoint)))
@@ -121,12 +121,12 @@ class L2NMOpenConfigServiceHandler(_ServiceHandler):
 
                 json_config_rules = teardown_config_rules(
                     service_uuid, connection_uuid, device_uuid, endpoint_uuid, settings, endpoint_settings)
-
-                device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
-                del device.device_config.config_rules[:]
-                for json_config_rule in json_config_rules:
-                    device.device_config.config_rules.append(ConfigRule(**json_config_rule))
-                self.__task_executor.configure_device(device)
+                if len(json_config_rules) > 0:
+                    device = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
+                    del device.device_config.config_rules[:]
+                    for json_config_rule in json_config_rules:
+                        device.device_config.config_rules.append(ConfigRule(**json_config_rule))
+                    self.__task_executor.configure_device(device)
                 results.append(True)
             except Exception as e: # pylint: disable=broad-except
                 LOGGER.exception('Unable to DeleteEndpoint({:s})'.format(str(endpoint)))
diff --git a/src/service/service/service_handlers/l3nm_openconfig/ConfigRules.py b/src/service/service/service_handlers/l3nm_openconfig/ConfigRules.py
index 2a8f7794bbb58c6c4f529f40eae8ce299a84e456..40f9d46ea06322cd6ae1bdf3dfc2555e06494d96 100644
--- a/src/service/service/service_handlers/l3nm_openconfig/ConfigRules.py
+++ b/src/service/service/service_handlers/l3nm_openconfig/ConfigRules.py
@@ -87,46 +87,6 @@ def setup_config_rules(
                 'interface': if_subif_name,
                 'subinterface': 0,
         }), 
-        json_config_rule_set(
-            '/routing_policy/bgp_defined_set[{:s}_rt_import][{:s}]'.format(
-                network_instance_name, bgp_route_target), {
-                'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
-                'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),
-        }), 
-        json_config_rule_set(
-            '/routing_policy/policy_definition[{:s}_import]/statement[3]'.format(
-                network_instance_name), {
-                'policy_name': policy_import, 
-                'statement_name': '3',
-                'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
-                'policy_result': 'ACCEPT_ROUTE',
-        }), 
-        json_config_rule_set(
-            '/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
-                network_instance_name, policy_import), {
-                'name': network_instance_name, 
-                'import_policy': policy_import,
-        }), 
-        json_config_rule_set(
-            '/routing_policy/bgp_defined_set[{:s}_rt_export][{:s}]'.format(
-                network_instance_name, bgp_route_target), {
-                'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
-                'ext_community_member'  : 'route-target:{:s}'.format(bgp_route_target),
-        }), 
-        json_config_rule_set(
-            '/routing_policy/policy_definition[{:s}_export]/statement[3]'.format(
-                network_instance_name), {
-                'policy_name': policy_export, 
-                'statement_name': '3',
-                'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
-                'policy_result': 'ACCEPT_ROUTE',
-        }), 
-        json_config_rule_set(
-            '/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
-                network_instance_name, policy_export), {
-                'name': network_instance_name, 
-                'export_policy': policy_export,
-        }),  
         json_config_rule_set(
             '/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
                 network_instance_name), {
@@ -163,46 +123,28 @@ def teardown_config_rules(
     vlan_id             = json_endpoint_settings.get('vlan_id',             1        )  # 400
     #address_ip          = json_endpoint_settings.get('address_ip',          '0.0.0.0')  # '2.2.2.1'
     #address_prefix      = json_endpoint_settings.get('address_prefix',      24       )  # 30
-    policy_import       = json_endpoint_settings.get('policy_1',      2              )  # 2
-    policy_export       = json_endpoint_settings.get('policy_2',      7              )  # 30
+    policy_import       = json_endpoint_settings.get('policy_1',      '2'              )  # 2
+    policy_export       = json_endpoint_settings.get('policy_2',      '7'              )  # 30
 
     if_subif_name       = '{:s}.{:d}'.format(endpoint_uuid, vlan_id)
 
 
     json_config_rules = [
-        json_config_rule_delete(
-            '/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
-                network_instance_name), {
-                'name': network_instance_name, 
-                'src_protocol': 'DIRECTLY_CONNECTED', 
-                'dst_protocol': 'BGP',
-                'address_family': 'IPV4',
-        }),
-        json_config_rule_delete('/routing_policy/policy_definition[{:s}_import]/statement[3]'.format(
-            network_instance_name),{
-                'policy_name' : policy_import,
-        }),
-
-        json_config_rule_delete('/routing_policy/bgp_defined_set[{:s}_rt_import][{:s}]'.format(
-            network_instance_name,bgp_route_target),{
-                'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
-        }),
-        json_config_rule_delete('/routing_policy/policy_definition[{:s}_export]/statement[3]'.format(
-            network_instance_name),{
-                'policy_name' : policy_export,
-        }),
-
-        json_config_rule_delete('/routing_policy/bgp_defined_set[{:s}_rt_import][{:s}]'.format(
-            network_instance_name,bgp_route_target),{
-                'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
-        }),
+        # json_config_rule_delete(
+        #     '/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
+        #         'name': network_instance_name, 
+        #         'id': if_subif_name, 
+        #         'interface': if_subif_name,
+        #         'subinterface': 0,
+        # }), 
         json_config_rule_delete(
             '/interface[{:s}]'.format(if_subif_name), {
                 'name': if_subif_name,
         }),
-        json_config_rule_delete(
-            '/network_instance[{:s}]'.format(network_instance_name), {
-                'name': network_instance_name
-        }),
+        # json_config_rule_delete(
+        #     '/network_instance[{:s}]'.format(network_instance_name), {
+        #         'name': network_instance_name
+        # }),
+        
     ]
     return json_config_rules
diff --git a/src/tests/tools/load_gen/RequestGenerator.py b/src/tests/tools/load_gen/RequestGenerator.py
index 51b80d972169cd208271fa081165063008e8aafb..419708f855878d0c7cd6bee79285edbce0017347 100644
--- a/src/tests/tools/load_gen/RequestGenerator.py
+++ b/src/tests/tools/load_gen/RequestGenerator.py
@@ -35,6 +35,10 @@ ROUTER_ID = {
     'R149': '5.5.5.5',
     'R155': '5.5.5.1',
 }
+VIRTUALCIRCUIT = {
+    'R149': '5.5.5.5',
+    'R155': '5.5.5.1',
+}
 
 class RequestGenerator:
     def __init__(self, parameters : Parameters) -> None:
@@ -209,11 +213,13 @@ class RequestGenerator:
                 json_constraint_custom('latency[ms]',     '20.0'),
             ]
             vlan_id = num_request % 1000
-            circuit_id = '{:03d}'.format(vlan_id)
+            circuit_id = vlan_id + 100
             src_router_id = ROUTER_ID.get(src_device_uuid)
             if src_router_id is None: src_router_id = '10.0.0.{:d}'.format(int(src_device_uuid.replace('R', '')))
             dst_router_id = ROUTER_ID.get(dst_device_uuid)
             if dst_router_id is None: dst_router_id = '10.0.0.{:d}'.format(int(dst_device_uuid.replace('R', '')))
+            remote = VIRTUALCIRCUIT.get(src_device_uuid)
+            
             config_rules = [
                 json_config_rule_set('/settings', {
                     'mtu': 1512
@@ -224,6 +230,7 @@ class RequestGenerator:
                     'vlan_id': vlan_id,
                     'remote_router': dst_router_id,
                     'circuit_id': circuit_id,
+                    'remote': remote,
                 }),
                 json_config_rule_set('/device[{:s}]/endpoint[{:s}]/settings'.format(dst_device_uuid, dst_endpoint_uuid), {
                     'router_id': dst_router_id,
@@ -258,8 +265,8 @@ class RequestGenerator:
             if dst_router_id is None: dst_router_id = '10.0.0.{:d}'.format(dst_router_num)
             src_address_ip = '10.{:d}.{:d}.{:d}'.format(x,y,int(src_device_uuid.replace('R', '')))
             dst_address_ip = '10.{:d}.{:d}.{:d}'.format(y,x,int(dst_device_uuid.replace('R', '')))
-            policy_R1 = num_request * 10 + src_router_num * 5 + dst_router_num
-            policy_R2 = num_request * 10 + dst_router_num * 5 + src_router_num
+            policy_R1 = vlan_id = num_request % 100
+            policy_R2 = vlan_id = num_request % 100 +1
 
             config_rules = [
                 json_config_rule_set('/settings', {
diff --git a/src/tests/tools/load_gen/__main__.py b/src/tests/tools/load_gen/__main__.py
index 88b4b16b163354931310c08a2aab3d181dae92b5..c3e86cc3e2bd045129699856df832e5c1269b5ee 100644
--- a/src/tests/tools/load_gen/__main__.py
+++ b/src/tests/tools/load_gen/__main__.py
@@ -24,15 +24,15 @@ LOGGER = logging.getLogger(__name__)
 def main():
     LOGGER.info('Starting...')
     parameters = Parameters(
-        num_requests = 1,
+        num_requests = 20,
         request_types = [
-            #RequestType.SERVICE_L2NM,
+            RequestType.SERVICE_L2NM,
             RequestType.SERVICE_L3NM,
             #RequestType.SERVICE_TAPI,
             #RequestType.SLICE_L2NM,
             #RequestType.SLICE_L3NM,
-        ],
-        offered_load  = 50,
+        ],                                                                                                                                                                                             
+        offered_load  = 10,
         holding_time  = 10,
         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