fix: better exception handling in P4 service handlers (6bd4562d) · Commits · TFS / controller

src/service/service/service_handlers/p4_fabric_tna_acl/p4_fabric_tna_acl_service_handler.py

+77 −57

Original line number	Original line	Diff line number	Diff line
	@@ -130,20 +130,19 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to insert ACL rules on device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to insert ACL rules on device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device port again
	visited.add(dev_port_key)		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		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -189,7 +188,7 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	try:		try:
	# Check if this port is part of the ACL configuration		# Check if this port is part of the ACL configuration
	_ = self._get_switch_port_in_port_map(device_name, port_id)		_ = 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))		LOGGER.warning("Switch {} endpoint {} is not part of the ACL configuration".format(device_name, port_id))
	results.append(False)		results.append(False)
	continue		continue
	@@ -216,20 +215,19 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to delete ACL rules from device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to delete ACL rules from device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device port again
	visited.add(dev_port_key)		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		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -342,24 +340,26 @@ class P4FabricACLServiceHandler(_ServiceHandler):

	def _parse_settings(self):		def _parse_settings(self):
	try:		try:
	self.__switch_info = self.__settings.value[SWITCH_INFO]		switch_info = self.__settings.value[SWITCH_INFO]
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to parse service settings: {}".format(ex))		LOGGER.error("Failed to parse service settings: {}".format(ex))
	raise Exception(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 in switch_info:
	for switch_name, switch_info in switch.items():		for switch_name, sw_info in switch.items():
	assert switch_name, "Invalid P4 switch name"		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 isinstance(sw_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 sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
	"Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))		"Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
	switch_dpid = 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, switch_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		# Access Control list
	acl = switch_info[ACL]		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)"		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:		for acl_entry in acl:
	LOGGER.info("ACL entry: {}".format(acl_entry))		LOGGER.info("ACL entry: {}".format(acl_entry))
	port_id = acl_entry[PORT_ID]		port_id = acl_entry[PORT_ID]
	@@ -398,13 +398,13 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	trn_port_src = -1		trn_port_src = -1
	if TRN_PORT_SRC in acl_entry:		if TRN_PORT_SRC in acl_entry:
	trn_port_src = acl_entry[TRN_PORT_SRC]		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		map_entry[TRN_PORT_SRC] = trn_port_src

	trn_port_dst = -1		trn_port_dst = -1
	if TRN_PORT_DST in acl_entry:		if TRN_PORT_DST in acl_entry:
	trn_port_dst = acl_entry[TRN_PORT_DST]		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		map_entry[TRN_PORT_DST] = trn_port_dst

	action = acl_entry[ACTION]		action = acl_entry[ACTION]
	@@ -416,11 +416,12 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	# Add routing entry		# Add routing entry
	switch_port_entry[ACL].append(map_entry)		switch_port_entry[ACL].append(map_entry)

			self.__switch_info[switch_name] = sw_info

	def _print_settings(self):		def _print_settings(self):
	LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))		LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))
	LOGGER.info("--- Topology info")		LOGGER.info("--- Topology info")
	for switch in self.__switch_info:		for switch_name, switch_info in self.__switch_info.items():
	for switch_name, switch_info in switch.items():
	LOGGER.info("\t Device {}".format(switch_name))		LOGGER.info("\t Device {}".format(switch_name))
	LOGGER.info("\t\t\| Target P4 architecture: {}".format(switch_info[ARCH]))		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\| Data plane ID: {}".format(switch_info[DPID]))
	@@ -450,6 +451,7 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	acl = self._get_acl_of_switch_port(switch_name=dev_name, port_id=port_id)		acl = self._get_acl_of_switch_port(switch_name=dev_name, port_id=port_id)
	for acl_entry in acl:		for acl_entry in acl:
	if IPV4_SRC in acl_entry:		if IPV4_SRC in acl_entry:
			try:
	rules += rules_set_up_acl_filter_host(		rules += rules_set_up_acl_filter_host(
	ingress_port=port_id,		ingress_port=port_id,
	ip_address=acl_entry[IPV4_SRC],		ip_address=acl_entry[IPV4_SRC],
	@@ -457,7 +459,12 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	ip_direction="src",		ip_direction="src",
	action=action		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:		if IPV4_DST in acl_entry:
			try:
	rules += rules_set_up_acl_filter_host(		rules += rules_set_up_acl_filter_host(
	ingress_port=port_id,		ingress_port=port_id,
	ip_address=acl_entry[IPV4_DST],		ip_address=acl_entry[IPV4_DST],
	@@ -465,19 +472,32 @@ class P4FabricACLServiceHandler(_ServiceHandler):
	ip_direction="dst",		ip_direction="dst",
	action=action		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:		if TRN_PORT_SRC in acl_entry:
			try:
	rules += rules_set_up_acl_filter_port(		rules += rules_set_up_acl_filter_port(
	ingress_port=port_id,		ingress_port=port_id,
	transport_port=acl_entry[TRN_PORT_SRC],		transport_port=acl_entry[TRN_PORT_SRC],
	transport_direction="src",		transport_direction="src",
	action=action		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:		if TRN_PORT_DST in acl_entry:
			try:
	rules += rules_set_up_acl_filter_port(		rules += rules_set_up_acl_filter_port(
	ingress_port=port_id,		ingress_port=port_id,
	transport_port=acl_entry[TRN_PORT_DST],		transport_port=acl_entry[TRN_PORT_DST],
	transport_direction="dst",		transport_direction="dst",
	action=action		action=action
	)		)
			except Exception as ex:
			LOGGER.error("Error while creating ACL destination port filter rules")
			raise Exception(ex)

	return rules		return rules

src/service/service/service_handlers/p4_fabric_tna_int/p4_fabric_tna_int_service_handler.py

+79 −47

Original line number	Original line	Diff line number	Diff line
	@@ -116,20 +116,19 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to insert INT rules on device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to insert INT rules on device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device again
	visited.add(device.name)		visited.add(device.name)

	if applied_rules > 0:
	LOGGER.info("Installed {}/{} INT rules on device {}".format(
	applied_rules, actual_rules, device.name))

	return results		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -182,20 +181,19 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	task_executor=self.__task_executor, device_obj=device, json_config_rules=rules)		task_executor=self.__task_executor, device_obj=device, json_config_rules=rules)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to delete INT rules from device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to delete INT rules from device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device again
	visited.add(device.name)		visited.add(device.name)

	if applied_rules > 0:
	LOGGER.info("Deleted {}/{} INT rules from device {}".format(
	applied_rules, actual_rules, device.name))

	return results		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -312,33 +310,33 @@ class P4FabricINTServiceHandler(_ServiceHandler):

	def _parse_settings(self):		def _parse_settings(self):
	try:		try:
	self.__switch_info = self.__settings.value[SWITCH_INFO]		switch_info = self.__settings.value[SWITCH_INFO]
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to parse service settings: {}".format(ex))		LOGGER.error("Failed to parse service settings: {}".format(ex))
	raise Exception(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 switch_info:
	for switch in self.__switch_info:		for switch_name, sw_info in switch.items():
	for switch_name, switch_info in switch.items():
	assert switch_name, "Invalid P4 switch name"		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 isinstance(sw_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 sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
	"Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(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 sw_info[DPID] > 0, "Switch {} - P4 switch dataplane ID must be a positive integer".format(switch_name, sw_info[DPID])
	assert chk_address_mac(switch_info[MAC]), "Switch {} - Invalid source Ethernet address".format(switch_name)		assert chk_address_mac(sw_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 chk_address_ipv4(sw_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 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 switch_info[PORT_INT][PORT_ID] >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)		assert sw_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[PORT_INT][PORT_TYPE] in PORT_TYPES_STR_VALID, "Switch {} - Valid P4 switch port types are: {}".format(
	switch_name, ','.join(PORT_TYPES_STR_VALID))		switch_name, ','.join(PORT_TYPES_STR_VALID))
	if arch_tna(switch_info[ARCH]):		if arch_tna(sw_info[ARCH]):
	switch_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_TNA		sw_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_TNA
	switch_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_TNA		sw_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_TNA
	else:		else:
	switch_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_V1MODEL		sw_info[RECIRCULATION_PORT_LIST] = RECIRCULATION_PORTS_V1MODEL
	switch_info[INT_REPORT_MIRROR_ID_LIST] = INT_REPORT_MIRROR_ID_LIST_V1MODEL		sw_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)		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]		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)"		assert isinstance(self.__int_collector_info, dict), "INT collector info object must be a map with mac, ip, port, and vlan_id keys)"
	@@ -358,8 +356,7 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	def _print_settings(self):		def _print_settings(self):
	LOGGER.info("-------------------- {} settings --------------------".format(self.__service.name))		LOGGER.info("-------------------- {} settings --------------------".format(self.__service.name))
	LOGGER.info("--- Topology info")		LOGGER.info("--- Topology info")
	for switch in self.__switch_info:		for switch_name, switch_info in self.__switch_info.items():
	for switch_name, switch_info in switch.items():
	LOGGER.info("\t Device {}".format(switch_name))		LOGGER.info("\t Device {}".format(switch_name))
	LOGGER.info("\t\t\| Target P4 architecture: {}".format(switch_info[ARCH]))		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\| Data plane ID: {}".format(switch_info[DPID]))
	@@ -379,9 +376,14 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	dev_name = device_obj.name		dev_name = device_obj.name
	rules = []		rules = []

	try:
	### INT reporting rules		### INT reporting rules
			try:
	rules += rules_set_up_int_watchlist(action=action)		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(		rules += rules_set_up_int_recirculation_ports(
	recirculation_port_list=self.__switch_info[dev_name][RECIRCULATION_PORT_LIST],		recirculation_port_list=self.__switch_info[dev_name][RECIRCULATION_PORT_LIST],
	port_type=PORT_TYPE_INT,		port_type=PORT_TYPE_INT,
	@@ -389,10 +391,20 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	vlan_id=self.__int_vlan_id,		vlan_id=self.__int_vlan_id,
	action=action		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(		rules += rules_set_up_int_report_collector(
	int_collector_ip=self.__int_collector_ip,		int_collector_ip=self.__int_collector_ip,
	action=action		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(		rules += rules_set_up_int_report_flow(
	switch_id=self.__switch_info[dev_name][DPID],		switch_id=self.__switch_info[dev_name][DPID],
	src_ip=self.__switch_info[dev_name][IP],		src_ip=self.__switch_info[dev_name][IP],
	@@ -400,12 +412,22 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	int_collector_port=self.__int_collector_port,		int_collector_port=self.__int_collector_port,
	action=action		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(		rules += rules_set_up_report_mirror_flow(
	recirculation_port_list=self.__switch_info[dev_name][RECIRCULATION_PORT_LIST],		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],		report_mirror_id_list=self.__switch_info[dev_name][INT_REPORT_MIRROR_ID_LIST],
	action=action		action=action
	)		)
			except Exception as ex:
			LOGGER.error("Error while creating report mirror flow rules")
			raise Exception(ex)

	### INT port setup rules		### INT port setup rules
			try:
	rules += rules_set_up_port(		rules += rules_set_up_port(
	port=self.__switch_info[dev_name][PORT_INT][PORT_ID],		port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
	port_type=PORT_TYPE_HOST,		port_type=PORT_TYPE_HOST,
	@@ -413,7 +435,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	vlan_id=self.__int_vlan_id,		vlan_id=self.__int_vlan_id,
	action=action		action=action
	)		)
			except Exception as ex:
			LOGGER.error("Error while creating INT port rules")
			raise Exception(ex)

	### INT port forwarding rules		### INT port forwarding rules
			try:
	rules += rules_set_up_fwd_bridging(		rules += rules_set_up_fwd_bridging(
	vlan_id=self.__int_vlan_id,		vlan_id=self.__int_vlan_id,
	eth_dst=self.__int_collector_mac,		eth_dst=self.__int_collector_mac,
	@@ -424,7 +451,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],		egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
	action=action		action=action
	)		)
			except Exception as ex:
			LOGGER.error("Error while creating INT bridging rules")
			raise Exception(ex)

	### INT packet routing rules		### INT packet routing rules
			try:
	rules += rules_set_up_next_routing_simple(		rules += rules_set_up_next_routing_simple(
	egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],		egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
	eth_src=self.__switch_info[dev_name][MAC],		eth_src=self.__switch_info[dev_name][MAC],
	@@ -438,7 +470,7 @@ class P4FabricINTServiceHandler(_ServiceHandler):
	action=action		action=action
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Error while creating rules")		LOGGER.error("Error while creating INT routing rules")
	raise Exception(ex)		raise Exception(ex)

	return rules		return rules

src/service/service/service_handlers/p4_fabric_tna_l2_simple/p4_fabric_tna_l2_simple_service_handler.py

+29 −30

Original line number	Original line	Diff line number	Diff line
	@@ -121,20 +121,19 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to insert L2 rules on device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to insert L2 rules on device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device port again
	visited.add(dev_port_key)		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		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -199,20 +198,19 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
	)		)
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to delete L2 rules from device {} due to {}".format(device.name, ex))		LOGGER.error("Failed to delete L2 rules from device {} due to {}".format(device.name, ex))
			results.append(ex)
	finally:		finally:
	rules.clear()		rules.clear()

	# Ensure correct status		# Ensure correct status
	results.append(True) if (failed_rules == 0) and (applied_rules == actual_rules) \		if (failed_rules == 0) and (applied_rules == actual_rules):
	else results.append(False)		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		# You should no longer visit this device port again
	visited.add(dev_port_key)		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		return results

	@metered_subclass_method(METRICS_POOL)		@metered_subclass_method(METRICS_POOL)
	@@ -325,24 +323,25 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):

	def _parse_settings(self):		def _parse_settings(self):
	try:		try:
	self.__switch_info = self.__settings.value[SWITCH_INFO]		switch_info = self.__settings.value[SWITCH_INFO]
	except Exception as ex:		except Exception as ex:
	LOGGER.error("Failed to parse service settings: {}".format(ex))		LOGGER.error("Failed to parse service settings: {}".format(ex))
	raise Exception(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 in switch_info:
	for switch_name, switch_info in switch.items():		for switch_name, sw_info in switch.items():
	assert switch_name, "Invalid P4 switch name"		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 isinstance(sw_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 sw_info[ARCH] in SUPPORTED_TARGET_ARCH_LIST, \
	"Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))		"Switch {} - Supported P4 architectures are: {}".format(switch_name, ','.join(SUPPORTED_TARGET_ARCH_LIST))
	switch_dpid = 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, switch_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
	port_list = switch_info[PORT_LIST]		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)"		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:		for port in port_list:
	port_id = port[PORT_ID]		port_id = port[PORT_ID]
	assert port_id >= 0, "Switch {} - Invalid P4 switch port ID".format(switch_name)		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] = []		self.__port_map[switch_name][port_key][FORWARDING_LIST] = []

	# Forwarding list		# Forwarding list
	fwd_list = switch_info[FORWARDING_LIST]		fwd_list = sw_info[FORWARDING_LIST]
	assert isinstance(fwd_list, list), "Switch {} forwarding list be a list)"		assert isinstance(fwd_list, list), "Switch {} forwarding list must be a list".format(switch_name)
	for fwd_entry in fwd_list:		for fwd_entry in fwd_list:
	port_id = fwd_entry[PORT_ID]		port_id = fwd_entry[PORT_ID]
	assert port_id >= 0, "Invalid port ID: {}".format(port_id)		assert port_id >= 0, "Invalid port ID: {}".format(port_id)
	@@ -377,12 +376,12 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
	host_facing_port = self._is_host_facing_port(switch_name, port_id)		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"))		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)		switch_port_entry[FORWARDING_LIST].append(host_mac)
			self.__switch_info[switch_name] = sw_info

	def _print_settings(self):		def _print_settings(self):
	LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))		LOGGER.info("--------------- {} settings ---------------".format(self.__service.name))
	LOGGER.info("--- Topology info")		LOGGER.info("--- Topology info")
	for switch in self.__switch_info:		for switch_name, switch_info in self.__switch_info.items():
	for switch_name, switch_info in switch.items():
	LOGGER.info("\t Device {}".format(switch_name))		LOGGER.info("\t Device {}".format(switch_name))
	LOGGER.info("\t\t\| Target P4 architecture: {}".format(switch_info[ARCH]))		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\| Data plane ID: {}".format(switch_info[DPID]))

src/service/service/service_handlers/p4_fabric_tna_l3/p4_fabric_tna_l3_service_handler.py

+29 −30

File changed.

Preview size limit exceeded, changes collapsed.