Merge branch 'pr-p4-fabric-fix' into 'develop' (c16256e4) · Commits · TFS / controller

src/common/tools/descriptor/Tools.py

+1 −1

Original line number	Diff line number	Diff line
		@@ -148,7 +148,7 @@ def split_links_by_type(links : List[Dict]) -> Dict[str, List[Dict]]:
		raise Exception(MSG.format(str(link)))

		link_type = LinkTypeEnum.Value(str_link_type)
		if link_type in {LinkTypeEnum.LINKTYPE_UNKNOWN, LinkTypeEnum.LINKTYPE_COPPER, LinkTypeEnum.LINKTYPE_RADIO}:
		if link_type in {LinkTypeEnum.LINKTYPE_UNKNOWN, LinkTypeEnum.LINKTYPE_COPPER, LinkTypeEnum.LINKTYPE_RADIO, LinkTypeEnum.LINKTYPE_MANAGEMENT}:
		typed_links['normal'].append(link)
		elif link_type in {LinkTypeEnum.LINKTYPE_FIBER}:
		typed_links['optical'].append(link)

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

+132 −108

Original line number	Diff line number	Diff line
		@@ -130,19 +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)

		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)
		@@ -188,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
		@@ -214,20 +214,20 @@ class P4FabricACLServiceHandler(_ServiceHandler):
		json_config_rules=rules
		)
		except Exception as ex:
		LOGGER.error("Failed to insert ACL rules on 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:
		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)

		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)
		@@ -340,23 +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, dict), "Switch info object must be a map with switch names as keys"
		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_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]
		@@ -395,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]
		@@ -413,6 +416,8 @@ 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")
		@@ -446,6 +451,7 @@ 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:
		try:
		rules += rules_set_up_acl_filter_host(
		ingress_port=port_id,
		ip_address=acl_entry[IPV4_SRC],
		@@ -453,7 +459,12 @@ class P4FabricACLServiceHandler(_ServiceHandler):
		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:
		try:
		rules += rules_set_up_acl_filter_host(
		ingress_port=port_id,
		ip_address=acl_entry[IPV4_DST],
		@@ -461,19 +472,32 @@ class P4FabricACLServiceHandler(_ServiceHandler):
		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:
		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:
		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

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

+74 −37

Original line number	Diff line number	Diff line
		@@ -116,19 +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)

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

		return results

		@metered_subclass_method(METRICS_POOL)
		@@ -181,19 +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)

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

		return results

		@metered_subclass_method(METRICS_POOL)
		@@ -310,31 +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, dict), "Switch info object must be a map with switch names as keys"
		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_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)"
		@@ -374,9 +376,14 @@ class P4FabricINTServiceHandler(_ServiceHandler):
		dev_name = device_obj.name
		rules = []

		try:
		### INT reporting rules
		try:
		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,
		@@ -384,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],
		@@ -395,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
		)
		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,
		@@ -408,7 +435,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
		vlan_id=self.__int_vlan_id,
		action=action
		)
		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,
		@@ -419,7 +451,12 @@ class P4FabricINTServiceHandler(_ServiceHandler):
		egress_port=self.__switch_info[dev_name][PORT_INT][PORT_ID],
		action=action
		)
		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],
		@@ -433,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

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

+63 −60

Original line number	Diff line number	Diff line
		@@ -121,19 +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)

		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)
		@@ -197,20 +197,20 @@ class P4FabricL2SimpleServiceHandler(_ServiceHandler):
		json_config_rules=rules
		)
		except Exception as ex:
		LOGGER.error("Failed to insert L2 rules on 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:
		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)

		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)
		@@ -323,23 +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, dict), "Switch info object must be a map with switch names as keys"
		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_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)
		@@ -360,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)
		@@ -374,6 +376,7 @@ 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))

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

+72 −69

File changed.

Preview size limit exceeded, changes collapsed.