Merge pull request #267 from atlanticwave-sdx/266-request-on-the-same-switch

request with the same port (invalid) or the same node (just vlan assi…

Author: YufengXin

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "sdx-pce"
-version = "3.0.0.dev9"
+version = "3.0.0.dev10"
 description = "Heuristic and Optimal Algorithms for CSP and TE Computation"
 authors = [
     { name = "Yufeng Xin", email = "yxin@renci.org" },

src/sdx_pce/topology/temanager.py

@@ -29,6 +29,7 @@
 from sdx_pce.utils.constants import Constants
 from sdx_pce.utils.exceptions import (
     RequestValidationError,
+    SameSwitchRequestError,
     TEError,
     UnknownRequestError,
     ValidationError,
@@ -412,6 +413,14 @@ def generate_traffic_matrix(self, connection_request: dict) -> TrafficMatrix:
             f"ingress_port.id: {ingress_port.id}, "
             f"egress_port.id: {egress_port.id}"
         )
+        if ingress_port.id == egress_port.id:
+            self._logger.warning(
+                f"Source and destination ports are the same: {ingress_port.id}"
+            )
+            raise RequestValidationError(
+                f"Source and destination ports are the same: {ingress_port.id}",
+                400,
+            )
 
         topology = self.topology_manager.get_topology()
 
@@ -430,6 +439,24 @@ def generate_traffic_matrix(self, connection_request: dict) -> TrafficMatrix:
             )
             return None
 
+        if ingress_node == egress_node:
+            self._logger.warning(
+                f"Source and destination nodes are the same: {ingress_node.id}"
+            )
+            domain_id = self.topology_manager.get_domain_name(ingress_node.id)
+            ingress_user_port_tag = ingress_port.vlan_range
+            egree_user_port_tag = egress_port.vlan_range
+            self._logger.info(f"Same switch request: {domain_id}")
+            raise SameSwitchRequestError(
+                f"Source and destination nodes are the same: {ingress_node.id}",
+                request.id,
+                domain_id,
+                ingress_port.id,
+                egress_port.id,
+                ingress_user_port_tag,
+                egree_user_port_tag,
+            )
+
         ingress_nodes = [
             x for x, y in self.graph.nodes(data=True) if y["id"] == ingress_node.id
         ]
@@ -581,6 +608,77 @@ def add_breakdowns_to_connection(self, connection_request: dict, breakdowns: dic
 
         return connection_request
 
+    # Special case: endpoints on the same device, no need to call the solver, only need vlan assignment
+    def generate_connection_breakdown_same_switch(
+        self,
+        request_id,
+        domain,
+        ingress_port_id: str,
+        egress_port_id: str,
+        ingress_port_tag,
+        egress_port_tag,
+    ):
+        """
+        Generate a breakdown for a connection request where the source and destination ports are the same.
+        """
+        ingress_port = self.topology_manager.get_port_by_id(ingress_port_id)
+        egress_port = self.topology_manager.get_port_by_id(egress_port_id)
+
+        self._logger.debug(
+            f"ingress_port: {ingress_port_id}, egress_port: {egress_port_id}, ingress_port_tag: {ingress_port_tag}, egress_port_tag: {egress_port_tag}"
+        )
+
+        ingress_vlan = self._reserve_vlan(
+            domain,
+            ingress_port,
+            request_id,
+            ingress_port_tag,
+            None,
+        )
+
+        egress_vlan = self._reserve_vlan(
+            domain,
+            egress_port,
+            request_id,
+            egress_port_tag,
+            None,
+        )
+
+        if ingress_vlan is None or egress_vlan is None:
+            self._logger.error(
+                f"ingress_vlan: {ingress_vlan}, egress_vlan: {egress_vlan}. "
+                f"Can't proceed. Rolling back reservations."
+            )
+            self.unreserve_vlan(request_id=request_id)
+            raise TEError(f"Can't find a vlan assignment for: {request_id}", 410)
+
+        self._logger.debug(f"ingress_vlan: {ingress_vlan}, egress_vlan: {egress_vlan}")
+
+        tag_type = 0 if ingress_vlan == "untagged" else 1
+        port_a = VlanTaggedPort(
+            VlanTag(value=ingress_vlan, tag_type=tag_type), port_id=ingress_port_id
+        )
+        tag_type = 0 if egress_vlan == "untagged" else 1
+        port_z = VlanTaggedPort(
+            VlanTag(value=egress_vlan, tag_type=tag_type), port_id=egress_port_id
+        )
+
+        # Names look like "AMLIGHT_vlan_201_202_Ampath_Tenet".  We
+        # can form the initial part, but where did the
+        # `Ampath_Tenet` at the end come from?
+        domain_name = domain.split(":")[-1].split(".")[0].upper()
+        name = f"{domain_name}_vlan_{ingress_vlan}_{egress_vlan}"
+        breakdowns = {}
+        breakdown = VlanTaggedBreakdown(
+            name=name,
+            dynamic_backup_path=True,
+            uni_a=port_a,
+            uni_z=port_z,
+        )
+        breakdowns[domain] = breakdown.to_dict()
+        return breakdowns
+
+    # General case
     def generate_connection_breakdown(
         self, solution: ConnectionSolution, connection_request: dict
     ) -> dict:
@@ -1236,7 +1334,7 @@ def _reserve_vlan(
         # with self._topology_lock:
         #     pass
 
-        self._logger.debug(
+        self._logger.info(
             f"Reserving VLAN for domain: {domain}, port: {port}, "
             f"request_id: {request_id}, tag:{tag}"
         )
@@ -1262,6 +1360,7 @@ def _reserve_vlan(
             self._logger.warning(
                 f"Can't find a VLAN table for domain: {domain} port: {port_id}"
             )
+            self._logger.warning(f"Available ports: {domain_table.keys()}")
             return None
 
         if tag is None:

src/sdx_pce/utils/exceptions.py

@@ -21,6 +21,34 @@ def __init__(self, message: str, request_id: str):
         self.request_id = request_id
 
 
+class SameSwitchRequestError(Exception):
+    """
+    A custom exception to represent a request with endpoints on the same switch.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        request_id: str,
+        domain_id: str,
+        ingress_port: str,
+        egress_port: str,
+        ingress_user_port_tag,
+        egress_user_port_tag,
+    ):
+        """
+        :param message: a string containing the error message.
+        :param request_id: a string containing request ID.
+        """
+        super().__init__(f"{message} (ID: {request_id})")
+        self.request_id = request_id
+        self.domain_id = domain_id
+        self.ingress_port = ingress_port
+        self.egress_port = egress_port
+        self.ingress_user_port_tag = ingress_user_port_tag
+        self.egress_user_port_tag = egress_user_port_tag
+
+
 class RequestValidationError(Exception):
     """
     A custom exception to represent TE (Traffic Engineering) errors.

tests/test_te_manager.py

@@ -9,6 +9,7 @@
 from sdx_pce.topology.temanager import TEManager
 from sdx_pce.utils.exceptions import (
     RequestValidationError,
+    SameSwitchRequestError,
     TEError,
     UnknownRequestError,
     ValidationError,
@@ -334,7 +335,10 @@ def test_generate_graph_and_connection_with_sax_2_invalid(self):
         # unresolvable port IDs, which are not present in the given
         # topology.
         request = json.loads(TestData.CONNECTION_REQ_FILE_SAX_2_INVALID.read_text())
-        tm = temanager.generate_traffic_matrix(request)
+        tm = None
+        with self.assertRaises(RequestValidationError) as ctx:
+            tm = temanager.generate_traffic_matrix(request)
+        print(f"{ctx.exception}")
         self.assertIsNone(tm)
 
     def test_generate_graph_and_connection_with_sax_2_valid(self):
@@ -438,6 +442,66 @@ def test_connection_amlight_v2(self):
         #   (ampath1, ampath3), (ampath3, ampath2)
         self.assertEqual(len(next(iter(solution.connection_map.values()))), 2)
 
+    def test_connection_amlight_v2_with_same_port_invalid(self):
+        """
+        Test with just one topology/domain.
+        """
+        topology = json.loads(TestData.TOPOLOGY_FILE_AMLIGHT_v2.read_text())
+        temanager = TEManager(topology_data=topology)
+        graph = temanager.generate_graph_te()
+
+        self.assertIsInstance(graph, nx.Graph)
+
+        request = {
+            "name": "new-connection",
+            "id": "123",
+            "endpoints": [
+                {"port_id": "urn:sdx:port:ampath.net:Ampath1:50", "vlan": "777"},
+                {"port_id": "urn:sdx:port:ampath.net:Ampath1:50", "vlan": "777"},
+            ],
+            "qos_metrics": {},
+            "scheduling": {},
+        }
+        with self.assertRaises(RequestValidationError) as ctx:
+            temanager.generate_traffic_matrix(request)
+        print(f"{ctx.exception}")
+
+    def test_connection_amlight_v2_with_same_node_valid(self):
+        """
+        Test with just one topology/domain.
+        """
+        topology = json.loads(TestData.TOPOLOGY_FILE_AMLIGHT_v2.read_text())
+        temanager = TEManager(topology_data=topology)
+        graph = temanager.generate_graph_te()
+
+        self.assertIsInstance(graph, nx.Graph)
+
+        request = {
+            "name": "new-connection",
+            "id": "123",
+            "endpoints": [
+                {"port_id": "urn:sdx:port:ampath.net:Ampath1:40", "vlan": "untagged"},
+                {"port_id": "urn:sdx:port:ampath.net:Ampath1:50", "vlan": "777"},
+            ],
+            "qos_metrics": {},
+            "scheduling": {},
+        }
+        try:
+            temanager.generate_traffic_matrix(request)
+        except SameSwitchRequestError as ctx:
+            print(
+                f"{str(ctx)},{ctx.request_id},{ctx.domain_id},{ctx.ingress_port},{ctx.egress_port}, {ctx.ingress_user_port_tag}, {ctx.egress_user_port_tag}"
+            )
+            breakdown = temanager.generate_connection_breakdown_same_switch(
+                ctx.request_id,
+                ctx.domain_id,
+                ctx.ingress_port,
+                ctx.egress_port,
+                ctx.ingress_user_port_tag,
+                ctx.egress_user_port_tag,
+            )
+            print(f"Breakdown: {breakdown}")
+
     def test_connection_amlight_user_port(self):
         """
         Test with just one topology/domain.