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

xoa_driver/internals/hli_v1/indices/filter/base_filter.py

@@ -0,0 +1,65 @@
+from typing import (
+    TYPE_CHECKING,
+    List,
+    Type,
+    TypeVar,
+)
+from xoa_driver.internals.commands import (
+    PF_INDICES,
+    PF_CREATE,
+    PF_DELETE,
+    PF_ENABLE,
+    PF_COMMENT,
+    PF_CONDITION,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from ..base_index import BaseIndex
+
+
+FT = TypeVar("FT")
+
+
+class BaseFilterIdx(BaseIndex):
+    """Base L23 Filter Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.comment = PF_COMMENT(conn, *kind)
+        """Description of the filter.
+
+        :type:  PF_COMMENT
+        """
+
+        self.enable = PF_ENABLE(conn, *kind)
+        """Enable or disable the filter.
+
+        :type:  PF_ENABLE
+        """
+
+        self.condition = PF_CONDITION(conn, *kind)
+        """Filter condition configuration.
+
+        :type:  PF_CONDITION
+        """
+
+    async def delete(self):
+        """Delete filter.
+        
+        :type:  PF_DELETE
+        """
+
+        await PF_DELETE(self._conn, *self.kind).set()
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await PF_INDICES(conn, module_id, port_id).get()
+        return list(resp.filter_xindices)
+
+    @classmethod
+    async def _new(cls: Type[FT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> FT:
+        await PF_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)

xoa_driver/internals/hli_v1/indices/filter/genuine_filter.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+from xoa_driver.internals.commands import PF_STRING
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+    from xoa_driver.internals.utils.indices import observer as idx_obs
+
+from .base_filter import BaseFilterIdx
+
+
+class GenuineFilterIdx(BaseFilterIdx):
+    """Genuine L23 Filter Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+        self.string = PF_STRING(conn, *kind)
+        """String representation of the filter.
+
+        :type:  PF_STRING
+        """

xoa_driver/internals/hli_v1/indices/length_term.py

@@ -0,0 +1,49 @@
+from typing import (
+    TYPE_CHECKING,
+    List,
+    TypeVar,
+    Type,
+)
+from xoa_driver.internals.commands import (
+    PL_INDICES,
+    PL_CREATE,
+    PL_DELETE,
+    PL_LENGTH,
+)
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from .base_index import BaseIndex
+
+
+LT = TypeVar("LT")
+
+
+class LengthTermIdx(BaseIndex):
+    """L23 Length Term Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+        self.length = PL_LENGTH(conn, *kind)
+        """Configure length term
+        :type: PL_LENGTH
+        """
+
+    async def delete(self):
+        await PL_DELETE(self._conn, *self.kind).set()
+        """Delete length term.
+        :type: PL_DELETE
+        """
+
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await PL_INDICES(conn, module_id, port_id).get()
+        return list(resp.length_term_xindices)
+
+    @classmethod
+    async def _new(cls: Type[LT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> LT:
+        await PL_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)

xoa_driver/internals/hli_v1/indices/macsecscs/base_macsecsc.py

@@ -0,0 +1,224 @@
+from typing import (
+    List,
+    Type,
+    TypeVar,
+    TYPE_CHECKING,
+)
+from xoa_driver.internals.commands import (
+    P_MACSEC_TXSC_INDICES,
+    P_MACSEC_TXSC_CREATE,
+    P_MACSEC_TXSC_DELETE,
+    P_MACSEC_TXSC_DESCR,
+    P_MACSEC_TXSC_SCI_MODE,
+    P_MACSEC_TXSC_SCI,
+    P_MACSEC_TXSC_CONF_OFFSET,
+    P_MACSEC_TXSC_CIPHERSUITE,
+    P_MACSEC_TXSC_STARTING_PN,
+    # P_MACSEC_TXSC_VLAN_MODE,
+    P_MACSEC_TXSC_REKEY_MODE,
+    P_MACSEC_TXSC_ENCRYPT,
+    P_MACSEC_RXSC_INDICES,
+    P_MACSEC_RXSC_CREATE,
+    P_MACSEC_RXSC_DELETE,
+    P_MACSEC_RXSC_DESCR,
+    P_MACSEC_RXSC_SCI,
+    P_MACSEC_RXSC_CONF_OFFSET,
+    P_MACSEC_RXSC_CIPHERSUITE,
+    P_MACSEC_RXSC_TPLDID,
+    P_MACSEC_RXSC_STARTING_PN,
+    P_MACSEC_TXSC_XPN_SSCI,
+    P_MACSEC_TXSC_XPN_SALT,
+    P_MACSEC_RXSC_XPN_SSCI,
+    P_MACSEC_RXSC_XPN_SALT,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from xoa_driver.internals.utils.indices import header_modifier_manager as hmm
+from ..base_index import BaseIndex
+
+
+class MACSecTxScConfig:
+    """MACSec TX SC Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, txsc_idx: int) -> None:
+        
+        self.description = P_MACSEC_TXSC_DESCR(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's description
+
+        :type: P_MACSEC_TXSC_DESCR
+        """
+
+        self.sci_mode = P_MACSEC_TXSC_SCI_MODE(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's SCI mode
+
+        :type: P_MACSEC_TXSC_SCI_MODE
+        """
+
+        self.sci = P_MACSEC_TXSC_SCI(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's SCI value
+
+        :type: P_MACSEC_TXSC_SCI
+        """
+
+        self.confidentiality_offset = P_MACSEC_TXSC_CONF_OFFSET(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's confidentiality offset
+
+        :type: P_MACSEC_TXSC_CONF_OFFSET
+        """
+
+        self.cipher_suite = P_MACSEC_TXSC_CIPHERSUITE(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's cipher suite
+
+        :type: P_MACSEC_TXSC_CIPHERSUITE
+        """
+
+        self.starting_pn = P_MACSEC_TXSC_STARTING_PN(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's starting PN
+
+        :type: P_MACSEC_TXSC_STARTING_PN
+        """
+
+        # self.vlan_mode = P_MACSEC_TXSC_VLAN_MODE(conn, module_id, port_id, txsc_idx)
+        # """Configure TX SC's VLAN mode
+
+        # :type: P_MACSEC_TXSC_VLAN_MODE
+        # """
+
+        self.rekey_mode = P_MACSEC_TXSC_REKEY_MODE(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's rekey mode
+
+        :type: P_MACSEC_TXSC_REKEY_MODE
+        """
+
+        self.encryption_mode = P_MACSEC_TXSC_ENCRYPT(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's encryption mode
+
+        :type: P_MACSEC_TXSC_ENCRYPT
+        """
+
+        self.xpn_ssci = P_MACSEC_TXSC_XPN_SSCI(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's XPN SSCI value
+
+        :type: P_MACSEC_TXSC_XPN_SSCI
+        """
+
+        self.xpn_salt = P_MACSEC_TXSC_XPN_SALT(conn, module_id, port_id, txsc_idx)
+        """Configure TX SC's XPN Salt value
+
+        :type: P_MACSEC_TXSC_XPN_SALT
+        """
+
+class MACSecRxScConfig:
+    """MACSec RX SC Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, rxsc_idx: int) -> None:
+        
+        self.description = P_MACSEC_RXSC_DESCR(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's description
+
+        :type: P_MACSEC_RXSC_DESCR
+        """
+
+        self.sci = P_MACSEC_RXSC_SCI(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's SCI value
+
+        :type: P_MACSEC_RXSC_SCI
+        """
+
+        self.confidentiality_offset = P_MACSEC_RXSC_CONF_OFFSET(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's confidentiality offset
+
+        :type: P_MACSEC_RXSC_CONF_OFFSET
+        """
+
+        self.cipher_suite = P_MACSEC_RXSC_CIPHERSUITE(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's cipher suite
+
+        :type: P_MACSEC_RXSC_CIPHERSUITE
+        """
+
+        self.starting_pn = P_MACSEC_RXSC_STARTING_PN(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's firset expected PN"""
+
+        self.tpld_id = P_MACSEC_RXSC_TPLDID(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's TPLD ID value
+
+        :type: P_MACSEC_RXSC_TPLDID
+        """
+
+        self.xpn_ssci = P_MACSEC_RXSC_XPN_SSCI(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's XPN SSCI value
+
+        :type: P_MACSEC_RXSC_XPN_SSCI
+        """
+
+        self.xpn_salt = P_MACSEC_RXSC_XPN_SALT(conn, module_id, port_id, rxsc_idx)
+        """Configure RX SC's XPN Salt value
+
+        :type: P_MACSEC_RXSC_XPN_SALT
+        """
+
+
+BS = TypeVar("BS")
+
+
+class BaseMacSecTxScIdx(BaseIndex):
+    """Base MACSec TX SC Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.config = MACSecTxScConfig(conn, *kind)
+        """MACSec TX SC Configuration
+        
+        :type: MACSecTxScConfig
+        """
+
+    async def delete(self):
+        """Delete the TX SC
+
+        :type: P_MACSEC_TXSC_DELETE
+        """
+
+        await P_MACSEC_TXSC_DELETE(self._conn, *self.kind).set()
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await P_MACSEC_TXSC_INDICES(conn, module_id, port_id).get()
+        return list(resp.txsc_indices)
+
+    @classmethod
+    async def _new(cls: Type[BS], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> BS:
+        await P_MACSEC_TXSC_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)
+
+
+class BaseMacSecRxScIdx(BaseIndex):
+    """Base MACSec RX SC Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.config = MACSecRxScConfig(conn, *kind)
+        """MACSec RX SC Configuration
+        
+        :type: MACSecRxScConfig
+        """
+
+    async def delete(self):
+        """Delete the RX SC
+
+        :type: P_MACSEC_RXSC_DELETE
+        """
+
+        await P_MACSEC_RXSC_DELETE(self._conn, *self.kind).set()
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await P_MACSEC_RXSC_INDICES(conn, module_id, port_id).get()
+        return list(resp.rxsc_indices)
+
+    @classmethod
+    async def _new(cls: Type[BS], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> BS:
+        await P_MACSEC_RXSC_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)

xoa_driver/internals/hli_v1/indices/macsecscs/genuine_macsecsc.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING
+from xoa_driver.internals.commands import (
+    P_MACSEC_TXSC_SAK_VALUE,
+    P_MACSEC_RXSC_SAK_VALUE,
+    P_MACSEC_TXSC_STATS,
+    P_MACSEC_RXSC_STATS,
+)
+from .base_macsecsc import (
+    BaseMacSecTxScIdx,
+    BaseMacSecRxScIdx
+)
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+    from xoa_driver.internals.utils.indices import observer as idx_obs
+
+
+
+class GenuineMacSecTxScIdx(BaseMacSecTxScIdx):
+    """Genuine MACSec TX SC Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.stats = P_MACSEC_TXSC_STATS(conn, *kind)
+        """Port's MACsec TX SC statistics
+
+        :type: P_MACSEC_TXSC_STATS
+        """
+
+    def access_sak_value(self, sak_index: int) -> "P_MACSEC_TXSC_SAK_VALUE":
+        """Access SAK value
+
+        :param sak_index: SAK key index
+        :type sak_index: int
+        :rtype: P_MACSEC_TXSC_SAK_VALUE
+        """
+
+        return P_MACSEC_TXSC_SAK_VALUE(
+            self._conn,
+            self.kind.module_id,
+            self.kind.port_id,
+            self.kind.index_id,
+            sak_index
+        )
+
+class GenuineMacSecRxScIdx(BaseMacSecRxScIdx):
+    """Genuine MACSec RX SC Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.stats = P_MACSEC_RXSC_STATS(conn, *kind)
+        """Port's MACsec RX SC statistics
+
+        :type: P_MACSEC_RXSC_STATS
+        """
+
+    def access_sak_value(self, sak_index: int) -> "P_MACSEC_RXSC_SAK_VALUE":
+        """Access SAK value
+
+        :param sak_index: SAK key index
+        :type sak_index: int
+        :rtype: P_MACSEC_RXSC_SAK_VALUE
+        """
+
+        return P_MACSEC_RXSC_SAK_VALUE(
+            self._conn,
+            self.kind.module_id,
+            self.kind.port_id,
+            self.kind.index_id,
+            sak_index
+        )

xoa_driver/internals/hli_v1/indices/match_term.py

@@ -0,0 +1,64 @@
+from typing import (
+    List,
+    Type,
+    TypeVar,
+    TYPE_CHECKING,
+)
+from xoa_driver.internals.commands import (
+    PM_INDICES,
+    PM_CREATE,
+    PM_DELETE,
+    PM_PROTOCOL,
+    PM_POSITION,
+    PM_MATCH,
+)
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from .base_index import BaseIndex
+
+MT = TypeVar("MT")
+
+
+class MatchTermIdx(BaseIndex):
+    """L23 Match Term Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+
+        self.protocol = PM_PROTOCOL(conn, *kind)
+        """The protocol segments assumed on the packets received on the port.
+
+        :type: PM_PROTOCOL
+        """
+
+        self.position = PM_POSITION(conn, *kind)
+        """The position within each received packet where content matching begins for the port.
+
+        :type: PM_POSITION
+        """
+
+        self.match = PM_MATCH(conn, *kind)
+        """The value that must be found at the match term position for packets received on the port.
+
+        :type: PM_MATCH
+        """
+
+    async def delete(self):
+        await PM_DELETE(self._conn, *self.kind).set()
+        """Delete the match term.
+        
+        :type: PM_DELETE
+        """
+
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await PM_INDICES(conn, module_id, port_id).get()
+        return list(resp.match_term_xindices)
+
+    @classmethod
+    async def _new(cls: Type[MT], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> MT:
+        await PM_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)

xoa_driver/internals/hli_v1/indices/port_dataset.py

@@ -0,0 +1,72 @@
+from typing import (
+    TYPE_CHECKING,
+    List,
+    TypeVar,
+    Type,
+)
+from xoa_driver.internals.commands import (
+    PD_INDICES,
+    PD_CREATE,
+    PD_DELETE,
+    PD_ENABLE,
+    PD_SOURCE,
+    PD_RANGE,
+    PD_SAMPLES,
+)
+
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+    from xoa_driver.internals.utils import kind
+from xoa_driver.internals.utils.indices import observer as idx_obs
+from .base_index import BaseIndex
+
+
+PD = TypeVar("PD")
+
+
+class PortDatasetIdx(BaseIndex):
+    """L23 Histogram Index Manager"""
+    def __init__(self, conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> None:
+        super().__init__(conn, kind, observer)
+        self.enable = PD_ENABLE(conn, *kind)
+        """Enable histogram.
+
+        :type: PD_ENABLE
+        """
+
+        self.source = PD_SOURCE(conn, *kind)
+        """The source criteria specifying what is counted, and for which packets, by a histogram of a port.
+
+        :type: PD_SOURCE
+        """
+
+        self.range = PD_RANGE(conn, *kind)
+        """The bucket ranges used for classifying the packets counted by a histogram of a port.
+        
+        :type: PD_RANGE
+        """
+
+        self.samples = PD_SAMPLES(conn, *kind)
+        """The current set of counts collected by a histogram for a port.
+
+        :type: PD_SAMPLES
+        """
+
+    async def delete(self):
+        await PD_DELETE(self._conn, *self.kind).set()
+        """Delete a histogram.
+
+        :type: PD_ENABLE
+        """
+
+        self._observer.notify(idx_obs.IndexEvents.DEL, self)
+
+    @classmethod
+    async def _fetch(cls, conn: "itf.IConnection", module_id: int, port_id: int) -> List[int]:
+        resp = await PD_INDICES(conn, module_id, port_id).get()
+        return list(resp.histogram_indices)
+
+    @classmethod
+    async def _new(cls: Type[PD], conn: "itf.IConnection", kind: "kind.IndicesKind", observer: "idx_obs.IndicesObserver") -> PD:
+        await PD_CREATE(conn, *kind).set()
+        return cls(conn, kind, observer)