diff --git a/src/service/service/service_handlers/p4_fabric_tna_acl/p4_fabric_tna_acl_service_handler.py b/src/service/service/service_handlers/p4_fabric_tna_acl/p4_fabric_tna_acl_service_handler.py
index 00eccfb4a02375dab48b112a41680a2a384ac2f1..84fd768cc7f9a818aba3370dc3e828ab81001e65 100644
--- a/src/service/service/service_handlers/p4_fabric_tna_acl/p4_fabric_tna_acl_service_handler.py
+++ b/src/service/service/service_handlers/p4_fabric_tna_acl/p4_fabric_tna_acl_service_handler.py
@@ -130,20 +130,19 @@ class P4FabricACLServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to insert ACL rules on device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Installed {}/{} ACL rules on device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Installed {}/{} ACL rules on device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -189,7 +188,7 @@ class P4FabricACLServiceHandler(_ServiceHandler):
             try:
                 # Check if this port is part of the ACL configuration
                 _ = self._get_switch_port_in_port_map(device_name, port_id)
-            except Exception:
+            except Exception as ex:
                 LOGGER.warning("Switch {} endpoint {} is not part of the ACL configuration".format(device_name, port_id))
                 results.append(False)
                 continue
@@ -216,20 +215,19 @@ class P4FabricACLServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to delete ACL rules from device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Deleted {}/{} ACL rules from device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Deleted {}/{} ACL rules from device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -342,24 +340,26 @@ class P4FabricACLServiceHandler(_ServiceHandler):
 
     def _parse_settings(self):
         try:
-            self.__switch_info = self.__settings.value[SWITCH_INFO]
+            switch_info = self.__settings.value[SWITCH_INFO]
         except Exception as ex:
             LOGGER.error("Failed to parse service settings: {}".format(ex))
             raise Exception(ex)
-        assert isinstance(self.__switch_info, list), "Switch info object must be a list"
+        assert isinstance(switch_info, list), "Switch info object must be a list"
 
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
+        for switch in switch_info:
+            for switch_name, sw_info in switch.items():
                 assert switch_name, "Invalid P4 switch name"
-                assert isinstance(switch_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
-                assert switch_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
+                assert isinstance(sw_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
+                assert sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
                     "Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
-                switch_dpid = switch_info[DPID]
-                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, switch_info[DPID])
+                switch_dpid = sw_info[DPID]
+                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, sw_info[DPID])
 
                 # Access Control list
-                acl = switch_info[ACL]
-                assert isinstance(acl, list), "Switch {} access control list must be a list with port_id, [ipv4_dst/src, trn_post_dst/src], and action items)"
+                acl = sw_info[ACL]
+                assert isinstance(acl, list),\
+                    "Switch {} access control list must be a list with port_id, [ipv4_dst/src, trn_post_dst/src], and action items)".\
+                        format(switch_name)
                 for acl_entry in acl:
                     LOGGER.info("ACL entry: {}".format(acl_entry))
                     port_id = acl_entry[PORT_ID]
@@ -398,13 +398,13 @@ class P4FabricACLServiceHandler(_ServiceHandler):
                     trn_port_src = -1
                     if TRN_PORT_SRC in acl_entry:
                         trn_port_src = acl_entry[TRN_PORT_SRC]
-                        assert chk_transport_port(trn_port_src), "Invalid source transport port"
+                        assert chk_transport_port(trn_port_src), "Invalid source transport port {}".format(trn_port_src)
                         map_entry[TRN_PORT_SRC] = trn_port_src
 
                     trn_port_dst = -1
                     if TRN_PORT_DST in acl_entry:
                         trn_port_dst = acl_entry[TRN_PORT_DST]
-                        assert chk_transport_port(trn_port_dst), "Invalid destination transport port"
+                        assert chk_transport_port(trn_port_dst), "Invalid destination transport port {}".format(trn_port_dst)
                         map_entry[TRN_PORT_DST] = trn_port_dst
 
                     action = acl_entry[ACTION]
@@ -416,15 +416,16 @@ class P4FabricACLServiceHandler(_ServiceHandler):
                     # Add routing entry
                     switch_port_entry[ACL].append(map_entry)
 
+                self.__switch_info[switch_name] = sw_info
+
     def _print_settings(self):
         LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))
         LOGGER.info("--- Topology info")
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
-                LOGGER.info("\t Device {}".format(switch_name))
-                LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
-                LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
-                LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
+        for switch_name, switch_info in self.__switch_info.items():
+            LOGGER.info("\t Device {}".format(switch_name))
+            LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
+            LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
+            LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
         LOGGER.info("-------------------------------------------------------")
 
     def _get_switch_port_in_port_map(self, switch_name : str, port_id : int) -> Dict:
@@ -450,34 +451,53 @@ class P4FabricACLServiceHandler(_ServiceHandler):
         acl = self._get_acl_of_switch_port(switch_name=dev_name, port_id=port_id)
         for acl_entry in acl:
             if IPV4_SRC in acl_entry:
-                rules += rules_set_up_acl_filter_host(
-                    ingress_port=port_id,
-                    ip_address=acl_entry[IPV4_SRC],
-                    prefix_len=acl_entry[IPV4_PREFIX_LEN],
-                    ip_direction="src",
-                    action=action
-                )
+                try:
+                    rules += rules_set_up_acl_filter_host(
+                        ingress_port=port_id,
+                        ip_address=acl_entry[IPV4_SRC],
+                        prefix_len=acl_entry[IPV4_PREFIX_LEN],
+                        ip_direction="src",
+                        action=action
+                    )
+                except Exception as ex:
+                    LOGGER.error("Error while creating ACL source host filter rules")
+                    raise Exception(ex)
+
             if IPV4_DST in acl_entry:
-                rules += rules_set_up_acl_filter_host(
-                    ingress_port=port_id,
-                    ip_address=acl_entry[IPV4_DST],
-                    prefix_len=acl_entry[IPV4_PREFIX_LEN],
-                    ip_direction="dst",
-                    action=action
-                )
+                try:
+                    rules += rules_set_up_acl_filter_host(
+                        ingress_port=port_id,
+                        ip_address=acl_entry[IPV4_DST],
+                        prefix_len=acl_entry[IPV4_PREFIX_LEN],
+                        ip_direction="dst",
+                        action=action
+                    )
+                except Exception as ex:
+                    LOGGER.error("Error while creating ACL destination host filter rules")
+                    raise Exception(ex)
+
             if TRN_PORT_SRC in acl_entry:
-                rules += rules_set_up_acl_filter_port(
-                    ingress_port=port_id,
-                    transport_port=acl_entry[TRN_PORT_SRC],
-                    transport_direction="src",
-                    action=action
-                )
+                try:
+                    rules += rules_set_up_acl_filter_port(
+                        ingress_port=port_id,
+                        transport_port=acl_entry[TRN_PORT_SRC],
+                        transport_direction="src",
+                        action=action
+                    )
+                except Exception as ex:
+                    LOGGER.error("Error while creating ACL source port filter rules")
+                    raise Exception(ex)
+
             if TRN_PORT_DST in acl_entry:
-                rules += rules_set_up_acl_filter_port(
-                    ingress_port=port_id,
-                    transport_port=acl_entry[TRN_PORT_DST],
-                    transport_direction="dst",
-                    action=action
-                )
+                try:
+                    rules += rules_set_up_acl_filter_port(
+                        ingress_port=port_id,
+                        transport_port=acl_entry[TRN_PORT_DST],
+                        transport_direction="dst",
+                        action=action
+                    )
+                except Exception as ex:
+                    LOGGER.error("Error while creating ACL destination port filter rules")
+                    raise Exception(ex)
 
         return rules
diff --git a/src/service/service/service_handlers/p4_fabric_tna_int/p4_fabric_tna_int_service_handler.py b/src/service/service/service_handlers/p4_fabric_tna_int/p4_fabric_tna_int_service_handler.py
index 73d555a0bdd12d0bebb1517431da84a3470595a4..3212887b85eacc55c62cf1c9e768bac1d1f18358 100644
--- a/src/service/service/service_handlers/p4_fabric_tna_int/p4_fabric_tna_int_service_handler.py
+++ b/src/service/service/service_handlers/p4_fabric_tna_int/p4_fabric_tna_int_service_handler.py
@@ -116,20 +116,19 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to insert INT rules on device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Installed {}/{} INT rules on device {}".format(
+                    applied_rules, actual_rules, device.name))
+                results.append(True)
 
             # You should no longer visit this device again
             visited.add(device.name)
 
-            if applied_rules > 0:
-                LOGGER.info("Installed {}/{} INT rules on device {}".format(
-                    applied_rules, actual_rules, device.name))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -182,20 +181,19 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 task_executor=self.__task_executor, device_obj=device, json_config_rules=rules)
             except Exception as ex:
                 LOGGER.error("Failed to delete INT rules from device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Deleted {}/{} INT rules from device {}".format(
+                    applied_rules, actual_rules, device.name))
+                results.append(True)
 
             # You should no longer visit this device again
             visited.add(device.name)
 
-            if applied_rules > 0:
-                LOGGER.info("Deleted {}/{} INT rules from device {}".format(
-                    applied_rules, actual_rules, device.name))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -312,33 +310,33 @@ class P4FabricINTServiceHandler(_ServiceHandler):
 
     def _parse_settings(self):
         try:
-            self.__switch_info = self.__settings.value[SWITCH_INFO]
+            switch_info = self.__settings.value[SWITCH_INFO]
         except Exception as ex:
             LOGGER.error("Failed to parse service settings: {}".format(ex))
             raise Exception(ex)
-        assert isinstance(self.__switch_info, list), "Switch info object must be a list"
+        assert isinstance(switch_info, list), "Switch info object must be a list"
 
-        # for switch_name, switch_info in self.__switch_info.items():
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
+        for switch in switch_info:
+            for switch_name, sw_info in switch.items():
                 assert switch_name, "Invalid P4 switch name"
-                assert isinstance(switch_info, dict), "Switch {} info must be a map with arch, dpid, mac, ip, and int_port items)"
-                assert switch_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
+                assert isinstance(sw_info, dict), "Switch {} info must be a map with arch, dpid, mac, ip, and int_port items)"
+                assert sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
                     "Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
-                assert switch_info[DPID] > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, switch_info[DPID])
-                assert chk_address_mac(switch_info[MAC]), "Switch {} - Invalid source Ethernet address".format(switch_name)
-                assert chk_address_ipv4(switch_info[IP]), "Switch {} - Invalid source IP address".format(switch_name)
-                assert isinstance(switch_info[PORT_INT], dict), "Switch {} - INT port object must be a map with port_id and port_type items".format(switch_name)
-                assert switch_info[PORT_INT][PORT_ID] >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)
-                assert switch_info[PORT_INT][PORT_TYPE] in PORT_TYPES_STR_VALID, "Switch {} - Valid P4 switch port types are: {}".format(
+                assert sw_info[DPID] > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, sw_info[DPID])
+                assert chk_address_mac(sw_info[MAC]), "Switch {} - Invalid source Ethernet address".format(switch_name)
+                assert chk_address_ipv4(sw_info[IP]), "Switch {} - Invalid source IP address".format(switch_name)
+                assert isinstance(sw_info[PORT_INT], dict), "Switch {} - INT port object must be a map with port_id and port_type items".format(switch_name)
+                assert sw_info[PORT_INT][PORT_ID] >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)
+                assert sw_info[PORT_INT][PORT_TYPE] in PORT_TYPES_STR_VALID, "Switch {} - Valid P4 switch port types are: {}".format(
                     switch_name, ','.join(PORT_TYPES_STR_VALID))
-                if arch_tna(switch_info[ARCH]):
-                    switch_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_TNA
-                    switch_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_TNA
+                if arch_tna(sw_info[ARCH]):
+                    sw_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_TNA
+                    sw_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_TNA
                 else:
-                    switch_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_V1MODEL
-                    switch_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_V1MODEL
-                assert isinstance(switch_info[RECIRCULATION_PORT_LIST], list), "Switch {} - Recirculation ports must be described as a list".format(switch_name)
+                    sw_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_V1MODEL
+                    sw_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_V1MODEL
+                assert isinstance(sw_info[RECIRCULATION_PORT_LIST], list), "Switch {} - Recirculation ports must be described as a list".format(switch_name)
+                self.__switch_info[switch_name] = sw_info
 
         self.__int_collector_info = self.__settings.value[INT_COLLECTOR_INFO]
         assert isinstance(self.__int_collector_info, dict), "INT collector info object must be a map with mac, ip, port, and vlan_id keys)"
@@ -358,17 +356,16 @@ class P4FabricINTServiceHandler(_ServiceHandler):
     def _print_settings(self):
         LOGGER.info("-------------------- {} settings --------------------".format(self.__service.name))
         LOGGER.info("--- Topology info")
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
-                LOGGER.info("\t Device {}".format(switch_name))
-                LOGGER.info("\t\t|  Target P4 architecture: {}".format(switch_info[ARCH]))
-                LOGGER.info("\t\t|           Data plane ID: {}".format(switch_info[DPID]))
-                LOGGER.info("\t\t|      Source MAC address: {}".format(switch_info[MAC]))
-                LOGGER.info("\t\t|      Source  IP address: {}".format(switch_info[IP]))
-                LOGGER.info("\t\t|           INT port   ID: {}".format(switch_info[PORT_INT][PORT_ID]))
-                LOGGER.info("\t\t|           INT port type: {}".format(switch_info[PORT_INT][PORT_TYPE]))
-                LOGGER.info("\t\t| Recirculation port list: {}".format(switch_info[RECIRCULATION_PORT_LIST]))
-                LOGGER.info("\t\t|   Report mirror ID list: {}".format(switch_info[INT_REPORT_MIRROR_ID_LIST]))
+        for switch_name, switch_info in self.__switch_info.items():
+            LOGGER.info("\t Device {}".format(switch_name))
+            LOGGER.info("\t\t|  Target P4 architecture: {}".format(switch_info[ARCH]))
+            LOGGER.info("\t\t|           Data plane ID: {}".format(switch_info[DPID]))
+            LOGGER.info("\t\t|      Source MAC address: {}".format(switch_info[MAC]))
+            LOGGER.info("\t\t|      Source  IP address: {}".format(switch_info[IP]))
+            LOGGER.info("\t\t|           INT port   ID: {}".format(switch_info[PORT_INT][PORT_ID]))
+            LOGGER.info("\t\t|           INT port type: {}".format(switch_info[PORT_INT][PORT_TYPE]))
+            LOGGER.info("\t\t| Recirculation port list: {}".format(switch_info[RECIRCULATION_PORT_LIST]))
+            LOGGER.info("\t\t|   Report mirror ID list: {}".format(switch_info[INT_REPORT_MIRROR_ID_LIST]))
         LOGGER.info("--- INT collector  MAC: {}".format(self.__int_collector_mac))
         LOGGER.info("--- INT collector   IP: {}".format(self.__int_collector_ip))
         LOGGER.info("--- INT collector port: {}".format(self.__int_collector_port))
@@ -379,9 +376,14 @@ class P4FabricINTServiceHandler(_ServiceHandler):
         dev_name = device_obj.name
         rules  = []
 
+        ### INT reporting rules
         try:
-            ### INT reporting rules
             rules += rules_set_up_int_watchlist(action=action)
+        except Exception as ex:
+            LOGGER.error("Error while creating INT watchlist rules")
+            raise Exception(ex)
+
+        try:
             rules += rules_set_up_int_recirculation_ports(
                 recirculation_port_list=self.__switch_info[dev_name][RECIRCULATION_PORT_LIST],
                 port_type=PORT_TYPE_INT,
@@ -389,10 +391,20 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 vlan_id=self.__int_vlan_id,
                 action=action
             )
+        except Exception as ex:
+            LOGGER.error("Error while creating INT recirculation rules")
+            raise Exception(ex)
+
+        try:
             rules += rules_set_up_int_report_collector(
                 int_collector_ip=self.__int_collector_ip,
                 action=action
             )
+        except Exception as ex:
+            LOGGER.error("Error while creating INT report collector rules")
+            raise Exception(ex)
+
+        try:
             rules += rules_set_up_int_report_flow(
                 switch_id=self.__switch_info[dev_name][DPID],
                 src_ip=self.__switch_info[dev_name][IP],
@@ -400,12 +412,22 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 int_collector_port=self.__int_collector_port,
                 action=action
             )
+        except Exception as ex:
+            LOGGER.error("Error while creating INT report flow rules")
+            raise Exception(ex)
+
+        try:
             rules += rules_set_up_report_mirror_flow(
                 recirculation_port_list=self.__switch_info[dev_name][RECIRCULATION_PORT_LIST],
                 report_mirror_id_list=self.__switch_info[dev_name][INT_REPORT_MIRROR_ID_LIST],
                 action=action
             )
-            ### INT port setup rules
+        except Exception as ex:
+            LOGGER.error("Error while creating report mirror flow rules")
+            raise Exception(ex)
+
+        ### INT port setup rules
+        try:
             rules += rules_set_up_port(
                 port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
                 port_type=PORT_TYPE_HOST,
@@ -413,7 +435,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 vlan_id=self.__int_vlan_id,
                 action=action
             )
-            ### INT port forwarding rules
+        except Exception as ex:
+            LOGGER.error("Error while creating INT port rules")
+            raise Exception(ex)
+
+        ### INT port forwarding rules
+        try:
             rules += rules_set_up_fwd_bridging(
                 vlan_id=self.__int_vlan_id,
                 eth_dst=self.__int_collector_mac,
@@ -424,7 +451,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
                 action=action
             )
-            ### INT packet routing rules
+        except Exception as ex:
+            LOGGER.error("Error while creating INT bridging rules")
+            raise Exception(ex)
+
+        ### INT packet routing rules
+        try:
             rules += rules_set_up_next_routing_simple(
                 egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
                 eth_src=self.__switch_info[dev_name][MAC],
@@ -438,7 +470,7 @@ class P4FabricINTServiceHandler(_ServiceHandler):
                 action=action
             )
         except Exception as ex:
-            LOGGER.error("Error while creating rules")
+            LOGGER.error("Error while creating INT routing rules")
             raise Exception(ex)
 
         return rules
diff --git a/src/service/service/service_handlers/p4_fabric_tna_l2_simple/p4_fabric_tna_l2_simple_service_handler.py b/src/service/service/service_handlers/p4_fabric_tna_l2_simple/p4_fabric_tna_l2_simple_service_handler.py
index d58a183ef8966aa6c9ea886207c9e1831839e4ac..7dff44ce899f508dc0eff9174b27c7f7a8437dba 100644
--- a/src/service/service/service_handlers/p4_fabric_tna_l2_simple/p4_fabric_tna_l2_simple_service_handler.py
+++ b/src/service/service/service_handlers/p4_fabric_tna_l2_simple/p4_fabric_tna_l2_simple_service_handler.py
@@ -121,20 +121,19 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to insert L2 rules on device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Installed {}/{} L2 rules on device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Installed {}/{} L2 rules on device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -199,20 +198,19 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to delete L2 rules from device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Deleted {}/{} L2 rules from device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Deleted {}/{} L2 rules from device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -325,24 +323,25 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
 
     def _parse_settings(self):
         try:
-            self.__switch_info = self.__settings.value[SWITCH_INFO]
+            switch_info = self.__settings.value[SWITCH_INFO]
         except Exception as ex:
             LOGGER.error("Failed to parse service settings: {}".format(ex))
             raise Exception(ex)
-        assert isinstance(self.__switch_info, list), "Switch info object must be a list"
+        assert isinstance(switch_info, list), "Switch info object must be a list"
 
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
+        for switch in switch_info:
+            for switch_name, sw_info in switch.items():
                 assert switch_name, "Invalid P4 switch name"
-                assert isinstance(switch_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
-                assert switch_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
+                assert isinstance(sw_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
+                assert sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
                     "Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
-                switch_dpid = switch_info[DPID]
-                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, switch_info[DPID])
+                switch_dpid = sw_info[DPID]
+                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, sw_info[DPID])
 
                 # Port list
-                port_list = switch_info[PORT_LIST]
-                assert isinstance(port_list, list), "Switch {} port list must be a list with port_id, port_type, and vlan_id items)"
+                port_list = sw_info[PORT_LIST]
+                assert isinstance(port_list, list), \
+                    "Switch {} port list must be a list with port_id, port_type, and vlan_id items".format(switch_name)
                 for port in port_list:
                     port_id = port[PORT_ID]
                     assert port_id >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)
@@ -363,8 +362,8 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
                     self.__port_map[switch_name][port_key][FORWARDING_LIST] = []
 
                 # Forwarding list
-                fwd_list = switch_info[FORWARDING_LIST]
-                assert isinstance(fwd_list, list), "Switch {} forwarding list be a list)"
+                fwd_list = sw_info[FORWARDING_LIST]
+                assert isinstance(fwd_list, list), "Switch {} forwarding list must be a list".format(switch_name)
                 for fwd_entry in fwd_list:
                     port_id = fwd_entry[PORT_ID]
                     assert port_id >= 0, "Invalid port ID: {}".format(port_id)
@@ -377,16 +376,16 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
                     host_facing_port = self._is_host_facing_port(switch_name, port_id)
                     LOGGER.info("Switch {} - Port {}: Is host facing: {}".format(switch_name, port_id, "True" if host_facing_port else "False"))
                     switch_port_entry[FORWARDING_LIST].append(host_mac)
+                self.__switch_info[switch_name] = sw_info
 
     def _print_settings(self):
         LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))
         LOGGER.info("--- Topology info")
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
-                LOGGER.info("\t Device {}".format(switch_name))
-                LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
-                LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
-                LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
+        for switch_name, switch_info in self.__switch_info.items():
+            LOGGER.info("\t Device {}".format(switch_name))
+            LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
+            LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
+            LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
         LOGGER.info("-------------------------------------------------------")
 
     def _get_switch_port_in_port_map(self, switch_name : str, port_id : int) -> Dict:
diff --git a/src/service/service/service_handlers/p4_fabric_tna_l3/p4_fabric_tna_l3_service_handler.py b/src/service/service/service_handlers/p4_fabric_tna_l3/p4_fabric_tna_l3_service_handler.py
index cc7a8dbd5441c9adf501956463c875a9758eca34..e1b73b3745ef995a755716952fabeaf182cbcce8 100644
--- a/src/service/service/service_handlers/p4_fabric_tna_l3/p4_fabric_tna_l3_service_handler.py
+++ b/src/service/service/service_handlers/p4_fabric_tna_l3/p4_fabric_tna_l3_service_handler.py
@@ -119,20 +119,19 @@ class P4FabricL3ServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to insert L3 rules on device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Installed {}/{} ACL rules on device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Installed {}/{} L3 rules on device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -197,20 +196,19 @@ class P4FabricL3ServiceHandler(_ServiceHandler):
                 )
             except Exception as ex:
                 LOGGER.error("Failed to delete L3 rules from device {} due to {}".format(device.name, ex))
+                results.append(ex)
             finally:
                 rules.clear()
 
             # Ensure correct status
-            results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \
-                else results.append(False)
+            if (failed_rules == 0) and (applied_rules == actual_rules):
+                LOGGER.info("Deleted {}/{} L3 rules from device {} and port {}".format(
+                    applied_rules, actual_rules, device_name, port_id))
+                results.append(True)
 
             # You should no longer visit this device port again
             visited.add(dev_port_key)
 
-            if applied_rules > 0:
-                LOGGER.info("Deleted {}/{} L3 rules from device {} and port {}".format(
-                    applied_rules, actual_rules, device_name, port_id))
-
         return results
 
     @metered_subclass_method(METRICS_POOL)
@@ -323,24 +321,25 @@ class P4FabricL3ServiceHandler(_ServiceHandler):
 
     def _parse_settings(self):
         try:
-            self.__switch_info = self.__settings.value[SWITCH_INFO]
+            switch_info = self.__settings.value[SWITCH_INFO]
         except Exception as ex:
             LOGGER.error("Failed to parse service settings: {}".format(ex))
             raise Exception(ex)
-        assert isinstance(self.__switch_info, list), "Switch info object must be a list"
+        assert isinstance(switch_info, list), "Switch info object must be a list"
 
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
+        for switch in switch_info:
+            for switch_name, sw_info in switch.items():
                 assert switch_name, "Invalid P4 switch name"
-                assert isinstance(switch_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
-                assert switch_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
+                assert isinstance(sw_info, dict), "Switch {} info must be a map with arch, dpid, and fwd_list items)"
+                assert sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
                     "Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
-                switch_dpid = switch_info[DPID]
-                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, switch_info[DPID])
+                switch_dpid = sw_info[DPID]
+                assert switch_dpid > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, sw_info[DPID])
 
                 # Port list
-                port_list = switch_info[PORT_LIST]
-                assert isinstance(port_list, list), "Switch {} port list must be a list with port_id and port_type items)"
+                port_list = sw_info[PORT_LIST]
+                assert isinstance(port_list, list),\
+                    "Switch {} port list must be a list with port_id and port_type items".format(switch_name)
                 for port in port_list:
                     port_id = port[PORT_ID]
                     assert port_id >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)
@@ -358,8 +357,8 @@ class P4FabricL3ServiceHandler(_ServiceHandler):
                     self.__port_map[switch_name][port_key][ROUTING_LIST] = []
 
                 # Routing list
-                routing_list = switch_info[ROUTING_LIST]
-                assert isinstance(routing_list, list), "Switch {} routing list be a list)"
+                routing_list = sw_info[ROUTING_LIST]
+                assert isinstance(routing_list, list), "Switch {} routing list must be a list".format(switch_name)
                 for rt_entry in routing_list:
                     port_id = rt_entry[PORT_ID]
                     assert port_id >= 0, "Invalid port ID: {}".format(port_id)
@@ -385,16 +384,16 @@ class P4FabricL3ServiceHandler(_ServiceHandler):
                             MAC_DST: mac_dst
                         }
                     )
+                self.__switch_info[switch_name] = sw_info
 
     def _print_settings(self):
         LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))
         LOGGER.info("--- Topology info")
-        for switch in self.__switch_info:
-            for switch_name, switch_info in switch.items():
-                LOGGER.info("\t Device {}".format(switch_name))
-                LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
-                LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
-                LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
+        for switch_name, switch_info in self.__switch_info.items():
+            LOGGER.info("\t Device {}".format(switch_name))
+            LOGGER.info("\t\t| Target P4 architecture: {}".format(switch_info[ARCH]))
+            LOGGER.info("\t\t|          Data plane ID: {}".format(switch_info[DPID]))
+            LOGGER.info("\t\t|               Port map: {}".format(self.__port_map[switch_name]))
         LOGGER.info("-------------------------------------------------------")
 
     def _get_switch_port_in_port_map(self, switch_name : str, port_id : int) -> Dict: