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

xoa_driver/internals/commands/pl_commands.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import typing
+import functools
+
+from xoa_driver.internals.core.builders import (
+    build_get_request,
+    build_set_request
+)
+from xoa_driver.internals.core import interfaces
+from xoa_driver.internals.core.token import Token
+from xoa_driver.internals.core.transporter.registry import register_command
+from xoa_driver.internals.core.transporter.protocol.payload import (
+    field,
+    RequestBodyStruct,
+    ResponseBodyStruct,
+    XmpInt,
+    XmpSequence,
+)
+from .enums import LengthCheckType
+
+
+@register_command
+@dataclass
+class PL_INDICES:
+    """
+    The full list of which length terms are defined for a port. These are the sub-
+    index values that are used for the parameters defining the length-based matching
+    of packets received for the port. Setting the value of this parameter creates a
+    new empty length term for each value that is not already in use, and deletes
+    each length term that is not mentioned in the list. The same can be accomplished
+    one- length-term-at-a-time using the PL_CREATE and PL_DELETE commands.
+    """
+
+    code: typing.ClassVar[int] = 207
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        length_term_xindices: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, the sub-index of a length term definition for the port."""
+
+    class SetDataAttr(RequestBodyStruct):
+        length_term_xindices: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, the sub-index of a length term definition for the port."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the full list of which length terms are defined for a port.
+
+        :return: the full list of which length terms are defined for a port
+        :rtype: PL_INDICES.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port))
+
+    def set(self, length_term_xindices: typing.List[int]) -> Token[None]:
+        """Create a new empty length term for each value that is not already in use, and deletes each length term that is not mentioned in the list.
+
+        :param length_term_xindices: the list of indices of length terms to be created on a port.
+        :type length_term_xindices: typing.List[int]
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, length_term_xindices=length_term_xindices))
+
+
+@register_command
+@dataclass
+class PL_CREATE:
+    """
+    Creates an empty length term definition with the specified sub-index value.
+    """
+
+    code: typing.ClassVar[int] = 208
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _length_term_xindex: int
+
+    class SetDataAttr(RequestBodyStruct):
+        pass
+
+    def set(self) -> Token[None]:
+        """Creates an empty length term definition with the specified sub-index value.
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._length_term_xindex]))
+
+
+@register_command
+@dataclass
+class PL_DELETE:
+    """
+    Deletes the length term definition with the specified sub-index value. A length
+    term cannot be deleted while it is used in the condition of any filter for the
+    port.
+    """
+
+    code: typing.ClassVar[int] = 209
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _length_term_xindex: int
+
+    class SetDataAttr(RequestBodyStruct):
+        pass
+
+    def set(self) -> Token[None]:
+        """Deletes the length term definition with the specified sub-index value.
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._length_term_xindex]))
+
+
+@register_command
+@dataclass
+class PL_LENGTH:
+    """
+    The specification for a length-based check that is applied on the packets
+    received on the port.
+    """
+
+    code: typing.ClassVar[int] = 210
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _length_term_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        length_check_type: LengthCheckType = field(XmpInt())
+        """coded integer, whether to test for shorter-than or longer-than."""
+        size: int = field(XmpInt())
+        """integer, the value to compare the packet length against."""
+
+    class SetDataAttr(RequestBodyStruct):
+        length_check_type: LengthCheckType = field(XmpInt())
+        """coded integer, whether to test for shorter-than or longer-than."""
+        size: int = field(XmpInt())
+        """integer, the value to compare the packet length against."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of a length-based check that is applied on the packets received on a port.
+
+        :return: whether to test for shorter-than or longer-than, and the value to compare the packet length against
+        :rtype: PL_LENGTH.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._length_term_xindex]))
+
+    def set(self, length_check_type: LengthCheckType, size: int) -> Token[None]:
+        """Set the configuration of a length-based check that is applied on the packets received on a port.
+
+        :param length_check_type: whether to test for shorter-than or longer-than
+        :type length_check_type: LengthCheckType
+        :param size: the value to compare the packet length against
+        :type size: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(self, module=self._module, port=self._port, indices=[self._length_term_xindex], length_check_type=length_check_type, size=size)
+        )
+
+    set_at_most = functools.partialmethod(set, LengthCheckType.AT_MOST)
+    """Set the length check to be short than or equal to the given length (at most).
+    """
+
+    set_at_least = functools.partialmethod(set, LengthCheckType.AT_LEAST)
+    """Set the length check to be longer than or equal to the given length (at least).
+    """

xoa_driver/internals/commands/pm_commands.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import typing
+
+from xoa_driver.internals.core.builders import (
+    build_get_request,
+    build_set_request
+)
+from xoa_driver.internals.core import interfaces
+from xoa_driver.internals.core.token import Token
+from xoa_driver.internals.core.transporter.registry import register_command
+from xoa_driver.internals.core.transporter.protocol.payload import (
+    field,
+    RequestBodyStruct,
+    ResponseBodyStruct,
+    XmpByte,
+    XmpHex,
+    XmpInt,
+    XmpSequence,
+    Hex,
+)
+from .enums import ProtocolOption
+
+
+@register_command
+@dataclass
+class PM_INDICES:
+    """
+    The full list of which match terms are defined for a port. These are the sub-
+    index values that are used for the parameters defining the content-based
+    matching of packets received for the port. Setting the value of this parameter
+    creates a new empty match term for each value that is not already in use, and
+    deletes each match term that is not mentioned in the list. The same can be
+    accomplished one match-term-at-a-time using the PM_CREATE and PM_DELETE commands.
+    """
+
+    code: typing.ClassVar[int] = 200
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        match_term_xindices: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, the sub-index of a match term definition for the port."""
+
+    class SetDataAttr(RequestBodyStruct):
+        match_term_xindices: typing.List[int] = field(XmpSequence(types_chunk=[XmpInt()]))
+        """list of integers, the sub-index of a match term definition for the port."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the full list of which match terms are defined for a port.
+
+        :return: the full list of which match terms are defined for a port
+        :rtype: PM_INDICES.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port))
+
+    def set(self, match_term_xindices: typing.List[int]) -> Token[None]:
+        """Creates a new empty match term for each value that is not already in use, and delete each match term that is not mentioned in the list
+
+        :param match_term_xindices: the sub-index of a match term definition for the port
+        :type match_term_xindices: typing.List[int]
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, match_term_xindices=match_term_xindices))
+
+
+@register_command
+@dataclass
+class PM_CREATE:
+    """
+    Creates an empty match term definition with the specified sub-index value.
+    """
+
+    code: typing.ClassVar[int] = 201
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _match_term_xindex: int
+
+    class SetDataAttr(RequestBodyStruct):
+        pass
+
+    def set(self) -> Token[None]:
+        """Creates an empty match term definition with the specified sub-index value.
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex]))
+
+
+@register_command
+@dataclass
+class PM_DELETE:
+    """
+    Deletes the match term definition with the specified sub-index value. A match
+    term cannot be deleted while it is used in the condition of any filter for the
+    port.
+    """
+
+    code: typing.ClassVar[int] = 202
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _match_term_xindex: int
+
+    class SetDataAttr(RequestBodyStruct):
+        pass
+
+    def set(self) -> Token[None]:
+        """Deletes the match term definition with the specified sub-index value.
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex]))
+
+
+@register_command
+@dataclass
+class PM_PROTOCOL:
+    """
+    The protocol segments assumed on the packets received on the port. This is
+    mainly for information purposes, and helps you identify which portion of the
+    packet header is being matched. The actual value definition of the match
+    position is specified with PM_POSITION.
+    """
+
+    code: typing.ClassVar[int] = 203
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _match_term_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        segments: typing.List[ProtocolOption] = field(XmpSequence(types_chunk=[XmpByte()]))
+        """list of coded bytes, a number specifying a built-in protocol segment: Uses the same coded values as the PS_HEADERPROTOCOL parameter."""
+
+    class SetDataAttr(RequestBodyStruct):
+        segments: typing.List[ProtocolOption] = field(XmpSequence(types_chunk=[XmpByte()]))
+        """list of coded bytes, a number specifying a built-in protocol segment: Uses the same coded values as the PS_HEADERPROTOCOL parameter."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the protocol segments assumed on the packets received on the port.
+
+        :return: a number specifying a built-in protocol segment: Uses the same coded values as the PS_HEADERPROTOCOL parameter.
+        :rtype: PM_PROTOCOL.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex]))
+
+    def set(self, segments: typing.List[ProtocolOption]) -> Token[None]:
+        """Set the protocol segments assumed on the packets received on the port.
+
+        :param segments: a number specifying a built-in protocol segment: Uses the same coded values as the PS_HEADERPROTOCOL parameter
+        :type segments: typing.List[ProtocolOption]
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex], segments=segments))
+
+
+@register_command
+@dataclass
+class PM_POSITION:
+    """
+    The position within each received packet where content matching begins for the port.
+    """
+
+    code: typing.ClassVar[int] = 204
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _match_term_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        byte_offset: int = field(XmpInt())
+        """integer, offset from the start of the packet bytes."""
+
+    class SetDataAttr(RequestBodyStruct):
+        byte_offset: int = field(XmpInt())
+        """integer, offset from the start of the packet bytes."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the position within each received packet where content matching begins for the port.
+
+        :return: offset from the start of the packet bytes
+        :rtype: PM_POSITION.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex]))
+
+    def set(self, byte_offset: int) -> Token[None]:
+        """Set the position within each received packet where content matching begins for the port.
+
+        :param byte_offset: offset from the start of the packet bytes
+        :type byte_offset: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex], byte_offset=byte_offset))
+
+
+@register_command
+@dataclass
+class PM_MATCH:
+    """
+    The value that must be found at the match term position for packets received on
+    the port. The mask can make certain bit positions don't-care.
+    """
+
+    code: typing.ClassVar[int] = 205
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _match_term_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        mask: Hex = field(XmpHex(size=8))
+        """eight hex bytes, which bits are significant in the match operation."""
+        value: Hex = field(XmpHex(size=8))
+        """eight hex bytes, the value that must be found for the match term to be true."""
+
+    class SetDataAttr(RequestBodyStruct):
+        mask: Hex = field(XmpHex(size=8))
+        """eight hex bytes, which bits are significant in the match operation."""
+        value: Hex = field(XmpHex(size=8))
+        """eight hex bytes, the value that must be found for the match term to be true."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the value that must be found at the match term position for packets received on the port.
+
+        :return: which bits are significant in the match operation, and the value that must be found for the match term to be true.
+        :rtype: PM_MATCH.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex]))
+
+    def set(self, mask: Hex, value: Hex) -> Token[None]:
+        """Set the value that must be found at the match term position for packets received on the port.
+
+        :param mask: which bits are significant in the match operation
+        :type mask: Hex
+        :param value: the value that must be found for the match term to be true
+        :type value: Hex
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._match_term_xindex], mask=mask, value=value))