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
@@ -71,12 +72,16 @@ def get_circuit(self, circuit_id: str) -> Optional[Dict]:
     def upsert_evc(self, evc: Dict) -> Optional[Dict]:
         """Update or insert an EVC"""
         utc_now = datetime.utcnow()
-        model = EVCBaseDoc(
-            **{
-                **evc,
-                **{"_id": evc["id"]}
-            }
-        )
+        try:
+            model = EVCBaseDoc(
+                **{
+                    **evc,
+                    **{"_id": evc["id"]}
+                }
+            )
+        except ValidationError as err:
+            raise err
+
         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,17 @@ 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', 'untagged' and the ",
+                         "format 'n/n'")
 
 
 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)
@@ -218,12 +219,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

@@ -252,7 +252,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)
 
@@ -811,8 +814,8 @@ 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(
@@ -825,27 +828,31 @@ def _prepare_direct_uni_flows(self):
             self.queue_id, is_EVPL
         )
 
-        if vlan_a and vlan_z:
+        if vlan_a is not None and vlan_z is not None:
             flow_mod_az["match"]["dl_vlan"] = vlan_a
             flow_mod_za["match"]["dl_vlan"] = vlan_z
-            flow_mod_az["actions"].insert(
-                0, {"action_type": "set_vlan", "vlan_id": vlan_z}
-            )
-            flow_mod_za["actions"].insert(
-                0, {"action_type": "set_vlan", "vlan_id": vlan_a}
-            )
-        elif vlan_a:
+            if vlan_z not in ("4096/4096", 0):
+                flow_mod_az["actions"].insert(
+                    0, {"action_type": "set_vlan", "vlan_id": vlan_z}
+                )
+            if vlan_a not in ("4096/4096", 0):
+                flow_mod_za["actions"].insert(
+                    0, {"action_type": "set_vlan", "vlan_id": vlan_a}
+                )
+        elif vlan_a is not None:
             flow_mod_az["match"]["dl_vlan"] = vlan_a
             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:
+            if vlan_a not in ("4096/4096", 0):
+                flow_mod_za["actions"].insert(
+                    0, {"action_type": "set_vlan", "vlan_id": vlan_a}
+                )
+        elif vlan_z is not None:
             flow_mod_za["match"]["dl_vlan"] = 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}
-            )
+            if vlan_z not in ("4096/4096", 0):
+                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]
         )
@@ -896,6 +903,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 = {}
@@ -904,10 +924,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
@@ -1034,7 +1054,6 @@ 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)
 
@@ -1061,27 +1080,28 @@ def _prepare_push_flow(self, *args, queue_id=None):
         flow_mod = self._prepare_flow_mod(
             in_interface, out_interface, queue_id, is_EVPL
         )
-
         # the service tag must be always pushed
-        new_action = {"action_type": "set_vlan", "vlan_id": out_vlan}
-        flow_mod["actions"].insert(0, new_action)
+        if in_vlan not in ("4096/4096", 0):
+            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:
+        if new_c_vlan is not None:
             # new_in_vlan is set, so an action to set it is necessary
-            new_action = {"action_type": "set_vlan", "vlan_id": new_c_vlan}
-            flow_mod["actions"].insert(0, new_action)
-            if not in_vlan:
+            if new_c_vlan not in ("4096/4096", 0):
+                new_action = {"action_type": "set_vlan", "vlan_id": new_c_vlan}
+                flow_mod["actions"].insert(0, new_action)
+            if in_vlan is None:
                 # 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:
+        elif in_vlan is not None:
             # in_vlan is set, but new_in_vlan is not, so the existing vlan
             # must be removed
             new_action = {"action_type": "pop_vlan"}

openapi.yml

@@ -598,16 +598,15 @@ 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
 
     CircuitSchedule: # Can be referenced via '#/components/schemas/CircuitSchedule'
       type: object