tdl-xoa-driver 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

xoa_driver/functions/cli/_config_block.py

@@ -0,0 +1,334 @@
+from xoa_driver import __version__, __name__
+from typing import Union, List
+from enum import Enum
+from dataclasses import dataclass
+
+class ConfigMetadataType(Enum):
+    DEFAULT = "XENA"
+    PORT = "XENAPORT"
+    MODULE = "XENAMODULE"
+    TESTCASE = "XENACASE"
+
+@dataclass
+class BaseConfigMetadata:
+    type: ConfigMetadataType = ConfigMetadataType.DEFAULT
+    formated_version: int = 3
+    saved_by: str = __name__ + __version__
+
+    def to_str(self) -> str:
+        header_lines = [
+            f";{self.type.value}",
+            f";FormatVersion: {self.formated_version}",
+            f";Savedby: {self.saved_by}",
+        ]
+        return "\n".join(header_lines)
+
+# Module config metadata dataclass
+@dataclass
+class TestCaseMetadata(BaseConfigMetadata):
+    type: ConfigMetadataType = ConfigMetadataType.TESTCASE
+    testbed_name: str = "<testbed>"
+    chassis_name: str = "<chassis_name>"
+    chassis_sn: str = "<chassis_sn>"
+    chassis_version_str: str = "<chassis_version_str>"
+    module_name: str = "<module_name>"
+    module_model: str = "<module_model>"
+    module_sn: str = "<module_sn>"
+    module_version_str: str = "<module_version_str>"
+    module_revision: str = "<module_revision>"
+
+    def to_str(self) -> str:
+        header_lines = [
+            f";{self.type.value}",
+            f";FormatVersion: {super().formated_version}",
+            f";Savedby: {super().saved_by}",
+            f";Testbed: {self.testbed_name}",
+        ]
+        return "\n".join(header_lines)
+
+# Module config metadata dataclass
+@dataclass
+class ModuleConfigMetadata(BaseConfigMetadata):
+    type: ConfigMetadataType = ConfigMetadataType.MODULE
+    testbed_name: str = "<testbed>"
+    chassis_name: str = "<chassis_name>"
+    chassis_sn: str = "<chassis_sn>"
+    chassis_version_str: str = "<chassis_version_str>"
+    module_name: str = "<module_name>"
+    module_model: str = "<module_model>"
+    module_sn: str = "<module_sn>"
+    module_version_str: str = "<module_version_str>"
+    module_revision: str = "<module_revision>"
+    module_id: str = "<module_id>"
+
+    def to_str(self) -> str:
+        header_lines = [
+            f";{self.type.value}",
+            f";FormatVersion: {super().formated_version}",
+            f";Savedby: {super().saved_by}",
+            f";ChassisName: {self.chassis_name}",
+            f";ChassisSerial: {self.chassis_sn}",
+            f";ChassisVersion: {self.chassis_version_str}",
+            f";ModuleName: {self.module_name}",
+            f";ModuleModel: {self.module_model.replace('_', '')}",
+            f";ModuleSerial: {self.module_sn}",
+            f";ModuleVersion: {self.module_version_str}",
+            f";ModuleRevision: {self.module_revision}",
+            f";Module: {self.module_id}",
+        ]
+        return "\n".join(header_lines)
+    
+# Port config metadata dataclass
+@dataclass
+class PortConfigMetadata(BaseConfigMetadata):
+    type = ConfigMetadataType.PORT
+    testbed_name: str = "<testbed>"
+    chassis_name: str = "<chassis_name>"
+    chassis_sn: str = "<chassis_sn>"
+    chassis_version_str: str = "<chassis_version_str>"
+    module_name: str = "<module_name>"
+    module_model: str = "<module_model>"
+    module_sn: str = "<module_sn>"
+    module_version_str: str = "<module_version_str>"
+    module_revision: str = "<module_revision>"
+    port_id: str = "<port_id>"
+
+    def to_str(self) -> str:
+        header_lines = [
+            f";{self.type.value}",
+            f";FormatVersion: {super().formated_version}",
+            f";Savedby: {super().saved_by}",
+            f";ChassisName: {self.chassis_name}",
+            f";ChassisSerial: {self.chassis_sn}",
+            f";ChassisVersion: {self.chassis_version_str}",
+            f";ModuleName: {self.module_name}",
+            f";ModuleModel: {self.module_model.replace('_', '')}",
+            f";ModuleSerial: {self.module_sn}",
+            f";ModuleVersion: {self.module_version_str}",
+            f";ModuleRevision: {self.module_revision}",
+            f";Port: {self.port_id}",
+        ]
+        return "\n".join(header_lines)
+
+# Config block
+class ConfigBlock:
+    def __init__(self):
+        self._config_block_str: str
+        self._metadata: Union[TestCaseMetadata, PortConfigMetadata, ModuleConfigMetadata]
+        self._commands: List[str] = []
+
+    @property
+    def type(self) -> ConfigMetadataType:
+        return self._metadata.type
+
+    @type.setter
+    def type(self, v: ConfigMetadataType) -> None:
+        if v == ConfigMetadataType.MODULE:
+            self._metadata = ModuleConfigMetadata()
+            self._metadata.type = v
+        elif v == ConfigMetadataType.PORT:
+            self._metadata = PortConfigMetadata()
+            self._metadata.type = v
+        elif v == ConfigMetadataType.TESTCASE:
+            self._metadata = TestCaseMetadata()
+            self._metadata.type = v
+        else:
+            raise ValueError("Invalid config type")
+
+    @property
+    def config_block_str(self) -> str:
+        header_str = self._metadata.to_str()
+        if len(self._commands) == 0:
+            return header_str
+        else:
+            commands_str = "\n".join(self._commands)
+            return header_str + "\n" + commands_str
+    
+    @config_block_str.setter
+    def config_block_str(self, v: str) -> None:
+        self._config_block_str = v
+
+        metadata_list = []
+        line_list = self._config_block_str.splitlines()
+        
+        for line in line_list:
+            if line.startswith(';'):
+                metadata_list.append(line)
+            else:
+                self._commands.append(line)
+
+        if line_list[0].startswith(f";{ConfigMetadataType.MODULE.value}"):
+            self._metadata = ModuleConfigMetadata()
+            for line in metadata_list:
+                if line.startswith(f";ChassisName:"):
+                    self._metadata.chassis_name = line.split(" ")[1].strip()
+                elif line.startswith(f";ChassisSerial:"):
+                    self._metadata.chassis_sn = line.split(" ")[1].strip()
+                elif line.startswith(f";ChassisVersion:"):
+                    self._metadata.chassis_version_str = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleName:"):
+                    self._metadata.module_name = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleModel:"):
+                    self._metadata.module_model = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleSerial:"):
+                    self._metadata.module_sn = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleVersion:"):
+                    self._metadata.module_version_str = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleRevision:"):
+                    self._metadata.module_revision = line.split(" ")[1].strip()
+                elif line.startswith(f";Module:"):
+                    self._metadata.module_id = line.split(" ")[1].strip()
+
+        if line_list[0].startswith(f";{ConfigMetadataType.PORT.value}"):
+            self._metadata = PortConfigMetadata()
+            for line in metadata_list:
+                if line.startswith(f";ChassisName:"):
+                    self._metadata.chassis_name = line.split(" ")[1].strip()
+                elif line.startswith(f";ChassisSerial:"):
+                    self._metadata.chassis_sn = line.split(" ")[1].strip()
+                elif line.startswith(f";ChassisVersion:"):
+                    self._metadata.chassis_version_str = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleName:"):
+                    self._metadata.module_name = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleModel:"):
+                    self._metadata.module_model = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleSerial:"):
+                    self._metadata.module_sn = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleVersion:"):
+                    self._metadata.module_version_str = line.split(" ")[1].strip()
+                elif line.startswith(f";ModuleRevision:"):
+                    self._metadata.module_revision = line.split(" ")[1].strip()
+                elif line.startswith(f";Port:"):
+                    self._metadata.port_id = line.split(" ")[1].strip()
+
+    @property
+    def testbed_name(self) -> str:
+        return self._metadata.testbed_name
+    
+    @testbed_name.setter
+    def testbed_name(self, v: str) -> None:
+        self._metadata.testbed_name = v
+    
+    @property
+    def chassis_name(self) -> str:
+        return self._metadata.chassis_name
+    
+    @chassis_name.setter
+    def chassis_name(self, v: str) -> None:
+        self._metadata.chassis_name = v
+    
+    @property
+    def chassis_sn(self) -> str:
+        return self._metadata.chassis_sn
+    
+    @chassis_sn.setter
+    def chassis_sn(self, v: str) -> None:
+        self._metadata.chassis_sn = v
+
+    @property
+    def chassis_version_str(self) -> str:
+        return self._metadata.chassis_version_str
+    
+    @chassis_version_str.setter
+    def chassis_version_str(self, v: str) -> None:
+        self._metadata.chassis_version_str = v
+
+    @property
+    def module_name(self) -> str:
+        return self._metadata.module_name
+
+    @module_name.setter
+    def module_name(self, v: str) -> None:
+        self._metadata.module_name = v
+
+    @property
+    def module_model(self) -> str:
+        return self._metadata.module_model
+    
+    @module_model.setter
+    def module_model(self, v: str) -> None:
+        self._metadata.module_model = v
+
+    @property
+    def module_sn(self) -> str:
+        return self._metadata.module_sn
+    
+    @module_sn.setter
+    def module_sn(self, v: str) -> None:
+        self._metadata.module_sn = v
+
+    @property
+    def module_version_str(self) -> str:
+        return self._metadata.module_version_str
+    
+    @module_version_str.setter
+    def module_version_str(self, v: str) -> None:
+        self._metadata.module_version_str = v
+
+    @property
+    def module_revision(self) -> str:
+        return self._metadata.module_revision
+
+    @module_revision.setter
+    def module_revision(self, v: str) -> None:
+        self._metadata.module_revision = v
+
+    @property
+    def module_id(self) -> str:
+        if isinstance(self._metadata, ModuleConfigMetadata):
+            return self._metadata.module_id
+        return ""
+    
+    @module_id.setter
+    def module_id(self, v: str) -> None:
+        if isinstance(self._metadata, ModuleConfigMetadata):
+            self._metadata.module_id = v
+        else:
+            raise AttributeError("module_id is only available for ModuleConfigMetadata")
+
+    @property
+    def port_id(self) -> str:
+        if isinstance(self._metadata, PortConfigMetadata):
+            return self._metadata.port_id
+        return ""
+    
+    @port_id.setter
+    def port_id(self, v: str) -> None:
+        if isinstance(self._metadata, PortConfigMetadata):
+            self._metadata.port_id = v
+        else:
+            raise AttributeError("port_id is only available for PortConfigMetadata")
+
+    @property
+    def metadata(self) -> Union[TestCaseMetadata, PortConfigMetadata, ModuleConfigMetadata]:
+        return self._metadata
+
+    @property
+    def commands(self) -> List[str]:
+        return self._commands
+
+    @commands.setter
+    def commands(self, v: str) -> None:
+        # Remove the <SYNC> tag
+        v = v.replace('<SYNC>', '')
+
+        if self.type == ConfigMetadataType.PORT:
+            v = v.replace(f"{self.port_id}  ", '')
+            v = f"P_RESET\n" + v
+
+        if self.type == ConfigMetadataType.MODULE:
+            v = v.replace(f"{self.module_id}  ", '')
+
+        self._commands = v.splitlines()
+
+# Determine type of config block
+def config_block_type(config_block_str: str) -> ConfigMetadataType:
+    line_list = config_block_str.splitlines()
+    if line_list[0].startswith(f";{ConfigMetadataType.MODULE.value}"):
+        return ConfigMetadataType.MODULE
+    elif line_list[0].startswith(f";{ConfigMetadataType.PORT.value}"):
+        return ConfigMetadataType.PORT
+    elif line_list[0].startswith(f";{ConfigMetadataType.TESTCASE.value}"):
+        return ConfigMetadataType.TESTCASE
+    else:
+        return ConfigMetadataType.DEFAULT

xoa_driver/functions/cli/_socket_driver.py

@@ -0,0 +1,111 @@
+import socket
+import time
+import logging
+from typing import Optional, Callable, Union, List, Dict, Any
+
+class ServerUnavaliable(Exception):
+	pass
+
+class SimpleSocket(object):
+	def __init__(self, hostname: str, port: int = 22611, timeout: int = 20) -> None:
+		self.server_addr = (hostname, port)
+		self.is_connected = False
+		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		self.sock.settimeout(timeout)
+		self.retry_connect = 3
+		self._connect()
+
+	def __del__(self) -> None:
+		self.sock.close()
+	
+	def _connect(self):
+		try:
+			if hasattr(self, "sock"):
+				connid = 1
+				err = self.sock.connect_ex(self.server_addr)
+				if err == 0:
+					self.retry_connect = 3
+					self.is_connected = True
+				else:
+					self.reconnect()
+
+		except socket.error as msg:
+			logging.error(f"[Socket connection error in <_connect>] Cannot connect to { self.server_addr[0] }, error: {msg}\n")
+			self.reconnect()
+
+	def reconnect(self):
+		time.sleep(5)
+		self.retry_connect -= 1
+		if self.retry_connect > 0:
+			self._connect()
+		else:
+			raise ServerUnavaliable(f'Cannot connect to <{ self.server_addr[0] }>, host is unavailable')
+
+	def close(self):
+		if hasattr(self, "sock"):
+			self.sock.close()
+			
+	# Send a string command to a socket
+	def send_only(self, cmd: str):
+		"""Send command string to server"""
+		if hasattr(self, "sock") and self.is_connected:
+			sent = self.sock.send((cmd + '\n').encode('utf-8'))
+			if sent == 0:
+				raise RuntimeError("Socket connection broken in <send_command>")
+
+	# Send a string command to a socket and return a string response from the socket
+	def send_and_response(self, cmd: str, sync_on: bool) -> str:
+		"""Send a command string to server and return the response"""
+		if hasattr(self, "sock") and self.is_connected:
+			try:
+				sent = self.sock.send((cmd + '\n').encode('utf-8'))
+				if sent == 0:
+					raise RuntimeError("Socket connection broken in <ask>")
+				if sync_on:
+					terminator = b'<SYNC>\n'
+					buffer = b''
+					while True:
+							chunk = self.sock.recv(4096)
+							if not chunk:
+									continue
+							buffer += chunk
+							if buffer.endswith(terminator):
+									break
+					return buffer.decode('utf-8')
+				else:
+					chunk = self.sock.recv(4096)
+					while not chunk:
+						chunk = self.sock.recv(4096)
+					return chunk.decode('utf-8')
+			except socket.error as msg:
+				logging.error(f"[Socket connection error in <ask>] { msg }")
+				return ''
+		return ''
+	
+
+	# Send a long string data to the socket and return a long string of response from the socket
+	def send_and_response_multiple(self, cmd:str, num:int) -> str:
+		"""Send a number of commands to server and return the responses"""
+		if hasattr(self, "sock") and self.is_connected:
+			try:
+				self.sock.sendall((cmd).encode('utf-8'))
+				chunk = self.sock.recv(4096)
+				while not chunk:
+					chunk = self.sock.recv(4096)
+				data = chunk.decode('utf-8')
+				while True:
+					if data.count('\n') < num:
+						data2 = self.sock.recv(4096).decode('utf-8')
+						if data2:
+							data = data + data2
+					else:
+						break
+				return data
+			except socket.error as msg:
+				logging.error(f"[Socket connection error in <ask_multi>] { msg }")
+				return ''
+		return ''
+	
+	def set_keepalives(self):
+		if hasattr(self, "sock") and self.is_connected:
+			self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 2)

xoa_driver/functions/cli/port_config.py

@@ -0,0 +1,116 @@
+import asyncio
+from xoa_driver import testers, ports
+from typing import List, Tuple
+from ._cli_manager import XOACLIManager
+from ._config_block import *
+
+async def save_port_config(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> str:
+    """Save port config to the specified filepath
+
+    :param tester: Chassis object
+    :type tester: testers.L23Tester
+    :param port: Port object to save configuration from
+    :type port: ports.GenericL23Port
+    :param save_path: File path to save the port configuration
+    :type save_path: str
+    :return: Port configuration string
+    :rtype: str
+    """
+    
+    tester_ip = tester.info.host
+    resp = await tester.password.get()
+    tester_password = resp.password
+    port_index = f"{port.kind.module_id}/{port.kind.port_id}"
+    module = tester.modules.obtain(port.kind.module_id)
+    
+    # Connect to the tester on tcp port 22611
+    xm = XOACLIManager(host=tester_ip, debug=debug, halt_on_error=halt_on_error)
+
+    # Log on and set username
+    xm.logon_set_owner(tester_password)
+
+    # Get full port configuration
+    raw_resp = xm.get_port_full_config_raw(port_index)
+
+    # Create config block
+    port_config_block = ConfigBlock()
+    # Fill in metadata
+    port_config_block.type = ConfigMetadataType.PORT
+    port_config_block.chassis_name = tester.info.name
+    port_config_block.chassis_sn = str(tester.info.serial_number)
+    port_config_block.chassis_version_str = tester.info.version_string
+    port_config_block.module_name = module.info.model_name
+    port_config_block.module_model = module.info.model
+    port_config_block.module_sn = module.info.serial_number
+    port_config_block.module_version_str = module.info.version_string
+    port_config_block.module_revision = module.info.revision
+    port_config_block.port_id = port_index
+    port_config_block.commands = raw_resp[0]
+
+    # Save configuration to file
+    result = port_config_block.config_block_str
+    with open(path, 'w+') as xpcfile:
+        xpcfile.write(result)
+    return result
+
+async def load_port_config(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
+    """Load port config from the specified filepath
+
+    :param tester: Chassis object
+    :type tester: testers.L23Tester
+    :param port: Port object to load configuration to
+    :type port: ports.GenericL23Port
+    :param load_path: File path to load the port configuration from
+    :type load_path: str
+    :return: List of tuples containing response and the corresponding command sent
+    :rtype: List[Tuple[str, str]]
+    """
+    
+    tester_ip = tester.info.host
+    resp = await tester.password.get()
+    tester_password = resp.password
+    port_index = f"{port.kind.module_id}/{port.kind.port_id}"
+    
+    # Connect to the tester on tcp port 22611
+    xm = XOACLIManager(host=tester_ip, debug=debug, halt_on_error=halt_on_error)
+
+    # Log on and set username
+    xm.logon_set_owner(tester_password)
+
+    # Reserve the port before applying configuration
+    xm.reserve_port(port_index)
+
+    result: List[Tuple[str, str]] = []
+
+    # Read configuration from file
+    with open(path, 'r', encoding='utf-8') as xpcfile:
+        config_data = xpcfile.read()
+
+    # Deserialize config block and send CLI commands
+    config_block = ConfigBlock()
+    config_block.config_block_str = config_data
+    cli_cmds = config_block.commands
+    for cmd in cli_cmds:
+        if cmd.strip():  # Ensure the command is not empty
+            resp = xm.send(cmd=f"{port_index} {cmd}", sync_on=False)
+            result.append((resp, f"{port_index} {cmd}"))
+
+    # Free the port after applying configuration
+    xm.free_port(port_index)
+    return result
+
+async def port_config_from_file(tester: testers.L23Tester, port: ports.GenericL23Port, path: str, debug=False, halt_on_error=False) -> List[Tuple[str, str]]:
+    """Load port configuration from the specifiied filepath. This function is a wrapper around load_port_config to provide backward compatibility.
+
+    :param tester: Chassis object
+    :type tester: testers.L23Tester
+    :param port: Port object to load configuration to
+    :type port: ports.GenericL23Port
+    :param load_path: File path to load the port configuration from
+    :type load_path: str
+    :return: List of tuples containing response and command sent
+    :rtype: List[Tuple[str, str]]
+    """
+    return await load_port_config(tester, port, path, debug=debug, halt_on_error=halt_on_error)
+
+