feature: Allow creation for "any" and "untagged" as EVCs

controllers/__init__.py

@@ -5,6 +5,7 @@
 from typing import Dict, Optional
 
 import pymongo
+from pydantic import ValidationError
 from pymongo.collection import ReturnDocument
 from pymongo.errors import AutoReconnect
 from tenacity import retry_if_exception_type, stop_after_attempt, wait_random
@@ -77,6 +78,7 @@ def upsert_evc(self, evc: Dict) -> Optional[Dict]:
                 **{"_id": evc["id"]}
             }
         )
+
         updated = self.db.evcs.find_one_and_update(
             {"_id": evc["id"]},
             {

db/models.py

@@ -3,9 +3,9 @@
 # pylint: disable=no-self-argument,no-name-in-module
 
 from datetime import datetime
-from typing import Dict, List, Literal, Optional
+from typing import Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 
 
 class DocumentBaseModel(BaseModel):
@@ -38,7 +38,16 @@ class CircuitScheduleDoc(BaseModel):
 class TAGDoc(BaseModel):
     """TAG model"""
     tag_type: int
-    value: int
+    value: Union[int, str]
+
+    @validator('value')
+    def validate_value(cls, value):
+        """Validate value when is a string"""
+        if isinstance(value, int):
+            return value
+        if isinstance(value, str) and value in ("any", "untagged"):
+            return value
+        raise ValueError("value as string allows 'any' and 'untagged'")
 
 
 class UNIDoc(BaseModel):

main.py

@@ -7,6 +7,7 @@
 from threading import Lock
 
 from flask import jsonify, request
+from pydantic import ValidationError
 from werkzeug.exceptions import (BadRequest, Conflict, Forbidden,
                                  MethodNotAllowed, NotFound,
                                  UnsupportedMediaType)
@@ -229,12 +230,15 @@ def create_circuit(self, data):
         except ValueError as exception:
             raise BadRequest(str(exception)) from exception
 
+        # save circuit
+        try:
+            evc.sync()
+        except ValidationError as exception:
+            raise BadRequest(str(exception)) from exception
+
         # store circuit in dictionary
         self.circuits[evc.id] = evc
 
-        # save circuit
-        evc.sync()
-
         # Schedule the circuit deploy
         self.sched.add(evc)
 

models/evc.py

@@ -251,7 +251,10 @@ def _validate(self, **kwargs):
                     raise ValueError(f"{attribute} is an invalid UNI.")
 
                 if not uni.is_valid():
-                    tag = uni.user_tag.value
+                    try:
+                        tag = uni.user_tag.value
+                    except AttributeError:
+                        tag = None
                     message = f"VLAN tag {tag} is not available in {attribute}"
                     raise ValueError(message)
 
@@ -810,41 +813,50 @@ def get_failover_flows(self):
 
     def _prepare_direct_uni_flows(self):
         """Prepare flows connecting two UNIs for intra-switch EVC."""
-        vlan_a = self.uni_a.user_tag.value if self.uni_a.user_tag else None
-        vlan_z = self.uni_z.user_tag.value if self.uni_z.user_tag else None
+        vlan_a = self._get_value_from_uni_tag(self.uni_a)
+        vlan_z = self._get_value_from_uni_tag(self.uni_z)
 
-        is_EVPL = (vlan_a is not None)
         flow_mod_az = self._prepare_flow_mod(
             self.uni_a.interface, self.uni_z.interface,
-            self.queue_id, is_EVPL
+            self.queue_id, vlan_a
         )
-        is_EVPL = (vlan_z is not None)
         flow_mod_za = self._prepare_flow_mod(
             self.uni_z.interface, self.uni_a.interface,
-            self.queue_id, is_EVPL
+            self.queue_id, vlan_z
         )
 
-        if vlan_a and vlan_z:
+        if vlan_a is not None:
             flow_mod_az["match"]["dl_vlan"] = vlan_a
+
+        if vlan_z is not None:
             flow_mod_za["match"]["dl_vlan"] = vlan_z
+
+        if vlan_z not in {None, "4096/4096", 0}:
             flow_mod_az["actions"].insert(
                 0, {"action_type": "set_vlan", "vlan_id": vlan_z}
             )
+            if not vlan_a:
+                flow_mod_az["actions"].insert(
+                    0, {"action_type": "push_vlan", "tag_type": "c"}
+                )
+
+        if vlan_a not in {None, "4096/4096", 0}:
             flow_mod_za["actions"].insert(
-                0, {"action_type": "set_vlan", "vlan_id": vlan_a}
-            )
-        elif vlan_a:
-            flow_mod_az["match"]["dl_vlan"] = vlan_a
+                    0, {"action_type": "set_vlan", "vlan_id": vlan_a}
+                )
+            if not vlan_z:
+                flow_mod_za["actions"].insert(
+                    0, {"action_type": "push_vlan", "tag_type": "c"}
+                )
+            if vlan_z == 0:
+                flow_mod_az["actions"].insert(0, {"action_type": "pop_vlan"})
+
+        elif vlan_a == "4096/4096" and vlan_z == 0:
             flow_mod_az["actions"].insert(0, {"action_type": "pop_vlan"})
-            flow_mod_za["actions"].insert(
-                0, {"action_type": "set_vlan", "vlan_id": vlan_a}
-            )
-        elif vlan_z:
-            flow_mod_za["match"]["dl_vlan"] = vlan_z
+
+        elif vlan_a == 0 and vlan_z:
             flow_mod_za["actions"].insert(0, {"action_type": "pop_vlan"})
-            flow_mod_az["actions"].insert(
-                0, {"action_type": "set_vlan", "vlan_id": vlan_z}
-            )
+
         return (
             self.uni_a.interface.switch.id, [flow_mod_az, flow_mod_za]
         )
@@ -895,6 +907,19 @@ def _install_nni_flows(self, path=None):
         for dpid, flows in self._prepare_nni_flows(path).items():
             self._send_flow_mods(dpid, flows)
 
+    @staticmethod
+    def _get_value_from_uni_tag(uni):
+        """Returns the value from tag. In case of any and untagged
+        it should return 4096/4096 and 0 respectively"""
+        special = {"any": "4096/4096", "untagged": 0}
+
+        if uni.user_tag:
+            value = uni.user_tag.value
+            if isinstance(value, str):
+                return special.get(value, value)
+            return value
+        return None
+
     def _prepare_uni_flows(self, path=None, skip_in=False, skip_out=False):
         """Prepare flows to install UNIs."""
         uni_flows = {}
@@ -903,10 +928,10 @@ def _prepare_uni_flows(self, path=None, skip_in=False, skip_out=False):
             return uni_flows
 
         # Determine VLANs
-        in_vlan_a = self.uni_a.user_tag.value if self.uni_a.user_tag else None
+        in_vlan_a = self._get_value_from_uni_tag(self.uni_a)
         out_vlan_a = path[0].get_metadata("s_vlan").value
 
-        in_vlan_z = self.uni_z.user_tag.value if self.uni_z.user_tag else None
+        in_vlan_z = self._get_value_from_uni_tag(self.uni_z)
         out_vlan_z = path[-1].get_metadata("s_vlan").value
 
         # Flows for the first UNI
@@ -1001,8 +1026,19 @@ def get_id_from_cookie(cookie):
         evc_id = cookie - (settings.COOKIE_PREFIX << 56)
         return f"{evc_id:x}".zfill(14)
 
+    @staticmethod
+    def get_priority(vlan):
+        """Return priority value depending on vlan value"""
+        if vlan not in {"4096/4096", None, 0}:
+            return settings.EVPL_SB_PRIORITY
+        if vlan == 0:
+            return settings.UNTAGGED_SB_PRIORITY
+        if vlan == "4096/4096":
+            return settings.ANY_SB_PRIORITY
+        return settings.EPL_SB_PRIORITY
+
     def _prepare_flow_mod(self, in_interface, out_interface,
-                          queue_id=None, is_EVPL=True):
+                          queue_id=None, vlan=True):
         """Prepare a common flow mod."""
         default_actions = [
             {"action_type": "output", "port": out_interface.port_number}
@@ -1020,10 +1056,7 @@ def _prepare_flow_mod(self, in_interface, out_interface,
         if self.sb_priority:
             flow_mod["priority"] = self.sb_priority
         else:
-            if is_EVPL:
-                flow_mod["priority"] = settings.EVPL_SB_PRIORITY
-            else:
-                flow_mod["priority"] = settings.EPL_SB_PRIORITY
+            flow_mod["priority"] = self.get_priority(vlan)
         return flow_mod
 
     def _prepare_nni_flow(self, *args, queue_id=None):
@@ -1033,13 +1066,11 @@ def _prepare_nni_flow(self, *args, queue_id=None):
             in_interface, out_interface, queue_id
         )
         flow_mod["match"]["dl_vlan"] = in_vlan
-
         new_action = {"action_type": "set_vlan", "vlan_id": out_vlan}
         flow_mod["actions"].insert(0, new_action)
 
         return flow_mod
 
-    # pylint: disable=too-many-arguments
     def _prepare_push_flow(self, *args, queue_id=None):
         """Prepare push flow.
 
@@ -1056,35 +1087,43 @@ def _prepare_push_flow(self, *args, queue_id=None):
         """
         # assign all arguments
         in_interface, out_interface, in_vlan, out_vlan, new_c_vlan = args
-        is_EVPL = (in_vlan is not None)
         flow_mod = self._prepare_flow_mod(
-            in_interface, out_interface, queue_id, is_EVPL
+            in_interface, out_interface, queue_id, in_vlan
         )
-
         # the service tag must be always pushed
         new_action = {"action_type": "set_vlan", "vlan_id": out_vlan}
         flow_mod["actions"].insert(0, new_action)
 
         new_action = {"action_type": "push_vlan", "tag_type": "s"}
         flow_mod["actions"].insert(0, new_action)
 
-        if in_vlan:
+        if in_vlan is not None:
             # if in_vlan is set, it must be included in the match
             flow_mod["match"]["dl_vlan"] = in_vlan
-        if new_c_vlan:
-            # new_in_vlan is set, so an action to set it is necessary
+
+        if new_c_vlan not in {"4096/4096", 0, None}:
+            # new_in_vlan is an integer but zero, action to set is required
             new_action = {"action_type": "set_vlan", "vlan_id": new_c_vlan}
             flow_mod["actions"].insert(0, new_action)
-            if not in_vlan:
-                # new_in_vlan is set, but in_vlan is not, so there was no
-                # vlan set; then it is set now
-                new_action = {"action_type": "push_vlan", "tag_type": "c"}
-                flow_mod["actions"].insert(0, new_action)
-        elif in_vlan:
-            # in_vlan is set, but new_in_vlan is not, so the existing vlan
-            # must be removed
+
+        if in_vlan not in {"4096/4096", 0, None} and new_c_vlan == 0:
+            # # new_in_vlan is an integer but zero and new_c_vlan does not
+            # a pop action is required
+            new_action = {"action_type": "pop_vlan"}
+            flow_mod["actions"].insert(0, new_action)
+
+        elif in_vlan == "4096/4096" and new_c_vlan == 0:
+            # if in_vlan match with any tags and new_c_vlan does not
+            # a pop action is required
             new_action = {"action_type": "pop_vlan"}
             flow_mod["actions"].insert(0, new_action)
+
+        elif not in_vlan and new_c_vlan not in {"4096/4096", 0, None}:
+            # new_in_vlan is an integer but zero and in_vlan is not set
+            # then it is set now
+            new_action = {"action_type": "push_vlan", "tag_type": "c"}
+            flow_mod["actions"].insert(0, new_action)
+
         return flow_mod
 
     def _prepare_pop_flow(

openapi.yml

@@ -598,16 +598,18 @@ components:
 
     Tag: # Can be referenced via '#/components/schemas/Tag'
       type: object
-      required:
-        - tag_type
-        - value
       properties:
         tag_type:
           type: integer
           format: int32
         value:
-          type: integer
-          format: int32
+          oneOf:
+            - type: integer
+              format: int32
+            - type: string
+              enum:
+                - any
+                - untagged
 
     CircuitSchedule: # Can be referenced via '#/components/schemas/CircuitSchedule'
       type: object

settings.py

@@ -41,6 +41,8 @@
 # is not set in a request
 EVPL_SB_PRIORITY = 20000
 EPL_SB_PRIORITY = 10000
+ANY_SB_PRIORITY = 15000
+UNTAGGED_SB_PRIORITY = 20000
 
 #  Time (seconds) to check if an evc has been updated
 #  or flows have been deleted.