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

xoa_driver/internals/hli_v2/indices/connection_group/tcp.py

@@ -0,0 +1,261 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_CLEAR_POST_STAT,
+    P4G_TCP_RTT_VALUE,
+    P4G_TCP_STATE_CURRENT,
+    P4G_TCP_STATE_TOTAL,
+    P4G_TCP_STATE_RATE,
+    P4G_TCP_RX_PAYLOAD_COUNTERS,
+    P4G_TCP_TX_PAYLOAD_COUNTERS,
+    P4G_TCP_RETRANSMIT_COUNTERS,
+    P4G_TCP_ERROR_COUNTERS,
+    P4G_TCP_MSS_TYPE,
+    P4G_TCP_MSS_MINMAX,
+    P4G_TCP_MSS_VALUE,
+    P4G_TCP_WINDOW_SIZE,
+    P4G_TCP_DUP_THRES,
+    P4G_TCP_SYN_RTO,
+    P4G_TCP_RTO,
+    P4G_TCP_CONGESTION_MODE,
+    P4G_TCP_WINDOW_SCALING,
+    P4G_TCP_RTO_MINMAX,
+    P4G_TCP_RTO_PROLONGED_MODE,
+    P4G_TCP_ICWND_CALC_METHOD,
+    P4G_TCP_ISSTHRESH,
+    P4G_TCP_ACK_FREQUENCY,
+    P4G_TCP_ACK_TIMEOUT,
+    P4G_TCP_ESTABLISH_HIST,
+    P4G_TCP_CLOSE_HIST,
+    P4G_TCP_RX_TOTAL_BYTES_HIST,
+    P4G_TCP_RX_GOOD_BYTES_HIST,
+    P4G_TCP_TX_TOTAL_BYTES_HIST,
+    P4G_TCP_TX_GOOD_BYTES_HIST,
+    P4G_TCP_RX_PACKET_COUNTERS,
+    P4G_TCP_TX_PACKET_COUNTERS,
+)
+
+
+class GAckTcp:
+    """TCP ACK configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.duplicate_tresholds = P4G_TCP_DUP_THRES(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_DUP_THRES
+        """
+        self.frequency = P4G_TCP_ACK_FREQUENCY(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ACK_FREQUENCY
+        """
+        self.timeout = P4G_TCP_ACK_TIMEOUT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ACK_TIMEOUT
+        """
+
+
+class GRetransmitionTimeoutTcp:
+    """TCP Retransmition Timeout configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.syn_value = P4G_TCP_SYN_RTO(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_SYN_RTO
+        """
+        self.value = P4G_TCP_RTO(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RTO
+        """
+        self.range_limits = P4G_TCP_RTO_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RTO_MINMAX
+        """
+        self.prolonged_mode = P4G_TCP_RTO_PROLONGED_MODE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RTO_PROLONGED_MODE
+        """
+
+
+class GStateCountersTcp:
+    """TCP State counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_TCP_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_STATE_CURRENT
+        """
+        self.total = P4G_TCP_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_STATE_TOTAL
+        """
+        self.rate = P4G_TCP_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_STATE_RATE
+        """
+
+
+class GMaxSegmentSize:
+    """TCP Max Segment Size Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_TCP_MSS_TYPE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_MSS_TYPE
+        """
+        self.range_limits = P4G_TCP_MSS_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_MSS_MINMAX
+        """
+        self.fixed_value = P4G_TCP_MSS_VALUE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_MSS_VALUE
+        """
+
+
+class GPacketCountersTcp:
+    """TCP Packet Counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TCP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RX_PACKET_COUNTERS
+        """
+        self.tx = P4G_TCP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_TX_PACKET_COUNTERS
+        """
+
+
+class GPayloadCountersTcp:
+    """TCP Payload Counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TCP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_TCP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GCountersTcp:
+    """TCP counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.retransmission = P4G_TCP_RETRANSMIT_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RETRANSMIT_COUNTERS
+        """
+        self.error = P4G_TCP_ERROR_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ERROR_COUNTERS
+        """
+        self.packet = GPacketCountersTcp(conn, module_id, port_id, group_idx)
+        """Packet counters"""
+        self.payload = GPayloadCountersTcp(conn, module_id, port_id, group_idx)
+        """Payload counters"""
+        self.state = GStateCountersTcp(conn, module_id, port_id, group_idx)
+        """State counters"""
+
+
+class GRxHistogramTcp:
+    """TCP RX Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.total_bytes = P4G_TCP_RX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RX_TOTAL_BYTES_HIST
+        """
+        self.good_bytes = P4G_TCP_RX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RX_GOOD_BYTES_HIST
+        """
+
+
+class GTxHistogramTcp:
+    """TCP TX Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.total_bytes = P4G_TCP_TX_TOTAL_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_TX_TOTAL_BYTES_HIST
+        """
+        self.good_bytes = P4G_TCP_TX_GOOD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_TX_GOOD_BYTES_HIST
+        """
+
+
+class GConnHistogramTcp:
+    """TCP Connection Histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.establish_times = P4G_TCP_ESTABLISH_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ESTABLISH_HIST
+        """
+        self.close_times = P4G_TCP_CLOSE_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_CLOSE_HIST
+        """
+
+
+class GHistogramTcp:
+    """TCP histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.connection = GConnHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP Connection Histogram"""
+        self.rx = GRxHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP RX Histogram"""
+        self.tx = GTxHistogramTcp(conn, module_id, port_id, group_idx)
+        """TCP TX Histogram"""
+
+
+class GReceiverWindowTcp:
+    """TCP RWND Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.size = P4G_TCP_WINDOW_SIZE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_WINDOW_SIZE
+        """
+        self.scaling = P4G_TCP_WINDOW_SCALING(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_WINDOW_SCALING
+        """
+
+
+class GCongestionWindowTcp:
+    """TCP CWND Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.congestion_mode = P4G_TCP_CONGESTION_MODE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_CONGESTION_MODE
+        """
+        self.icwnd_calc_method = P4G_TCP_ICWND_CALC_METHOD(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ICWND_CALC_METHOD
+        """
+
+
+class GTcp:
+    """TCP Stack Configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.clear_post_test_statistics = P4G_CLEAR_POST_STAT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_CLEAR_POST_STAT
+        """
+        self.rtt_value = P4G_TCP_RTT_VALUE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_RTT_VALUE
+        """
+        self.iss_treshold = P4G_TCP_ISSTHRESH(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TCP_ISSTHRESH
+        """
+        self.mss = GMaxSegmentSize(conn, module_id, port_id, group_idx)
+        """Max segment size config"""
+        self.rto = GRetransmitionTimeoutTcp(conn, module_id, port_id, group_idx)
+        """Retransmission timeout config"""
+        self.ack = GAckTcp(conn, module_id, port_id, group_idx)
+        """ACK config"""
+        self.rwnd = GReceiverWindowTcp(conn, module_id, port_id, group_idx)
+        """RWND config"""
+        self.cwnd = GCongestionWindowTcp(conn, module_id, port_id, group_idx)
+        """CWND config"""
+        self.counters = GCountersTcp(conn, module_id, port_id, group_idx)
+        """Counters"""
+        self.histogram = GHistogramTcp(conn, module_id, port_id, group_idx)
+        """Histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/tls.py

@@ -0,0 +1,166 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_TLS_ENABLE,
+    P4G_TLS_CIPHER_SUITES,
+    P4G_TLS_MAX_RECORD_SIZE,
+    P4G_TLS_CERTIFICATE_FILENAME,
+    P4G_TLS_PRIVATE_KEY_FILENAME,
+    P4G_TLS_DHPARAMS_FILENAME,
+    P4G_TLS_CLOSE_NOTIFY,
+    P4G_TLS_ALERT_WARNING_COUNTERS,
+    P4G_TLS_ALERT_FATAL_COUNTERS,
+    P4G_TLS_STATE_CURRENT,
+    P4G_TLS_STATE_TOTAL,
+    P4G_TLS_STATE_RATE,
+    P4G_TLS_RX_PAYLOAD_COUNTERS,
+    P4G_TLS_TX_PAYLOAD_COUNTERS,
+    P4G_TLS_RX_PAYLOAD_BYTES_HIST,
+    P4G_TLS_TX_PAYLOAD_BYTES_HIST,
+    P4G_TLS_HANDSHAKE_HIST,
+    P4G_TLS_SERVER_NAME,
+    P4G_TLS_PROTOCOL_VER,
+    P4G_TLS_MIN_REQ_PROTOCOL_VER,
+)
+
+
+class GCountersTlsState:
+    """TLS state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_TLS_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_STATE_CURRENT
+        """
+        self.total = P4G_TLS_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_STATE_TOTAL
+        """
+        self.rate = P4G_TLS_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_STATE_RATE
+        """
+
+
+class GCountersTlsAlert:
+    """TLS alert counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.warning = P4G_TLS_ALERT_WARNING_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_ALERT_WARNING_COUNTERS
+        """
+        self.fatal = P4G_TLS_ALERT_FATAL_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_ALERT_FATAL_COUNTERS
+        """
+
+
+class GCountersTlsPayload:
+    """TLS payload counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_TLS_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_TLS_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GCountersTls:
+    """TLS counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.alert = GCountersTlsAlert(conn, module_id, port_id, group_idx)
+        """TLS alert counters"""
+        self.payload = GCountersTlsPayload(conn, module_id, port_id, group_idx)
+        """TLS payload counters"""
+        self.state = GCountersTlsState(conn, module_id, port_id, group_idx)
+        """TLS state counters"""
+
+
+class GHistogramTlsPayload:
+    """TLS payload histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx_bytes = P4G_TLS_RX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_RX_PAYLOAD_BYTES_HIST
+        """
+        self.tx_bytes = P4G_TLS_TX_PAYLOAD_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_TX_PAYLOAD_BYTES_HIST
+        """
+
+
+class GHistogramTls:
+    """TLS histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.handshake = P4G_TLS_HANDSHAKE_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_HANDSHAKE_HIST
+        """
+        self.payload = GHistogramTlsPayload(conn, module_id, port_id, group_idx)
+        """TLS payload histogram"""
+
+
+class GProtocolTls:
+    """TLS protocol version"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.version = P4G_TLS_PROTOCOL_VER(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_PROTOCOL_VER
+        """
+        self.min_required_version = P4G_TLS_MIN_REQ_PROTOCOL_VER(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_MIN_REQ_PROTOCOL_VER
+        """
+
+
+class GFileTls:
+    """TLS certificate and key files"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.certificate_path = P4G_TLS_CERTIFICATE_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_CERTIFICATE_FILENAME
+        """
+        self.private_key_path = P4G_TLS_PRIVATE_KEY_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_PRIVATE_KEY_FILENAME
+        """
+        self.dhparams_path = P4G_TLS_DHPARAMS_FILENAME(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_DHPARAMS_FILENAME
+        """
+
+
+class GTls:
+    """TLS configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.enable = P4G_TLS_ENABLE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_ENABLE
+        """
+        self.server_name = P4G_TLS_SERVER_NAME(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_SERVER_NAME
+        """
+        self.close_notify = P4G_TLS_CLOSE_NOTIFY(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_CLOSE_NOTIFY
+        """
+        self.cipher_suites = P4G_TLS_CIPHER_SUITES(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_CIPHER_SUITES
+        """
+        self.max_record_size = P4G_TLS_MAX_RECORD_SIZE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_TLS_MAX_RECORD_SIZE
+        """
+        self.file = GFileTls(conn, module_id, port_id, group_idx)
+        """Cert and key file"""
+        self.protocol = GProtocolTls(conn, module_id, port_id, group_idx)
+        """Protocol version"""
+        self.counters = GCountersTls(conn, module_id, port_id, group_idx)
+        """Counters"""
+        self.histogram = GHistogramTls(conn, module_id, port_id, group_idx)
+        """Histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/udp.py

@@ -0,0 +1,112 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_UDP_PACKET_SIZE_TYPE,
+    P4G_UDP_PACKET_SIZE_MINMAX,
+    P4G_UDP_PACKET_SIZE_VALUE,
+    P4G_UDP_STATE_CURRENT,
+    P4G_UDP_STATE_TOTAL,
+    P4G_UDP_STATE_RATE,
+    P4G_UDP_RX_PAYLOAD_COUNTERS,
+    P4G_UDP_TX_PAYLOAD_COUNTERS,
+    P4G_UDP_RX_BYTES_HIST,
+    P4G_UDP_TX_BYTES_HIST,
+    P4G_UDP_RX_PACKET_COUNTERS,
+    P4G_UDP_TX_PACKET_COUNTERS,
+)
+
+
+class GHistogramUdp:
+    """UDP histogram"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx_bytes = P4G_UDP_RX_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_RX_BYTES_HIST
+        """
+        self.tx_bytes = P4G_UDP_TX_BYTES_HIST(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_TX_BYTES_HIST
+        """
+
+
+class GPayloadCountersUdp:
+    """UDP payload counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_UDP_RX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_RX_PAYLOAD_COUNTERS
+        """
+        self.tx = P4G_UDP_TX_PAYLOAD_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_TX_PAYLOAD_COUNTERS
+        """
+
+
+class GPacketCountersUdp:
+    """UDP packet counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.rx = P4G_UDP_RX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_RX_PACKET_COUNTERS
+        """
+        self.tx = P4G_UDP_TX_PACKET_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_TX_PACKET_COUNTERS
+        """
+
+
+class GCountersUdp:
+    """UDP counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.payload = GPayloadCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP payload counters"""
+        self.packet = GPacketCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP packet counters"""
+        self.state = GStateCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP state counters"""
+
+
+class GPacketSizeUdp:
+    """UDP packet size"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_UDP_PACKET_SIZE_TYPE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_PACKET_SIZE_TYPE
+        """
+        self.range_limits = P4G_UDP_PACKET_SIZE_MINMAX(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_PACKET_SIZE_MINMAX
+        """
+        self.value = P4G_UDP_PACKET_SIZE_VALUE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_PACKET_SIZE_VALUE
+        """
+
+
+class GStateCountersUdp:
+    """UDP state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_UDP_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_STATE_CURRENT
+        """
+        self.total = P4G_UDP_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_STATE_TOTAL
+        """
+        self.rate = P4G_UDP_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_UDP_STATE_RATE
+        """
+
+
+class GUdp:
+    """UDP configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.packet_size = GPacketSizeUdp(conn, module_id, port_id, group_idx)
+        """UDP packet size"""
+        self.counters = GCountersUdp(conn, module_id, port_id, group_idx)
+        """UDP counters"""
+        self.histogram = GHistogramUdp(conn, module_id, port_id, group_idx)
+        """UDP histogram"""

xoa_driver/internals/hli_v2/indices/connection_group/user_state.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_USER_STATE_CURRENT,
+    P4G_USER_STATE_TOTAL,
+    P4G_USER_STATE_RATE,
+)
+
+
+class GUserState:
+    """User state counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.current = P4G_USER_STATE_CURRENT(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_USER_STATE_CURRENT
+        """
+        self.total = P4G_USER_STATE_TOTAL(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_USER_STATE_TOTAL
+        """
+        self.rate = P4G_USER_STATE_RATE(conn, module_id, port_id, group_idx)
+        """
+        Representation of P4G_USER_STATE_RATE
+        """

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

@@ -0,0 +1,50 @@
+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)
+        """Representation of PF_COMMENT"""
+        self.enable = PF_ENABLE(conn, *kind)
+        """Representation of PF_ENABLE"""
+        self.condition = PF_CONDITION(conn, *kind)
+        """Representation of PF_CONDITION"""
+
+    async def delete(self):
+        """Representation of 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_v2/indices/filter/genuine_filter.py

@@ -0,0 +1,17 @@
+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)
+        """Representation of PF_STRING"""

xoa_driver/internals/hli_v2/indices/length_term.py

@@ -0,0 +1,44 @@
+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)
+        """Representation of pl_commands.PL_LENGTH"""
+
+    async def delete(self):
+        await PL_DELETE(self._conn, *self.kind).set()
+        """Representation of pl_commands.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)