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

xoa_driver/internals/hli_v1/indices/connection_group/l2.py

@@ -0,0 +1,94 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_L2_CLIENT_MAC,
+    P4G_L2_SERVER_MAC,
+    P4G_L2_USE_ADDRESS_RES,
+    P4G_L2_USE_GW,
+    P4G_L2_GW,
+    P4G_L2_IPV6_GW,
+    P4G_VLAN_ENABLE,
+    P4G_VLAN_TCI,
+)
+
+
+class GMacL2:
+    """L2 MAC"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.client = P4G_L2_CLIENT_MAC(conn, module_id, port_id, group_idx)
+        """Configure the client MAC address.
+        
+        :type: P4G_L2_CLIENT_MAC
+        """
+
+        self.server = P4G_L2_SERVER_MAC(conn, module_id, port_id, group_idx)
+        """Configure the server MAC address.
+        
+        :type: P4G_L2_SERVER_MAC
+        """
+
+
+class GGatewayL2:
+    """L2 Gateway"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.use = P4G_L2_USE_GW(conn, module_id, port_id, group_idx)
+        """Specify whether to use the resolved default gateway's MAC address as the destination MAC address in the packets.
+        
+        :type: P4G_L2_USE_GW
+        """
+
+        self.ipv4 = P4G_L2_GW(conn, module_id, port_id, group_idx)
+        """Specify a default gateway for IPv4.
+        
+        :type: P4G_L2_GW
+        """
+
+        self.ipv6 = P4G_L2_IPV6_GW(conn, module_id, port_id, group_idx)
+        """Specify a default gateway for IPv6.
+        
+        :type: P4G_L2_IPV6_GW
+        """
+
+
+class GVlanL2:
+    """L2 VLAN"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.enable = P4G_VLAN_ENABLE(conn, module_id, port_id, group_idx)
+        """Specify whether to insert a VLAN tag header upon transmit.
+        
+        :type: P4G_VLAN_ENABLE
+        """
+
+        self.tci = P4G_VLAN_TCI(conn, module_id, port_id, group_idx)
+        """Specify the VLAN TCI.
+        
+        :type: P4G_VLAN_TCI
+        """
+
+
+class GL2:
+    """L2 Configurations"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.address_resolve = P4G_L2_USE_ADDRESS_RES(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_L2_USE_ADDRESS_RES
+        """
+        self.mac = GMacL2(conn, module_id, port_id, group_idx)
+        """L2 MAC
+        
+        :type: GMacL2
+        """
+
+        self.gateway = GGatewayL2(conn, module_id, port_id, group_idx)
+        """L2 Gateway
+        
+        :type: GGatewayL2
+        """
+        
+        self.vlan = GVlanL2(conn, module_id, port_id, group_idx)
+        """L2 VLAN
+        
+        :type: GVlanL2
+        """

xoa_driver/internals/hli_v1/indices/connection_group/l3.py

@@ -0,0 +1,130 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_CLIENT_RANGE,
+    P4G_SERVER_RANGE,
+    P4G_IP_DS_TYPE,
+    P4G_IP_DS_VALUE,
+    P4G_IP_DS_MASK,
+    P4G_IP_DS_MINMAX,
+    P4G_IP_DS_STEP,
+    P4G_IP_VERSION,
+    P4G_IPV6_CLIENT_RANGE,
+    P4G_IPV6_SERVER_RANGE,
+    P4G_IPV6_TRAFFIC_CLASS,
+    P4G_IPV6_FLOW_LABEL,
+    P4G_NAT,
+)
+
+
+class GIPv4L3:
+    """L3 IPv4"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.client_range = P4G_CLIENT_RANGE(conn, module_id, port_id, group_idx)
+        """Specifies a number of client sockets
+        
+        :type: P4G_CLIENT_RANGE
+        """
+
+        self.server_range = P4G_SERVER_RANGE(conn, module_id, port_id, group_idx)
+        """Specifies a number of server sockets
+        
+        :type: P4G_SERVER_RANGE
+        """
+
+
+class GIPv6L3:
+    """L3 IPv6"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.client_range = P4G_IPV6_CLIENT_RANGE(conn, module_id, port_id, group_idx)
+        """Specifies the number of client sockets
+        
+        :type: P4G_IPV6_CLIENT_RANGE
+        """
+
+        self.server_range = P4G_IPV6_SERVER_RANGE(conn, module_id, port_id, group_idx)
+        """Specifies the number of server sockets
+        
+        :type: P4G_IPV6_SERVER_RANGE
+        """
+
+        self.traffic_class = P4G_IPV6_TRAFFIC_CLASS(conn, module_id, port_id, group_idx)
+        """Configure the value of the traffic class field of the IPv6 header.
+        
+        :type: P4G_IPV6_TRAFFIC_CLASS
+        """
+
+        self.flow_label = P4G_IPV6_FLOW_LABEL(conn, module_id, port_id, group_idx)
+        """Configure the value of the flow label field of the IPv6 header.
+        
+        :type: P4G_IPV6_FLOW_LABEL
+        """
+
+
+class GDifferentialServiceL3:
+    """L3 Differential Service"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_IP_DS_TYPE(conn, module_id, port_id, group_idx)
+        """Configure the mode of the DS field of the IP header of this Connection Group.
+        
+        :type: P4G_IP_DS_TYPE
+        """
+
+        self.value = P4G_IP_DS_VALUE(conn, module_id, port_id, group_idx)
+        """Specify the (FIXED) value used for DS.
+        
+        :type: P4G_IP_DS_VALUE
+        """
+
+        self.mask = P4G_IP_DS_MASK(conn, module_id, port_id, group_idx)
+        """Specify a bit mask to be applied to the DS field.
+        
+        :type: P4G_IP_DS_MASK
+        """
+
+        self.range_limits = P4G_IP_DS_MINMAX(conn, module_id, port_id, group_idx)
+        """Configure the min and max values of the range for the calculated part of the DS value.
+        
+        :type: P4G_IP_DS_MINMAX
+        """
+
+        self.step = P4G_IP_DS_STEP(conn, module_id, port_id, group_idx)
+        """Specifies the incrementing step size for the calculated part of the DS value.
+        
+        :type: P4G_IP_DS_STEP
+        """
+
+
+class GL3:
+    """L3 Configurations"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.ip_version = P4G_IP_VERSION(conn, module_id, port_id, group_idx)
+        """Specifies either IPv4 or IPv6.
+        
+        :type: P4G_IP_VERSION
+        """
+
+        self.ipv4 = GIPv4L3(conn, module_id, port_id, group_idx)
+        """L3 IPv4 Configurations
+        
+        :type: GIPv4L3
+        """
+
+        self.ipv6 = GIPv6L3(conn, module_id, port_id, group_idx)
+        """L3 IPv6 Configurations
+        
+        :type: GIPv6L3
+        """
+
+        self.diffserv = GDifferentialServiceL3(conn, module_id, port_id, group_idx)
+        """L3 IPv6 DS Configurations
+        
+        :type: GDifferentialServiceL3
+        """
+
+        self.nat = P4G_NAT(conn, module_id, port_id, group_idx)  # TODO: maybe to add extra logic for this command based on the description
+        """Specify whether to support DUT Source NAT functionality.
+        
+        :type: P4G_NAT
+        """

xoa_driver/internals/hli_v1/indices/connection_group/raw.py

@@ -0,0 +1,200 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_RAW_TEST_SCENARIO,
+    P4G_RAW_PAYLOAD_TYPE,
+    P4G_RAW_PAYLOAD_TOTAL_LEN,
+    P4G_RAW_PAYLOAD,
+    P4G_RAW_PAYLOAD_REPEAT_LEN,
+    P4G_RAW_HAS_DOWNLOAD_REQ,
+    P4G_RAW_CLOSE_CONN,
+    P4G_RAW_UTILIZATION,
+    P4G_RAW_DOWNLOAD_REQUEST,
+    P4G_RAW_TX_DURING_RAMP,
+    P4G_RAW_TX_TIME_OFFSET,
+    P4G_RAW_BURSTY_TX,
+    P4G_RAW_BURSTY_CONF,
+    P4G_RAW_RX_PAYLOAD_LEN,
+    P4G_RAW_REQUEST_REPEAT,
+    P4G_RAW_CONN_INCARNATION,
+    P4G_RAW_CONN_REPETITIONS,
+    P4G_RAW_CONN_LIFETIME,
+    P4G_APP_TRANSACTION_COUNTERS,
+)
+
+
+class GPayloadRaw:
+    """Payload settings of Raw type of test application"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.type = P4G_RAW_PAYLOAD_TYPE(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_PAYLOAD_TYPE
+        """
+
+        self.total_length = P4G_RAW_PAYLOAD_TOTAL_LEN(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_PAYLOAD_TOTAL_LEN
+        """
+
+        self.rx_length = P4G_RAW_RX_PAYLOAD_LEN(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_RX_PAYLOAD_LEN
+        """
+
+        self.content = P4G_RAW_PAYLOAD(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_PAYLOAD
+        """
+
+        self.repeat_length = P4G_RAW_PAYLOAD_REPEAT_LEN(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_PAYLOAD_REPEAT_LEN
+        """
+
+
+class GConnectionRaw:
+    """Connection settings of Raw type of test application"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.incarnation = P4G_RAW_CONN_INCARNATION(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_CONN_INCARNATION
+        """
+
+        self.repetitions = P4G_RAW_CONN_REPETITIONS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_CONN_REPETITIONS
+        """
+
+        self.lifetime = P4G_RAW_CONN_LIFETIME(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_CONN_LIFETIME
+        """
+
+        self.close_condition = P4G_RAW_CLOSE_CONN(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_CLOSE_CONN
+        """
+
+
+class GBurstyRaw:
+    """Burst settings of Raw type of test application"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.transmission = P4G_RAW_BURSTY_TX(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_BURSTY_TX
+        """
+
+        self.config = P4G_RAW_BURSTY_CONF(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_BURSTY_CONF
+        """
+
+
+class GTransmitRaw:
+    """Transmission settings of Raw type of test application"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.during_ramp = P4G_RAW_TX_DURING_RAMP(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_TX_DURING_RAMP
+        """
+
+        self.time_offset = P4G_RAW_TX_TIME_OFFSET(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_TX_TIME_OFFSET
+        """
+
+
+class GDownloadRequestRaw:
+    """Download request settings."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.server_must_wait = P4G_RAW_HAS_DOWNLOAD_REQ(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_HAS_DOWNLOAD_REQ
+        """
+        self.transactions_number = P4G_RAW_REQUEST_REPEAT(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_REQUEST_REPEAT
+        """
+        self.content = P4G_RAW_DOWNLOAD_REQUEST(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_DOWNLOAD_REQUEST
+        """
+
+
+class GCountersTransaction:
+    """Transaction counters."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.transaction = P4G_APP_TRANSACTION_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_APP_TRANSACTION_COUNTERS
+        """
+
+
+class GRaw:
+    """Raw test application configuration."""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.test_scenario = P4G_RAW_TEST_SCENARIO(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_TEST_SCENARIO
+        """
+
+        self.utilization = P4G_RAW_UTILIZATION(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_RAW_UTILIZATION
+        """
+
+        self.download_request = GDownloadRequestRaw(conn, module_id, port_id, group_idx)
+        """Download request.
+        
+        :type: GDownloadRequestRaw
+        """
+
+        self.payload = GPayloadRaw(conn, module_id, port_id, group_idx)
+        """Payload configuration.
+        
+        :type: GPayloadRaw
+        """
+
+        self.connection = GConnectionRaw(conn, module_id, port_id, group_idx)
+        """Connection configuration.
+        
+        :type: GConnectionRaw
+        """
+
+        self.bursty = GBurstyRaw(conn, module_id, port_id, group_idx)
+        """Burst configuration.
+        
+        :type: GBurstyRaw
+        """
+
+        self.tx = GTransmitRaw(conn, module_id, port_id, group_idx)
+        """Transmit configuration.
+        
+        :type: GTransmitRaw
+        """
+
+        self.transaction_counter = GCountersTransaction(conn, module_id, port_id, group_idx)
+        """Transaction counters.
+        
+        :type: GCountersTransaction
+        """

xoa_driver/internals/hli_v1/indices/connection_group/replay.py

@@ -0,0 +1,109 @@
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from xoa_driver.internals.core import interfaces as itf
+from xoa_driver.internals.commands import (
+    P4G_REPLAY_FILE_INDICES,
+    P4G_REPLAY_FILE_NAME,
+    P4G_REPLAY_FILE_CLEAR,
+    P4G_REPLAY_UTILIZATION,
+    P4G_REPLAY_USER_INCARNATION,
+    P4G_REPLAY_USER_REPETITIONS,
+    P4G_APP_REPLAY_COUNTERS,
+    # P4G_REPLAY_SCHEDULING, # TODO: need to implement
+    # P4G_REPLAY_SYNCHRONIZATION, # TODO: need to implement
+)
+
+
+class GFilesReplay:
+    """PCAP replay file configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.__conn = conn
+        self.__module_id = module_id
+        self.__port_id = port_id
+        self.__group_idx = group_idx
+        self.indices = P4G_REPLAY_FILE_INDICES(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_REPLAY_FILE_INDICES
+        """
+
+    def name(self, replay_file_idx: int) -> "P4G_REPLAY_FILE_NAME":
+        """
+        
+        :type: P4G_REPLAY_FILE_NAME
+        """
+        return P4G_REPLAY_FILE_NAME(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            self.__group_idx,
+            replay_file_idx
+        )
+
+    async def clear_index(self, replay_file_idx: int) -> None:
+        """
+        
+        :type: P4G_REPLAY_FILE_CLEAR
+        """
+        await P4G_REPLAY_FILE_CLEAR(
+            self.__conn,
+            self.__module_id,
+            self.__port_id,
+            replay_file_idx
+        ).set()
+
+
+class GUserReplay:
+    """PCAP replay user configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.incarnation = P4G_REPLAY_USER_INCARNATION(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_REPLAY_USER_INCARNATION
+        """
+
+        self.repetitions = P4G_REPLAY_USER_REPETITIONS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_REPLAY_USER_REPETITIONS
+        """
+
+
+class GCounters:
+    """PCAP replay counters"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.replay = P4G_APP_REPLAY_COUNTERS(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_APP_REPLAY_COUNTERS
+        """
+
+
+class GReplay:
+    """PCAP replay configuration"""
+    def __init__(self, conn: "itf.IConnection", module_id: int, port_id: int, group_idx: int) -> None:
+        self.utilization = P4G_REPLAY_UTILIZATION(conn, module_id, port_id, group_idx)
+        """
+        
+        :type: P4G_REPLAY_UTILIZATION
+        """
+
+        # self.scheduling = P4G_REPLAY_SCHEDULING(conn, module_id, port_id, group_idx)
+        # self.synchronization = P4G_REPLAY_SYNCHRONIZATION(conn, module_id, port_id, group_idx)
+        self.files = GFilesReplay(conn, module_id, port_id, group_idx)
+        """PCAP replay file configuration.
+        
+        :type: GFilesReplay
+        """
+
+        self.user = GUserReplay(conn, module_id, port_id, group_idx)
+        """PCAP replay user configuration.
+        
+        :type: GUserReplay
+        """
+
+        self.counters = GCounters(conn, module_id, port_id, group_idx)
+        """PCAP replay counters.
+        
+        :type: GCounters
+        """