build.models.evc.EVCDeploy.is_using_backup_path() - Code Metrics - Inspection of "Update check_list_traces for execute_consistency" - kytos-ng/mef_eline - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#241)

unknown
created 2023-01-19 02:25 UTC
build.models.evc.EVCDeploy.is_using_backup_path() A

↳ Parent: build.models.evc
Complexity

Conditions
Size

Total Lines	3
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	2
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	1
"""Classes used in the main application."""  # pylint: disable=too-many-lines
from collections import OrderedDict
from datetime import datetime
from threading import Lock
from uuid import uuid4

import requests
from glom import glom
from requests.exceptions import ConnectTimeout

from kytos.core import log
from kytos.core.common import EntityStatus, GenericEntity
from kytos.core.exceptions import KytosNoTagAvailableError
from kytos.core.helpers import get_time, now
from kytos.core.interface import UNI
from napps.kytos.mef_eline import controllers, settings
from napps.kytos.mef_eline.exceptions import FlowModException, InvalidPath
from napps.kytos.mef_eline.utils import (compare_endpoint_trace, emit_event,
                                         notify_link_available_tags)

from .path import DynamicPathManager, Path


class EVCBase(GenericEntity):
    """Class to represent a circuit."""

    read_only_attributes = [
        "creation_time",
        "active",
        "current_path",
        "failover_path",
        "_id",
        "archived",
    ]
    attributes_requiring_redeploy = [
        "primary_path",
        "backup_path",
        "dynamic_backup_path",
        "queue_id",
        "sb_priority",
        "primary_constraints",
        "secondary_constraints"
    ]
    required_attributes = ["name", "uni_a", "uni_z"]

    def __init__(self, controller, **kwargs):
        """Create an EVC instance with the provided parameters.

        Args:
            id(str): EVC identifier. Whether it's None an ID will be genereted.
                     Only the first 14 bytes passed will be used.
            name: represents an EVC name.(Required)
            uni_a (UNI): Endpoint A for User Network Interface.(Required)
            uni_z (UNI): Endpoint Z for User Network Interface.(Required)
            start_date(datetime|str): Date when the EVC was registred.
                                      Default is now().
            end_date(datetime|str): Final date that the EVC will be fineshed.
                                    Default is None.
            bandwidth(int): Bandwidth used by EVC instance. Default is 0.
            primary_links(list): Primary links used by evc. Default is []
            backup_links(list): Backups links used by evc. Default is []
            current_path(list): Circuit being used at the moment if this is an
                                active circuit. Default is [].
            failover_path(list): Path being used to provide EVC protection via
                                failover during link failures. Default is [].
            primary_path(list): primary circuit offered to user IF one or more
                                links were provided. Default is [].
            backup_path(list): backup circuit offered to the user IF one or
                               more links were provided. Default is [].
            dynamic_backup_path(bool): Enable computer backup path dynamically.
                                       Dafault is False.
            creation_time(datetime|str): datetime when the circuit should be
                                         activated. default is now().
            enabled(Boolean): attribute to indicate the administrative state;
                              default is False.
            active(Boolean): attribute to indicate the operational state;
                             default is False.
            archived(Boolean): indicate the EVC has been deleted and is
                               archived; default is False.
            owner(str): The EVC owner. Default is None.
            sb_priority(int): Service level provided in the request.
                              Default is None.
            service_level(int): Service level provided. The higher the better.
                                Default is 0.

        Raises:
            ValueError: raised when object attributes are invalid.

        """
        self._validate(**kwargs)
        super().__init__()

        # required attributes
        self._id = kwargs.get("id", uuid4().hex)[:14]
        self.uni_a = kwargs.get("uni_a")
        self.uni_z = kwargs.get("uni_z")
        self.name = kwargs.get("name")

        # optional attributes
        self.start_date = get_time(kwargs.get("start_date")) or now()
        self.end_date = get_time(kwargs.get("end_date")) or None
        self.queue_id = kwargs.get("queue_id", None)

        self.bandwidth = kwargs.get("bandwidth", 0)
        self.primary_links = Path(kwargs.get("primary_links", []))
        self.backup_links = Path(kwargs.get("backup_links", []))
        self.current_path = Path(kwargs.get("current_path", []))
        self.failover_path = Path(kwargs.get("failover_path", []))
        self.primary_path = Path(kwargs.get("primary_path", []))
        self.backup_path = Path(kwargs.get("backup_path", []))
        self.dynamic_backup_path = kwargs.get("dynamic_backup_path", False)
        self.primary_constraints = kwargs.get("primary_constraints", {})
        self.secondary_constraints = kwargs.get("secondary_constraints", {})
        self.creation_time = get_time(kwargs.get("creation_time")) or now()
        self.owner = kwargs.get("owner", None)
        self.sb_priority = kwargs.get("sb_priority", None) or kwargs.get(
            "priority", None
        )
        self.service_level = kwargs.get("service_level", 0)
        self.circuit_scheduler = kwargs.get("circuit_scheduler", [])
        self.flow_removed_at = get_time(kwargs.get("flow_removed_at")) or None
        self.updated_at = get_time(kwargs.get("updated_at")) or now()
        self.execution_rounds = kwargs.get("execution_rounds", 0)

        self.current_links_cache = set()
        self.primary_links_cache = set()
        self.backup_links_cache = set()

        self.lock = Lock()

        self.archived = kwargs.get("archived", False)

        self.metadata = kwargs.get("metadata", {})

        self._controller = controller
        self._mongo_controller = controllers.ELineController()

        if kwargs.get("active", False):
            self.activate()
        else:
            self.deactivate()

        if kwargs.get("enabled", False):
            self.enable()
        else:
            self.disable()

        # datetime of user request for a EVC (or datetime when object was
        # created)
        self.request_time = kwargs.get("request_time", now())
        # dict with the user original request (input)
        self._requested = kwargs

    def sync(self):
        """Sync this EVC in the MongoDB."""
        self.updated_at = now()
        self._mongo_controller.upsert_evc(self.as_dict())

    def update(self, **kwargs):
        """Update evc attributes.

        This method will raises an error trying to change the following
        attributes: [name, uni_a and uni_z]

        Returns:
            the values for enable and a redeploy attribute, if exists and None
            otherwise
        Raises:
            ValueError: message with error detail.

        """
        enable, redeploy = (None, None)
        uni_a = kwargs.get("uni_a") or self.uni_a
        uni_z = kwargs.get("uni_z") or self.uni_z
        self._validate_has_primary_or_dynamic(
            primary_path=kwargs.get("primary_path"),
            dynamic_backup_path=kwargs.get("dynamic_backup_path"),
            uni_a=uni_a,
            uni_z=uni_z,
        )
        for attribute, value in kwargs.items():
            if attribute in self.read_only_attributes:
                raise ValueError(f"{attribute} can't be updated.")
            if not hasattr(self, attribute):
                raise ValueError(f'The attribute "{attribute}" is invalid.')
            if attribute in ("primary_path", "backup_path"):
                try:
                    value.is_valid(
                        uni_a.interface.switch, uni_z.interface.switch
                    )
                except InvalidPath as exception:
                    raise ValueError(  # pylint: disable=raise-missing-from
                        f"{attribute} is not a " f"valid path: {exception}"
                    )
        for attribute, value in kwargs.items():
            if attribute in ("enable", "enabled"):
                if value:
                    self.enable()
                else:
                    self.disable()
                enable = value
            else:
                setattr(self, attribute, value)
                if attribute in self.attributes_requiring_redeploy:
                    redeploy = value
        self.sync()
        return enable, redeploy

    def set_flow_removed_at(self):
        """Update flow_removed_at attribute."""
        self.flow_removed_at = now()

    def has_recent_removed_flow(self, setting=settings):
        """Check if any flow has been removed from the evc"""
        if self.flow_removed_at is None:
            return False
        res_seconds = (now() - self.flow_removed_at).seconds
        return res_seconds < setting.TIME_RECENT_DELETED_FLOWS

    def is_recent_updated(self, setting=settings):
        """Check if the evc has been updated recently"""
        res_seconds = (now() - self.updated_at).seconds
        return res_seconds < setting.TIME_RECENT_UPDATED

    def __repr__(self):
        """Repr method."""
        return f"EVC({self._id}, {self.name})"

    def _validate(self, **kwargs):
        """Do Basic validations.

        Verify required attributes: name, uni_a, uni_z
        Verify if the attributes uni_a and uni_z are valid.

        Raises:
            ValueError: message with error detail.

        """
        for attribute in self.required_attributes:

            if attribute not in kwargs:
                raise ValueError(f"{attribute} is required.")

            if "uni" in attribute:
                uni = kwargs.get(attribute)
                if not isinstance(uni, UNI):
                    raise ValueError(f"{attribute} is an invalid UNI.")

                if not uni.is_valid():
                    tag = uni.user_tag.value
                    message = f"VLAN tag {tag} is not available in {attribute}"
                    raise ValueError(message)

    def _validate_has_primary_or_dynamic(
        self,
        primary_path=None,
        dynamic_backup_path=None,
        uni_a=None,
        uni_z=None,
    ) -> None:
        """Validate that it must have a primary path or allow dynamic paths."""
        primary_path = (
            primary_path
            if primary_path is not None
            else self.primary_path
        )
        dynamic_backup_path = (
            dynamic_backup_path
            if dynamic_backup_path is not None
            else self.dynamic_backup_path
        )
        uni_a = uni_a if uni_a is not None else self.uni_a
        uni_z = uni_z if uni_z is not None else self.uni_z
        if (
            not primary_path
            and not dynamic_backup_path
            and uni_a and uni_z
            and uni_a.interface.switch != uni_z.interface.switch
        ):
            msg = "The EVC must have a primary path or allow dynamic paths."
            raise ValueError(msg)

    def __eq__(self, other):
        """Override the default implementation."""
        if not isinstance(other, EVC):
            return False

        attrs_to_compare = ["name", "uni_a", "uni_z", "owner", "bandwidth"]
        for attribute in attrs_to_compare:
            if getattr(other, attribute) != getattr(self, attribute):
                return False
        return True

    def shares_uni(self, other):
        """Check if two EVCs share an UNI."""
        if other.uni_a in (self.uni_a, self.uni_z) or other.uni_z in (
            self.uni_a,
            self.uni_z,
        ):
            return True
        return False

    def as_dict(self):
        """Return a dictionary representing an EVC object."""
        evc_dict = {
            "id": self.id,
            "name": self.name,
            "uni_a": self.uni_a.as_dict(),
            "uni_z": self.uni_z.as_dict(),
        }

        time_fmt = "%Y-%m-%dT%H:%M:%S"

        evc_dict["start_date"] = self.start_date
        if isinstance(self.start_date, datetime):
            evc_dict["start_date"] = self.start_date.strftime(time_fmt)

        evc_dict["end_date"] = self.end_date
        if isinstance(self.end_date, datetime):
            evc_dict["end_date"] = self.end_date.strftime(time_fmt)

        evc_dict["queue_id"] = self.queue_id
        evc_dict["bandwidth"] = self.bandwidth
        evc_dict["primary_links"] = self.primary_links.as_dict()
        evc_dict["backup_links"] = self.backup_links.as_dict()
        evc_dict["current_path"] = self.current_path.as_dict()
        evc_dict["failover_path"] = self.failover_path.as_dict()
        evc_dict["primary_path"] = self.primary_path.as_dict()
        evc_dict["backup_path"] = self.backup_path.as_dict()
        evc_dict["dynamic_backup_path"] = self.dynamic_backup_path
        evc_dict["metadata"] = self.metadata

        evc_dict["request_time"] = self.request_time
        if isinstance(self.request_time, datetime):
            evc_dict["request_time"] = self.request_time.strftime(time_fmt)

        time = self.creation_time.strftime(time_fmt)
        evc_dict["creation_time"] = time

        evc_dict["owner"] = self.owner
        evc_dict["circuit_scheduler"] = [
            sc.as_dict() for sc in self.circuit_scheduler
        ]

        evc_dict["active"] = self.is_active()
        evc_dict["enabled"] = self.is_enabled()
        evc_dict["archived"] = self.archived
        evc_dict["sb_priority"] = self.sb_priority
        evc_dict["service_level"] = self.service_level
        evc_dict["primary_constraints"] = self.primary_constraints
        evc_dict["secondary_constraints"] = self.secondary_constraints
        evc_dict["flow_removed_at"] = self.flow_removed_at
        evc_dict["updated_at"] = self.updated_at

        return evc_dict

    @property
    def id(self):  # pylint: disable=invalid-name
        """Return this EVC's ID."""
        return self._id

    def archive(self):
        """Archive this EVC on deletion."""
        self.archived = True


# pylint: disable=fixme, too-many-public-methods
class EVCDeploy(EVCBase):
    """Class to handle the deploy procedures."""

    def create(self):
        """Create a EVC."""

    def discover_new_paths(self):
        """Discover new paths to satisfy this circuit and deploy it."""
        return DynamicPathManager.get_best_paths(self,
                                                 **self.primary_constraints)

    def get_failover_path_candidates(self):
        """Get failover paths to satisfy this EVC."""
        # in the future we can return primary/backup paths as well
        # we just have to properly handle link_up and failover paths
        # if (
        #     self.is_using_primary_path() and
        #     self.backup_path.status is EntityStatus.UP
        # ):
        #     yield self.backup_path
        return DynamicPathManager.get_disjoint_paths(self, self.current_path)

    def change_path(self):
        """Change EVC path."""

    def reprovision(self):
        """Force the EVC (re-)provisioning."""

    def is_affected_by_link(self, link):
        """Return True if this EVC has the given link on its current path."""
        return link in self.current_path

    def link_affected_by_interface(self, interface):
        """Return True if this EVC has the given link on its current path."""
        return self.current_path.link_affected_by_interface(interface)

    def is_backup_path_affected_by_link(self, link):
        """Return True if the backup path of this EVC uses the given link."""
        return link in self.backup_path

    # pylint: disable=invalid-name
    def is_primary_path_affected_by_link(self, link):
        """Return True if the primary path of this EVC uses the given link."""
        return link in self.primary_path

    def is_failover_path_affected_by_link(self, link):
        """Return True if this EVC has the given link on its failover path."""
        return link in self.failover_path

    def is_eligible_for_failover_path(self):
        """Verify if this EVC is eligible for failover path (EP029)"""
        # In the future this function can be augmented to consider
        # primary/backup, primary/dynamic, and other path combinations
        return (
            self.dynamic_backup_path and
            not self.primary_path and not self.backup_path
        )

    def is_using_primary_path(self):
        """Verify if the current deployed path is self.primary_path."""
        return self.primary_path and (self.current_path == self.primary_path)

    def is_using_backup_path(self):
        """Verify if the current deployed path is self.backup_path."""
        return self.backup_path and (self.current_path == self.backup_path)

    def is_using_dynamic_path(self):
        """Verify if the current deployed path is a dynamic path."""
        if (
            self.current_path
            and not self.is_using_primary_path()
            and not self.is_using_backup_path()
            and self.current_path.status == EntityStatus.UP
        ):
            return True
        return False

    def deploy_to_backup_path(self):
        """Deploy the backup path into the datapaths of this circuit.

        If the backup_path attribute is valid and up, this method will try to
        deploy this backup_path.

        If everything fails and dynamic_backup_path is True, then tries to
        deploy a dynamic path.
        """
        # TODO: Remove flows from current (cookies)
        if self.is_using_backup_path():
            # TODO: Log to say that cannot move backup to backup
            return True

        success = False
        if self.backup_path.status is EntityStatus.UP:
            success = self.deploy_to_path(self.backup_path)

        if success:
            return True

        if (
            self.dynamic_backup_path
            or self.uni_a.interface.switch == self.uni_z.interface.switch
        ):
            return self.deploy_to_path()

        return False

    def deploy_to_primary_path(self):
        """Deploy the primary path into the datapaths of this circuit.

        If the primary_path attribute is valid and up, this method will try to
        deploy this primary_path.
        """
        # TODO: Remove flows from current (cookies)
        if self.is_using_primary_path():
            # TODO: Log to say that cannot move primary to primary
            return True

        if self.primary_path.status is EntityStatus.UP:
            return self.deploy_to_path(self.primary_path)
        return False

    def deploy(self):
        """Deploy EVC to best path.

        Best path can be the primary path, if available. If not, the backup
        path, and, if it is also not available, a dynamic path.
        """
        if self.archived:
            return False
        self.enable()
        success = self.deploy_to_primary_path()
        if not success:
            success = self.deploy_to_backup_path()

        if success:
            emit_event(self._controller, "deployed", evc_id=self.id)
        return success

    @staticmethod
    def get_path_status(path):
        """Check for the current status of a path.

        If any link in this path is down, the path is considered down.
        """
        if not path:
            return EntityStatus.DISABLED

        for link in path:
            if link.status is not EntityStatus.UP:
                return link.status
        return EntityStatus.UP

    #    def discover_new_path(self):
    #        # TODO: discover a new path to satisfy this circuit and deploy

    def remove(self):
        """Remove EVC path and disable it."""
        self.remove_current_flows()
        self.remove_failover_flows()
        self.disable()
        self.sync()
        emit_event(self._controller, "undeployed", evc_id=self.id)

    def remove_failover_flows(self, exclude_uni_switches=True,
                              force=True, sync=True) -> None:
        """Remove failover_flows.

        By default, it'll exclude UNI switches, if mef_eline has already
        called remove_current_flows before then this minimizes the number
        of FlowMods and IO.
        """
        if not self.failover_path:
            return
        switches, cookie, excluded = OrderedDict(), self.get_cookie(), set()
        links = set()
        if exclude_uni_switches:
            excluded.add(self.uni_a.interface.switch.id)
            excluded.add(self.uni_z.interface.switch.id)
        for link in self.failover_path:
            if link.endpoint_a.switch.id not in excluded:
                switches[link.endpoint_a.switch.id] = link.endpoint_a.switch
                links.add(link)
            if link.endpoint_b.switch.id not in excluded:
                switches[link.endpoint_b.switch.id] = link.endpoint_b.switch
                links.add(link)
        for switch in switches.values():
            try:
                self._send_flow_mods(
                    switch.id,
                    [
                        {
                            "cookie": cookie,
                            "cookie_mask": int(0xffffffffffffffff),
                        }
                    ],
                    "delete",
                    force=force,
                )
            except FlowModException as err:
                log.error(
                    f"Error removing flows from switch {switch.id} for"
                    f"EVC {self}: {err}"
                )
        for link in links:
            link.make_tag_available(link.get_metadata("s_vlan"))
            link.remove_metadata("s_vlan")
            notify_link_available_tags(self._controller, link)
        self.failover_path = Path([])
        if sync:
            self.sync()

    def remove_current_flows(self, current_path=None, force=True):
        """Remove all flows from current path."""
        switches = set()

        switches.add(self.uni_a.interface.switch)
        switches.add(self.uni_z.interface.switch)
        if not current_path:
            current_path = self.current_path
        for link in current_path:
            switches.add(link.endpoint_a.switch)
            switches.add(link.endpoint_b.switch)

        match = {
            "cookie": self.get_cookie(),
            "cookie_mask": int(0xffffffffffffffff)
        }

        for switch in switches:
            try:
                self._send_flow_mods(switch.id, [match], 'delete', force=force)
            except FlowModException as err:
                log.error(
                    f"Error removing flows from switch {switch.id} for"
                    f"EVC {self}: {err}"
                )

        current_path.make_vlans_available()
        for link in current_path:
            notify_link_available_tags(self._controller, link)
        self.current_path = Path([])
        self.deactivate()
        self.sync()

    def remove_path_flows(self, path=None, force=True):
        """Remove all flows from path."""
        if not path:
            return

        dpid_flows_match = {}
        for dpid, flows in self._prepare_nni_flows(path).items():
            dpid_flows_match.setdefault(dpid, [])
            for flow in flows:
                dpid_flows_match[dpid].append({
                    "cookie": flow["cookie"],
                    "match": flow["match"],
                    "cookie_mask": int(0xffffffffffffffff)
                })
        for dpid, flows in self._prepare_uni_flows(path, skip_in=True).items():
            dpid_flows_match.setdefault(dpid, [])
            for flow in flows:
                dpid_flows_match[dpid].append({
                    "cookie": flow["cookie"],
                    "match": flow["match"],
                    "cookie_mask": int(0xffffffffffffffff)
                })

        for dpid, flows in dpid_flows_match.items():
            try:
                self._send_flow_mods(dpid, flows, 'delete', force=force)
            except FlowModException as err:
                log.error(
                    "Error removing failover flows: "
                    f"dpid={dpid} evc={self} error={err}"
                )

        path.make_vlans_available()
        for link in path:
            notify_link_available_tags(self._controller, link)

    @staticmethod
    def links_zipped(path=None):
        """Return an iterator which yields pairs of links in order."""
        if not path:
            return []
        return zip(path[:-1], path[1:])

    def should_deploy(self, path=None):
        """Verify if the circuit should be deployed."""
        if not path:
            log.debug("Path is empty.")
            return False

        if not self.is_enabled():
            log.debug(f"{self} is disabled.")
            return False

        if not self.is_active():
            log.debug(f"{self} will be deployed.")
            return True

        return False

    def deploy_to_path(self, path=None):  # pylint: disable=too-many-branches
        """Install the flows for this circuit.

        Procedures to deploy:

        0. Remove current flows installed
        1. Decide if will deploy "path" or discover a new path
        2. Choose vlan
        3. Install NNI flows
        4. Install UNI flows
        5. Activate
        6. Update current_path
        7. Update links caches(primary, current, backup)

        """
        self.remove_current_flows()
        use_path = path
        if self.should_deploy(use_path):
            try:
                use_path.choose_vlans()
                for link in use_path:
                    notify_link_available_tags(self._controller, link)
            except KytosNoTagAvailableError:
                use_path = None
        else:
            for use_path in self.discover_new_paths():
                if use_path is None:
                    continue
                try:
                    use_path.choose_vlans()
                    for link in use_path:
                        notify_link_available_tags(self._controller, link)
                    break
                except KytosNoTagAvailableError:
                    pass
            else:
                use_path = None

        try:
            if use_path:
                self._install_nni_flows(use_path)
                self._install_uni_flows(use_path)
            elif self.uni_a.interface.switch == self.uni_z.interface.switch:
                use_path = Path()
                self._install_direct_uni_flows()
            else:
                log.warning(
                    f"{self} was not deployed. " "No available path was found."
                )
                return False
        except FlowModException as err:
            log.error(
                f"Error deploying EVC {self} when calling flow_manager: {err}"
            )
            self.remove_current_flows(use_path)
            return False
        self.activate()
        self.current_path = use_path
        self.sync()
        log.info(f"{self} was deployed.")
        return True

    def setup_failover_path(self):
        """Install flows for the failover path of this EVC.

        Procedures to deploy:

        0. Remove flows currently installed for failover_path (if any)
        1. Discover a disjoint path from current_path
        2. Choose vlans
        3. Install NNI flows
        4. Install UNI egress flows
        5. Update failover_path
        """
        # Intra-switch EVCs have no failover_path
        if self.uni_a.interface.switch == self.uni_z.interface.switch:
            return False

        # For not only setup failover path for totally dynamic EVCs
        if not self.is_eligible_for_failover_path():
            return False

        reason = ""
        self.remove_path_flows(self.failover_path)
        for use_path in self.get_failover_path_candidates():
            if not use_path:
                continue
            try:
                use_path.choose_vlans()
                for link in use_path:
                    notify_link_available_tags(self._controller, link)
                break
            except KytosNoTagAvailableError:
                pass
        else:
            use_path = Path([])
            reason = "No available path was found"

        try:
            if use_path:
                self._install_nni_flows(use_path)
                self._install_uni_flows(use_path, skip_in=True)
        except FlowModException as err:
            reason = "Error deploying failover path"
            log.error(
                f"{reason} for {self}. FlowManager error: {err}"
            )
            self.remove_path_flows(use_path)
            use_path = Path([])

        self.failover_path = use_path
        self.sync()

        if not use_path:
            log.warning(
                f"Failover path for {self} was not deployed: {reason}"
            )
            return False
        log.info(f"Failover path for {self} was deployed.")
        return True

    def get_failover_flows(self):
        """Return the flows needed to make the failover path active, i.e. the
        flows for ingress forwarding.

        Return:
            dict: A dict of flows indexed by the switch_id will be returned, or
                an empty dict if no failover_path is available.
        """
        if not self.failover_path:
            return {}
        return self._prepare_uni_flows(self.failover_path, skip_out=True)

    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

        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
        )
        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
        )

        if vlan_a and vlan_z:
            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:
            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:
            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}
            )
        return (
            self.uni_a.interface.switch.id, [flow_mod_az, flow_mod_za]
        )

    def _install_direct_uni_flows(self):
        """Install flows connecting two UNIs.

        This case happens when the circuit is between UNIs in the
        same switch.
        """
        (dpid, flows) = self._prepare_direct_uni_flows()
        self._send_flow_mods(dpid, flows)

    def _prepare_nni_flows(self, path=None):
        """Prepare NNI flows."""
        nni_flows = OrderedDict()
        for incoming, outcoming in self.links_zipped(path):
            in_vlan = incoming.get_metadata("s_vlan").value
            out_vlan = outcoming.get_metadata("s_vlan").value

            flows = []
            # Flow for one direction
            flows.append(
                self._prepare_nni_flow(
                    incoming.endpoint_b,
                    outcoming.endpoint_a,
                    in_vlan,
                    out_vlan,
                    queue_id=self.queue_id,
                )
            )

            # Flow for the other direction
            flows.append(
                self._prepare_nni_flow(
                    outcoming.endpoint_a,
                    incoming.endpoint_b,
                    out_vlan,
                    in_vlan,
                    queue_id=self.queue_id,
                )
            )
            nni_flows[incoming.endpoint_b.switch.id] = flows
        return nni_flows

    def _install_nni_flows(self, path=None):
        """Install NNI flows."""
        for dpid, flows in self._prepare_nni_flows(path).items():
            self._send_flow_mods(dpid, flows)

    def _prepare_uni_flows(self, path=None, skip_in=False, skip_out=False):
        """Prepare flows to install UNIs."""
        uni_flows = {}
        if not path:
            log.info("install uni flows without path.")
            return uni_flows

        # Determine VLANs
        in_vlan_a = self.uni_a.user_tag.value if self.uni_a.user_tag else None
        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
        out_vlan_z = path[-1].get_metadata("s_vlan").value

        # Flows for the first UNI
        flows_a = []

        # Flow for one direction, pushing the service tag
        if not skip_in:
            push_flow = self._prepare_push_flow(
                self.uni_a.interface,
                path[0].endpoint_a,
                in_vlan_a,
                out_vlan_a,
                in_vlan_z,
                queue_id=self.queue_id,
            )
            flows_a.append(push_flow)

        # Flow for the other direction, popping the service tag
        if not skip_out:
            pop_flow = self._prepare_pop_flow(
                path[0].endpoint_a,
                self.uni_a.interface,
                out_vlan_a,
                queue_id=self.queue_id,
            )
            flows_a.append(pop_flow)

        uni_flows[self.uni_a.interface.switch.id] = flows_a

        # Flows for the second UNI
        flows_z = []

        # Flow for one direction, pushing the service tag
        if not skip_in:
            push_flow = self._prepare_push_flow(
                self.uni_z.interface,
                path[-1].endpoint_b,
                in_vlan_z,
                out_vlan_z,
                in_vlan_a,
                queue_id=self.queue_id,
            )
            flows_z.append(push_flow)

        # Flow for the other direction, popping the service tag
        if not skip_out:
            pop_flow = self._prepare_pop_flow(
                path[-1].endpoint_b,
                self.uni_z.interface,
                out_vlan_z,
                queue_id=self.queue_id,
            )
            flows_z.append(pop_flow)

        uni_flows[self.uni_z.interface.switch.id] = flows_z

        return uni_flows

    def _install_uni_flows(self, path=None, skip_in=False, skip_out=False):
        """Install UNI flows."""
        uni_flows = self._prepare_uni_flows(path, skip_in, skip_out)

        for (dpid, flows) in uni_flows.items():
            self._send_flow_mods(dpid, flows)

    @staticmethod
    def _send_flow_mods(dpid, flow_mods, command='flows', force=False):
        """Send a flow_mod list to a specific switch.

        Args:
            dpid(str): The target of flows (i.e. Switch.id).
            flow_mods(dict): Python dictionary with flow_mods.
            command(str): By default is 'flows'. To remove a flow is 'remove'.
            force(bool): True to send via consistency check in case of errors

        """

        endpoint = f"{settings.MANAGER_URL}/{command}/{dpid}"

        data = {"flows": flow_mods, "force": force}
        response = requests.post(endpoint, json=data)
        if response.status_code >= 400:
            raise FlowModException(str(response.text))

    def get_cookie(self):
        """Return the cookie integer from evc id."""
        return int(self.id, 16) + (settings.COOKIE_PREFIX << 56)

    @staticmethod
    def get_id_from_cookie(cookie):
        """Return the evc id given a cookie value."""
        evc_id = cookie - (settings.COOKIE_PREFIX << 56)
        return f"{evc_id:x}".zfill(14)

    def _prepare_flow_mod(self, in_interface, out_interface,
                          queue_id=None, is_EVPL=True):
        """Prepare a common flow mod."""
        default_actions = [
            {"action_type": "output", "port": out_interface.port_number}
        ]
        if queue_id is not None:
            default_actions.append(
                {"action_type": "set_queue", "queue_id": queue_id}
            )

        flow_mod = {
            "match": {"in_port": in_interface.port_number},
            "cookie": self.get_cookie(),
            "actions": default_actions,
        }
        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
        return flow_mod

    def _prepare_nni_flow(self, *args, queue_id=None):
        """Create NNI flows."""
        in_interface, out_interface, in_vlan, out_vlan = args
        flow_mod = self._prepare_flow_mod(
            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.

        Arguments:
            in_interface(str): Interface input.
            out_interface(str): Interface output.
            in_vlan(str): Vlan input.
            out_vlan(str): Vlan output.
            new_c_vlan(str): New client vlan.

        Return:
            dict: An python dictionary representing a FlowMod

        """
        # 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
        )

        # 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 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
            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
            new_action = {"action_type": "pop_vlan"}
            flow_mod["actions"].insert(0, new_action)
        return flow_mod

    def _prepare_pop_flow(
        self, in_interface, out_interface, out_vlan, queue_id=None
    ):
        # pylint: disable=too-many-arguments
        """Prepare pop flow."""
        flow_mod = self._prepare_flow_mod(
            in_interface, out_interface, queue_id
        )
        flow_mod["match"]["dl_vlan"] = out_vlan
        new_action = {"action_type": "pop_vlan"}
        flow_mod["actions"].insert(0, new_action)
        return flow_mod

    @staticmethod
    def run_sdntrace(uni):
        """Run SDN trace on control plane starting from EVC UNIs."""
        endpoint = f"{settings.SDN_TRACE_CP_URL}/trace"
        data_uni = {
            "trace": {
                "switch": {
                    "dpid": uni.interface.switch.dpid,
                    "in_port": uni.interface.port_number,
                }
            }
        }
        if uni.user_tag:
            data_uni["trace"]["eth"] = {
                "dl_type": 0x8100,
                "dl_vlan": uni.user_tag.value,
            }
        response = requests.put(endpoint, json=data_uni)
        if response.status_code >= 400:
            log.error(f"Failed to run sdntrace-cp: {response.text}")
            return []
        return response.json().get('result', [])

    @staticmethod
    def run_bulk_sdntraces(uni_list):
        """Run SDN traces on control plane starting from EVC UNIs."""
        endpoint = f"{settings.SDN_TRACE_CP_URL}/traces"
        data = []
        for uni in uni_list:
            data_uni = {
                "trace": {
                            "switch": {
                                "dpid": uni.interface.switch.dpid,
                                "in_port": uni.interface.port_number,
                            }
                        }
                }
            if uni.user_tag:
                data_uni["trace"]["eth"] = {
                                            "dl_type": 0x8100,
                                            "dl_vlan": uni.user_tag.value,
                                            }
            data.append(data_uni)
        try:
            response = requests.put(endpoint, json=data, timeout=30)
        except ConnectTimeout as exception:
            log.error(f"Request has timed out: {exception}")

        if response.status_code >= 400:
            log.error(f"Failed to run sdntrace-cp: {response.text}")
            return []
        return response.json()

    @staticmethod
    def check_trace(
                    circuit_id,
                    circuit_current_path,
                    circuit_by_traces,
                    circuits_checked
                ):
        """Auxiliar function to check an individual trace"""
        if circuit_current_path:
            circuits_checked[circuit_id] = True
            trace_a = circuit_by_traces[circuit_id]['trace_a']
            trace_z = circuit_by_traces[circuit_id]['trace_z']
            if len(trace_a) != len(circuit_current_path) + 1:
                log.warning(f"Invalid trace from uni_a: {trace_a}")
                circuits_checked[circuit_id] = False
            if len(trace_z) != len(circuit_current_path) + 1:
                log.warning(f"Invalid trace from uni_z: {trace_z}")
                circuits_checked[circuit_id] = False
            for link, trace1, trace2 in zip(circuit_current_path,
                                            trace_a[1:],
                                            trace_z[:0:-1]):
                metadata_vlan = None
                if link.metadata:
                    metadata_vlan = glom(link.metadata, 's_vlan.value')
                if compare_endpoint_trace(
                                            link.endpoint_a,
                                            metadata_vlan,
                                            trace2
                                        ) is False:
                    log.warning(f"Invalid trace from uni_a: {trace_a}")
                    circuits_checked[circuit_id] = False
                if compare_endpoint_trace(
                                            link.endpoint_b,
                                            metadata_vlan,
                                            trace1
                                        ) is False:
                    log.warning(f"Invalid trace from uni_z: {trace_z}")
                    circuits_checked[circuit_id] = False

    @staticmethod
    # pylint: disable=too-many-locals
    def check_list_traces(list_circuits):
        """Check if current_path is deployed comparing with SDN traces."""
        if not list_circuits:
            return {}
        uni_list = []
        circuit_data = {}
        for circuit_id in list_circuits:
            circuit = list_circuits[circuit_id]
            uni_list.append(circuit.uni_a)
            uni_list.append(circuit.uni_z)
            dpid_a = circuit.uni_a.interface.switch.dpid
            port_a = circuit.uni_a.interface.port_number
            interface_a = str(dpid_a) + ':' + str(port_a)
            if circuit.uni_a.user_tag:
                vlan_a = circuit.uni_a.user_tag.value
                interface_a += ':' + str(vlan_a)
            circuit_data[interface_a] = {
                                            'circuit_id': circuit.id,
                                            'trace_name': 'trace_a'
                                        }
            dpid_z = circuit.uni_z.interface.switch.dpid
            port_z = circuit.uni_z.interface.port_number
            interface_z = str(dpid_z) + ':' + str(port_z)
            if circuit.uni_z.user_tag:
                vlan_z = circuit.uni_z.user_tag.value
                interface_z += ':' + str(vlan_z)
            circuit_data[interface_z] = {
                                            'circuit_id': circuit.id,
                                            'trace_name': 'trace_z'
                                        }
        traces = EVCDeploy.run_bulk_sdntraces(uni_list)

        circuit_by_traces = {}
        circuits_checked = {}
        for trace_switch in traces:
            for trace in traces[trace_switch]:
                id_trace = str(trace[0]['dpid']) + ':' + str(trace[0]['port'])
                if 'vlan' in trace[0]:
                    id_trace += ':' + str(trace[0]['vlan'])
                circuit_from_data = circuit_data.get(id_trace)
                if circuit_from_data is None:
                    continue
                circuit_id = circuit_from_data['circuit_id']
                trace_name = circuit_from_data['trace_name']
                circuit = list_circuits[circuit_id]
                circuit_current_path = circuit.current_path.copy()
                if circuit_id not in circuit_by_traces:
                    circuit_by_traces[circuit_id] = {}
                circuit_by_traces[circuit_id][trace_name] = trace

                if 'trace_a' in circuit_by_traces[circuit_id] \
                        and 'trace_z' in circuit_by_traces[circuit_id]:
                    EVCDeploy.check_trace(
                                            circuit_id,
                                            circuit_current_path,
                                            circuit_by_traces,
                                            circuits_checked
                                        )
        return circuits_checked


class LinkProtection(EVCDeploy):
    """Class to handle link protection."""

    def is_affected_by_link(self, link=None):
        """Verify if the current path is affected by link down event."""
        return self.current_path.is_affected_by_link(link)

    def is_using_primary_path(self):
        """Verify if the current deployed path is self.primary_path."""
        return self.current_path == self.primary_path

    def is_using_backup_path(self):
        """Verify if the current deployed path is self.backup_path."""
        return self.current_path == self.backup_path

    def is_using_dynamic_path(self):
        """Verify if the current deployed path is dynamic."""
        if (
            self.current_path
            and not self.is_using_primary_path()
            and not self.is_using_backup_path()
            and self.current_path.status is EntityStatus.UP
        ):
            return True
        return False

    def deploy_to(self, path_name=None, path=None):
        """Create a deploy to path."""
        if self.current_path == path:
            log.debug(f"{path_name} is equal to current_path.")
            return True

        if path.status is EntityStatus.UP:
            return self.deploy_to_path(path)

        return False

    def handle_link_up(self, link):
        """Handle circuit when link down.

        Args:
            link(Link): Link affected by link.down event.

        """
        if self.is_using_primary_path():
            return True

        success = False
        if self.primary_path.is_affected_by_link(link):
            success = self.deploy_to_primary_path()

        if success:
            return True

        # We tried to deploy(primary_path) without success.
        # And in this case is up by some how. Nothing to do.
        if self.is_using_backup_path() or self.is_using_dynamic_path():
            return True

        # In this case, probably the circuit is not being used and
        # we can move to backup
        if self.backup_path.is_affected_by_link(link):
            success = self.deploy_to_backup_path()

        # In this case, the circuit is not being used and we should
        # try a dynamic path
        if not success and self.dynamic_backup_path:
            success = self.deploy_to_path()

        if success:
            emit_event(self._controller, "redeployed_link_up", evc_id=self.id)
            return True

        return True

    def handle_link_down(self):
        """Handle circuit when link down.

        Returns:
            bool: True if the re-deploy was successly otherwise False.

        """
        success = False
        if self.is_using_primary_path():
            success = self.deploy_to_backup_path()
        elif self.is_using_backup_path():
            success = self.deploy_to_primary_path()

        if not success and self.dynamic_backup_path:
            success = self.deploy_to_path()

        if success:
            log.debug(f"{self} deployed after link down.")
        else:
            self.deactivate()
            self.current_path = Path([])
            self.sync()
            log.debug(f"Failed to re-deploy {self} after link down.")

        return success


class EVC(LinkProtection):
    """Class that represents a E-Line Virtual Connection."""

kytos-ng / mef_eline

Pull Request — master (#241)

build.models.evc.EVCDeploy.is_using_backup_path() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
