tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/hli_v1/ports/port_l23/chimera/filter_definition/_utils.py

@@ -0,0 +1,15 @@
+from typing import NoReturn, TypeVar
+from xoa_driver.internals.commands.enums import FilterType
+
+T = TypeVar("T")
+
+
+def prevent_set(inst: T, filter_type: FilterType = FilterType.WORKING) -> T:
+    METHOD_NAME = "set"
+
+    def _set(*args, **kwargs) -> NoReturn:
+        raise Exception(f"Method {METHOD_NAME} is not allowed")
+
+    if filter_type is FilterType.WORKING and hasattr(inst, METHOD_NAME):
+        setattr(inst, METHOD_NAME, _set)
+    return inst

xoa_driver/internals/hli_v1/ports/port_l23/chimera/filter_definition/general.py

@@ -0,0 +1,396 @@
+from typing import (
+    Dict,
+    Tuple,
+    Type,
+    TypeVar,
+    TYPE_CHECKING
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands.enums import (
+    FilterType,
+    FilterVlanType,
+    ProtocolOption,
+    FilterMode,
+)
+from xoa_driver.internals.commands import (
+    PEF_ETHSETTINGS,
+    PEF_ETHSRCADDR,
+    PEF_ETHDESTADDR,
+    PEF_L2PUSE,
+    PEF_VLANSETTINGS,
+    PEF_VLANTAG,
+    PEF_VLANPCP,
+    PEF_MPLSSETTINGS,
+    PEF_MPLSLABEL,
+    PEF_MPLSTOC,
+    PEF_L3USE,
+    PEF_IPV4SETTINGS,
+    PEF_IPV4SRCADDR,
+    PEF_IPV4DESTADDR,
+    PEF_IPV4DSCP,
+    PEF_IPV6SETTINGS,
+    PEF_IPV6SRCADDR,
+    PEF_IPV6DESTADDR,
+    PEF_IPV6TC,
+    PEF_UDPSETTINGS,
+    PEF_UDPSRCPORT,
+    PEF_UDPDESTPORT,
+    PEF_TCPSETTINGS,
+    PEF_TCPSRCPORT,
+    PEF_TCPDESTPORT,
+    PEF_ANYSETTINGS,
+    PEF_ANYCONFIG,
+    PEF_TPLDSETTINGS,
+    PEF_TPLDCONFIG,
+    # PEF_ISSHADOWDIRTY, #TODO: need to implement
+    # PEF_CANCEL, #TODO: need to implement
+    PEF_VALUE,
+    PEF_MASK,
+    PEF_PROTOCOL,
+    PEF_MODE,
+)
+from ._utils import prevent_set
+
+
+class FEthernet:
+    """Filter for Ethernet field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_ETHSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on Ethernet field.
+
+        :type: PEF_ETHSETTINGS
+        """
+        self.src_address = prevent_set(PEF_ETHSRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Ethernet source address settings for the filter.
+
+        :type: PEF_ETHSRCADDR
+        """
+        self.dest_address = prevent_set(PEF_ETHDESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Ethernet destination address settings for the filter.
+
+        :type: PEF_ETHDESTADDR
+        """
+
+
+class FPerVlanType:
+    """Filter for VLAN tag."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, vlan_type: FilterVlanType) -> None:
+        self.tag = prevent_set(PEF_VLANTAG(conn, module_id, port_id, flow_index, filter_type, vlan_type), filter_type)
+        """VLAN tag setting for the filter.
+
+        :type: PEF_VLANTAG
+        """
+        self.pcp = prevent_set(PEF_VLANPCP(conn, module_id, port_id, flow_index, filter_type, vlan_type), filter_type)
+        """VLAN PCP setting for the filter.
+
+        :type: PEF_VLANPCP
+        """
+
+
+class FVlan:
+    """Filter for VLAN field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_VLANSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on VLAN field.
+
+        :type: PEF_VLANSETTINGS
+        """
+
+        self.inner = FPerVlanType(conn, module_id, port_id, flow_index, filter_type, FilterVlanType.INNER)
+        """Filter for inner VLAN tag."""
+
+        self.outer = FPerVlanType(conn, module_id, port_id, flow_index, filter_type, FilterVlanType.OUTER)
+        """Filter for outer VLAN tag."""
+
+
+class FUdp:
+    """Filer for UDP field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_UDPSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on UDP field.
+
+        :type: PEF_UDPSETTINGS
+        """
+        self.src_port = prevent_set(PEF_UDPSRCPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """UDP source port settings for the filter.
+
+        :type: PEF_UDPSRCPORT
+        """
+        self.dest_port = prevent_set(PEF_UDPDESTPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """UDP destination port settings for the filter.
+
+        :type: PEF_UDPDESTPORT
+        """
+
+
+class FTcp:
+    """Filter for TCP."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_TCPSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on TCP field.
+
+        :type: PEF_TCPSETTINGS
+        """
+        self.src_port = prevent_set(PEF_TCPSRCPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """TCP source port settings for the filter.
+
+        :type: PEF_TCPSRCPORT
+        """
+        self.dest_port = prevent_set(PEF_TCPDESTPORT(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """TCP destination port settings for the filter.
+
+        :type: PEF_TCPDESTPORT
+        """
+
+
+class FIPv4:
+    """Filter for IPv4 field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_IPV4SETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on IPv4 field.
+
+        :type: PEF_IPV4SETTINGS
+        """
+        self.src_address = prevent_set(PEF_IPV4SRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv4 source address settings for the filter.
+
+        :type: PEF_IPV4SRCADDR
+        """
+        self.dest_address = prevent_set(PEF_IPV4DESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv4 destination address settings for the filter.
+
+        :type: PEF_IPV4DESTADDR
+        """
+        self.dscp = prevent_set(PEF_IPV4DSCP(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv4 DSCP/TOS settings for the filter.
+
+        :type: PEF_IPV4DSCP
+        """
+
+
+class FIPv6:
+    """Filter for IPv6 field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_IPV6SETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on IPv6 field.
+
+        :type: PEF_IPV6SETTINGS
+        """
+        self.src_address = prevent_set(PEF_IPV6SRCADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv6 source address settings for the filter.
+
+        :type: PEF_IPV6SRCADDR
+        """
+        self.dest_address = prevent_set(PEF_IPV6DESTADDR(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv6 destination address settings for the filter.
+
+        :type: PEF_IPV6DESTADDR
+        """
+        self.traffic_class = prevent_set(PEF_IPV6TC(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """IPv6 traffic class settings for the filter.
+
+        :type: PEF_IPV6TC
+        """
+
+
+class FIp:
+    """Filter for IP field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.v4 = FIPv4(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for IPv4 field."""
+
+        self.v6 = FIPv6(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for IPv6 field."""
+
+
+class FMpls:
+    """Filter for MPLS field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_MPLSSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on MPLS field.
+
+        :type: PEF_MPLSSETTINGS
+        """
+        self.label = prevent_set(PEF_MPLSLABEL(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """MPLS label settings for the filter.
+
+        :type: PEF_MPLSLABEL
+        """
+        self.toc = prevent_set(PEF_MPLSTOC(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """"MPLS TOC settings for the filter.
+
+        :type: PEF_MPLSTOC
+        """
+
+
+class FTpld:
+    """Filter for Xena TPLD field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_TPLDSETTINGS(conn, module_id, port_id, flow_index, filter_type))
+        """Filter action on Xena TPLD field.
+
+        :type: PEF_TPLDSETTINGS
+        """
+
+        self.test_payload_filters_config = tuple(
+            prevent_set(PEF_TPLDCONFIG(conn, module_id, port_id, flow_index, filter_type, test_payload_filter_index), filter_type)
+            for test_payload_filter_index in range(16)  # range need to put to the constants place
+        )
+        """TPLD filter configurations.
+
+        :type: PEF_TPLDCONFIG
+        """
+
+
+class FAny:
+    """Filter for any field."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.settings = prevent_set(PEF_ANYSETTINGS(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Filter action on any field.
+
+        :type: PEF_ANYSETTINGS
+        """
+        self.config = prevent_set(PEF_ANYCONFIG(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """Any field's filter configurations.
+
+        :type: PEF_ANYCONFIG
+        """
+
+
+class ModeBasic:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self.l2plus_use = prevent_set(PEF_L2PUSE(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """L2 protocol to use.
+
+        :type: PEF_L2PUSE
+        """
+        self.l3_use = prevent_set(PEF_L3USE(conn, module_id, port_id, flow_index, filter_type), filter_type)
+        """L3 protocol to use.
+
+        :type: PEF_L3USE
+        """
+        self.any = FAny(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for any field.
+
+        :type: FAny
+        """
+
+        self.tpld = FTpld(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for Xena TPLD field.
+
+        :type: FTpld
+        """
+
+        self.mpls = FMpls(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for MPLS field.
+
+        :type: FMpls
+        """
+
+        self.ip = FIp(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for IP field.
+
+        :type: FIp
+        """
+
+        self.tcp = FTcp(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for TCP field.
+
+        :type: FTcp
+        """
+
+        self.udp = FUdp(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for UDP field.
+
+        :type: FUdp
+        """
+
+        self.vlan = FVlan(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for VLAN field.
+
+        :type: FVlan
+        """
+
+        self.ethernet = FEthernet(conn, module_id, port_id, flow_index, filter_type)
+        """Filter for Ethernet field.
+
+        :type: FEthernet
+        """
+
+
+class ProtocolSegment:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, protocol_segment_index: int, segment_type: ProtocolOption) -> None:  # noqa: E501
+        self.segment_type = segment_type
+
+        self.value = prevent_set(PEF_VALUE(conn, module_id, port_id, flow_index, filter_type, protocol_segment_index), filter_type)
+        """Value bytes match for the filter.
+
+        :type: PEF_VALUE
+        """
+        self.mask = prevent_set(PEF_MASK(conn, module_id, port_id, flow_index, filter_type, protocol_segment_index), filter_type)
+        """Mask byte value.
+
+        :type: PEF_MASK
+        """
+
+
+class ModeExtended:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType) -> None:
+        self._conn = conn
+        self._module_id = module_id
+        self._port_id = port_id
+        self._flow_index = flow_index
+        self._filter_type = filter_type
+
+        # self.protocol = prevent_set(PEF_PROTOCOL(conn, module_id, port_id, flow_index, filter_type))
+        # """Protocol segments match for the filter.
+        #
+        # :type: PEF_PROTOCOL
+        # """
+
+    async def get_protocol_segments(self) -> Tuple[ProtocolSegment, ...]:
+        segments_raw = (
+            await PEF_PROTOCOL(
+                self._conn,
+                self._module_id,
+                self._port_id,
+                self._flow_index,
+                self._filter_type
+            ).get()
+        ).segment_list
+        return tuple(
+            ProtocolSegment(
+                self._conn,
+                self._module_id,
+                self._port_id,
+                self._flow_index,
+                self._filter_type,
+                idx + 1,  # TODO: need to discuss with Leo
+                ProtocolOption(segment_type)
+            )
+            for idx, segment_type in enumerate(segments_raw)
+        )
+
+
+T = TypeVar("T")
+
+
+async def get_mode(conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int, filter_type: FilterType, mode_types: Dict[FilterMode, Type[T]]) -> T:
+    mode_raw = (
+        await PEF_MODE(
+            conn,
+            module_id,
+            port_id,
+            flow_index,
+            filter_type,
+        ).get()
+    ).mode
+    mode_type = mode_types[FilterMode(mode_raw)]
+    return mode_type(
+        conn,
+        module_id,
+        port_id,
+        flow_index,
+        filter_type,
+    )

xoa_driver/internals/hli_v1/ports/port_l23/chimera/filter_definition/shadow.py

@@ -0,0 +1,104 @@
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Type,
+    Union
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands.enums import (
+    FilterType,
+    ProtocolOption,
+    FilterMode,
+)
+from xoa_driver.internals.commands import (
+    PEF_INIT,
+    PEF_APPLY,
+    PEF_ENABLE,
+    PEF_PROTOCOL,
+    PEF_MODE,
+    PEF_CANCEL,
+)
+from . import general
+
+
+class ModeExtendedS(general.ModeExtended):
+    async def use_segments(self, *segments: ProtocolOption) -> None:
+        segments_payload = [
+            ProtocolOption.ETHERNET,
+            *segments
+        ]
+        await PEF_PROTOCOL(
+            self._conn,
+            self._module_id,
+            self._port_id,
+            self._flow_index,
+            self._filter_type
+        ).set(segments_payload)
+
+
+class FilterDefinitionShadow:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self._conn = conn
+        self._module_id = module_id
+        self._port_id = port_id
+        self._flow_index = flow_index
+        self._filter_type = FilterType.SHADOW
+
+        self.initiating = PEF_INIT(conn, module_id, port_id, flow_index)
+        """Preparing filter definition.
+
+        :type: PEF_INIT
+        """
+        self.apply = PEF_APPLY(conn, module_id, port_id, flow_index)
+        """Apply filter definition.
+
+        :type: PEF_APPLY
+        """
+        self.enable = PEF_ENABLE(conn, module_id, port_id, flow_index, self._filter_type)
+        """Enabling the filter.
+
+        :type: PEF_ENABLE
+        """
+        self.cancel = PEF_CANCEL(conn, module_id, port_id, flow_index)
+        """Cancel changes made to Shadow and restores them to the ones in Working.
+
+        :type: PEF_CANCEL
+        """
+        # self.mode = PEF_MODE(conn, module_id, port_id, flow_index, self._filter_type)
+        # """Filter mode.
+        #
+        # :type: PEF_MODE`
+        # """
+
+    async def get_mode(self) -> Union[general.ModeBasic, ModeExtendedS]:
+        mode_types: Dict[FilterMode, Type[Union[general.ModeBasic, ModeExtendedS]]] = {
+            FilterMode.BASIC: general.ModeBasic,
+            FilterMode.EXTENDED: ModeExtendedS,
+        }
+        return await general.get_mode(
+            self._conn,
+            self._module_id,
+            self._port_id,
+            self._flow_index,
+            self._filter_type,
+            mode_types
+        )
+
+    async def use_basic_mode(self) -> None:
+        await PEF_MODE(
+            self._conn,
+            self._module_id,
+            self._port_id,
+            self._flow_index,
+            self._filter_type,
+        ).set_basic()
+
+    async def use_extended_mode(self) -> None:
+        await PEF_MODE(
+            self._conn,
+            self._module_id,
+            self._port_id,
+            self._flow_index,
+            self._filter_type,
+        ).set_extended()

xoa_driver/internals/hli_v1/ports/port_l23/chimera/filter_definition/working.py

@@ -0,0 +1,36 @@
+from typing import (
+    Dict,
+    Type,
+    Union,
+    TYPE_CHECKING
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands.enums import (
+    FilterType,
+    FilterMode,
+)
+from . import general
+
+
+class FilterDefinitionWorking:
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, flow_index: int) -> None:
+        self._conn = conn
+        self._module_id = module_id
+        self._port_id = port_id
+        self._flow_index = flow_index
+        self._filter_type = FilterType.WORKING
+
+    async def get_mode(self) -> Union[general.ModeBasic, general.ModeExtended]:
+        mode_types: Dict[FilterMode, Type[Union[general.ModeBasic, general.ModeExtended]]] = {
+            FilterMode.BASIC: general.ModeBasic,
+            FilterMode.EXTENDED: general.ModeExtended,
+        }
+        return await general.get_mode(
+            self._conn,
+            self._module_id,
+            self._port_id,
+            self._flow_index,
+            self._filter_type,
+            mode_types
+        )

xoa_driver/internals/hli_v1/ports/port_l23/chimera/pe_custom_distribution.py

@@ -0,0 +1,125 @@
+from typing import (
+    TYPE_CHECKING,
+    List,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    PEC_INDICES,
+    PEC_VAL,
+    PEC_COMMENT,
+    PEC_DELETE,
+    PEC_DISTTYPE,
+)
+
+from xoa_driver.internals.utils.indices import observer
+
+
+class CustomDistribution:
+    """Custom distribution"""
+
+    def __init__(self, observer: "observer.IndicesObserver", conn: "itf.IConnection", module_id: int, port_id: int, custom_distribution_index: int) -> None:
+        self.__observer = observer
+        self.__conn = conn
+        self.__module_id = module_id
+        self.__port_id = port_id
+        self.__cdi = custom_distribution_index
+        self.definition = PEC_VAL(conn, module_id, port_id, custom_distribution_index)
+        """Custom distribution definition.
+
+        :type: PEC_VAL
+        """
+
+        self.comment = PEC_COMMENT(conn, module_id, port_id, custom_distribution_index)
+        """Custom distribution description.
+
+        :type: PEC_COMMENT
+        """
+
+        self.type = PEC_DISTTYPE(conn, module_id, port_id, custom_distribution_index)
+        """Custom distribution type.
+
+        :type: PEC_DISTTYPE
+        """
+
+    async def delete(self) -> None:
+        """
+        Deleting an existing Custom Distribution
+        """
+
+        await PEC_DELETE(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            self.__cdi
+        ).set()
+        self.__observer.notify(observer.IndexEvents.DEL, self)
+
+
+class CustomDistributions:
+    """Custom distributions"""
+
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int) -> None:
+        self.__conn = conn
+        self.__module_id = module_id
+        self.__port_id = port_id
+        self.__items: List[CustomDistribution] = []
+        self.__observer = observer.IndicesObserver()
+        self.__observer.subscribe(
+            observer.IndexEvents.DEL,
+            self.__remove_from_slot
+        )
+
+    async def server_sync(self) -> None:
+        """Sync the indices with xenaserver"""
+
+        _resp = await PEC_INDICES(self.__conn, self.__module_id, self.__port_id).get()
+        self.__items = [
+            CustomDistribution(
+                self.__observer,
+                self.__conn,
+                self.__module_id,
+                self.__port_id,
+                idx
+            )
+            for idx in _resp.indexations
+        ]
+
+    def __len__(self) -> int:
+        """Return the number of existing indices"""
+        return len(self.__items)
+
+    def __iter__(self):
+        self.__k = 0
+        return self
+
+    def __next__(self):
+        try:
+            v = self.__items[self.__k]
+        except IndexError:
+            raise StopIteration()
+        else:
+            self.__k += 1
+            return v
+
+    def __getitem__(self, key: int):
+        return self.__items[key]
+
+    def __remove_from_slot(self, index_inst: "CustomDistribution") -> None:
+        # throws ValueError if element is not exists in list of indices
+        self.__items.remove(index_inst)
+
+    async def assign(self, idx_cuantity: int = 0) -> None:
+        """
+        Assign Custom distribution indices, all indices which is out of range will be removed.
+        ``idx_cuantity`` permitted values is: 0 <= idx_cuantity <= 40
+        """
+
+        if not (0 <= idx_cuantity <= 40):
+            raise ValueError("idx_cuantity must be in range of: 0 <= idx_cuantity <= 40")
+        await PEC_INDICES(self.__conn, self.__module_id, self.__port_id).set([i for i in range(idx_cuantity)])
+        await self.server_sync()
+
+    async def remove(self, position_idx: int) -> None:
+        """Remove a index from port"""
+        await self.__items[position_idx].delete()