datacomshell 0.1.2__tar.gz → 0.26.5__tar.gz

{datacomshell-0.1.2 → datacomshell-0.26.5}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.3
 Name: datacomshell
-Version: 0.1.2
+Version: 0.26.5
 Summary: Add your description here
 Author: Saven
 Author-email: Saven <2416844857@qq.com>
+Requires-Dist: aiofiles>=25.1.0
 Requires-Dist: telnetlib3>=4.0.2
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown

{datacomshell-0.1.2 → datacomshell-0.26.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datacomshell"
-version = "0.1.2"
+version = "0.26.5"
 description = "Add your description here"
 authors = [
     { name = "Saven", email = "2416844857@qq.com" },
@@ -8,6 +8,7 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.14"
 dependencies = [
+    "aiofiles>=25.1.0",
     "telnetlib3>=4.0.2",
 ]
 

datacomshell-0.26.5/src/datacomshell/AsyncTelnetClientUtil.py

@@ -0,0 +1,259 @@
+from typing import Optional, Union, Tuple, cast
+from datacomshell.Auth import Auth, AuthState, UsernamePasswordAuth
+from telnetlib3 import TelnetReader, TelnetReaderUnicode, TelnetWriter, TelnetWriterUnicode, open_connection
+from datetime import datetime
+import asyncio
+import aiofiles
+from aiofiles.threadpool.text import AsyncTextIOWrapper
+import pathlib
+
+import re
+
+_DEFAULT_ENDING = '[saven-process-end]'
+# 默认认证（无认证）
+_DEFAILT_AUTH_OBG = Auth()
+
+# type
+_READER_TYPE = Union[TelnetReader, TelnetReaderUnicode]
+_WRITER_TYPE = Union[TelnetWriter, TelnetWriterUnicode]
+
+_DEFAULT_WAIT_INPUT_TAG_PARTTEN_LIST = [
+    re.compile(r'\<.*\>'),
+    re.compile(r'\[.*\]'),
+]
+
+
+# __reader、__writer等操作对象为 null
+class OperationObjNullError(RuntimeError):
+    def __init__(self, message: str) -> None: return super().__init__(message)
+
+
+class ConnectParamError(RuntimeError):
+    def __init__(self, message: str) -> None: return super().__init__(message)
+
+
+class LoginTimoutError(RuntimeError):
+    def __init__(self, message: str) -> None: return super().__init__(message)
+
+
+class LoginTypeError(RuntimeError):
+    def __init__(self, message: str) -> None: return super().__init__(message)
+
+
+class ExcCommandTimoutError(RuntimeError):
+    def __init__(self, message: str) -> None: return super().__init__(message)
+
+
+class AsyncTelnetClientUtil(object):
+    """
+    AsyncTelnetClientUtil
+    """
+
+    def __init__(self,
+                 host: str = '127.0.0.1',
+                 port: int = 23,
+                 auth: Auth = _DEFAILT_AUTH_OBG,
+                 connect_timeout: float = 10.0,
+                 login_timeout: float = 10.0,
+                 exc_command_timeout: float = 10.0,
+                 log_folder_path: Optional[str] = None,
+                 log_new_second: float = 1800,
+                 wait_input_tag_partten_list: list[re.Pattern] = _DEFAULT_WAIT_INPUT_TAG_PARTTEN_LIST,
+                 ) -> None:
+        self.__host: str = host
+        self.__port: int = port
+        self.__connect_timeout: float = connect_timeout
+        self.__login_timeout: float = login_timeout
+        self.__exc_command_timout: float = exc_command_timeout
+
+        self.__auth: Auth = auth
+        self.__auth_type: AuthState = self.__auth.get_auth_type()
+
+        self.__reader: _READER_TYPE | None = None
+        self.__writer: _WRITER_TYPE | None = None
+
+        self.__log_folder_path: str | None = log_folder_path
+        self.__log_new_second: float = log_new_second
+        self.__timestemp: float = datetime.now().timestamp()
+        self.__log_file: AsyncTextIOWrapper | None = None
+
+        self.__is_log = True if log_folder_path != None else False
+
+        if self.__is_log and self.__log_folder_path != None:
+            pathlib.Path(self.__log_folder_path).mkdir(
+                parents=True, exist_ok=True)
+
+    async def __initConnect(self) -> None:
+        if self.__auth_type == AuthState.NONE_AUTH:
+            res = await self.__none_auth()
+            self.__reader = res[0]
+            self.__writer = res[1]
+        elif self.__auth_type == AuthState.USERNAME_PASSWORD_AUTH:
+            res = await self.__username_password_auth()
+            self.__reader = res[0]
+            self.__writer = res[1]
+        else:
+            raise LoginTypeError("Auth type error")
+
+    @classmethod
+    async def create(cls,
+                     host: str = '127.0.0.1',
+                     port: int = 23,
+                     auth: Auth = _DEFAILT_AUTH_OBG,
+                     connect_timeout: float = 10.0,
+                     login_timeout: float = 10.0,
+                     exc_command_timeout: float = 10.0,
+                     log_folder_path: Optional[str] = None,
+                     log_new_second: float = 1800,
+                     wait_input_tag_partten_list: list[re.Pattern] = _DEFAULT_WAIT_INPUT_TAG_PARTTEN_LIST,) -> 'AsyncTelnetClientUtil':
+
+        instance: AsyncTelnetClientUtil = cls(
+            host=host,
+            port=port,
+            auth=auth,
+            connect_timeout=connect_timeout,
+            login_timeout=login_timeout,
+            exc_command_timeout=exc_command_timeout,
+            log_folder_path=log_folder_path,
+            log_new_second=log_new_second,
+            wait_input_tag_partten_list=wait_input_tag_partten_list,
+        )
+
+        await instance.__initConnect()
+        await instance.__create_log_file()
+        print(f"""
+              [I] connect success: {instance.__host}:{instance.__port}
+              [I] login type: {instance.__auth.get_auth_type().name}
+              [I] login info: {instance.__auth.to_string()}
+              """)
+        return instance
+
+    def __command_wrapper(self, command: str) -> str:
+        return command + '\r\n'
+
+    async def __read_wait_wrapper(self, read) -> bytes:
+        return await asyncio.wait_for(read, timeout=self.__exc_command_timout)
+
+    async def __read_login_wait_wrapper(self, read):
+        return await asyncio.wait_for(read, timeout=self.__login_timeout)
+
+    async def __none_auth(self) -> Tuple[TelnetReader, TelnetWriter]:
+        return await open_connection(self.__host, self.__port, connect_timeout=self.__connect_timeout)
+
+    async def __login_of_username_password(self, reader: _READER_TYPE, writer: _WRITER_TYPE) -> None:
+        if reader == None and writer == None:
+            raise OperationObjNullError("[IE]: __reader and __writer is None")
+
+        if self.__auth_type != AuthState.USERNAME_PASSWORD_AUTH:
+            raise ConnectParamError(
+                "[IE] __auth_type is not AuthState.USERNAME_PASSWORD_AUTH")
+
+        # 变量类型整理
+        _reader = reader
+        _writer = cast(TelnetWriterUnicode, writer)
+        _auth = cast(UsernamePasswordAuth, self.__auth)
+
+        buffer = ''
+        try:
+            res: bytes = b''
+            res: bytes = await self.__read_login_wait_wrapper(_reader.readuntil(b'Username:'))
+            buffer = buffer + res.decode()
+            _writer.write(self.__command_wrapper(_auth.get_username()))
+            await _writer.drain()
+
+            res: bytes = b''
+            res: bytes = await self.__read_login_wait_wrapper(_reader.readuntil(b'Password:'))
+            buffer = buffer + res.decode()
+            _writer.write(self.__command_wrapper(_auth.get_password()))
+            await _writer.drain()
+
+            res: bytes = b''
+            res: bytes = await self.__read_login_wait_wrapper(_reader.readuntil(b'>'))
+            buffer = buffer + res.decode()
+
+            # Log
+            await self.__log(buffer)
+        except asyncio.TimeoutError:
+            raise LoginTimoutError('Login timeout')
+
+    async def __username_password_auth(self) -> Tuple[TelnetReader, TelnetWriter]:
+        reader, writer = await open_connection(self.__host, self.__port, connect_timeout=self.__connect_timeout)
+
+        # 登录
+        await self.__login_of_username_password(reader, writer)
+        return reader, writer
+
+    async def __close_log_file(self):
+        if self.__log_file != None:
+            await self.__log_file.close()
+
+    async def __create_log_file(self):
+        await self.__close_log_file()
+        filename = datetime.now().strftime('%Y-%m-%d_%H-%M-%S-%f') + '.log'
+
+        if self.__log_folder_path == None:
+            raise RuntimeError('[IE] log_folder_path error')
+
+        self.__timestemp = datetime.now().timestamp()
+        en_path = self.__log_folder_path + '/' + filename
+        self.__log_file = await aiofiles.open(en_path, 'a', encoding='utf-8')
+
+        await self.__log_file.write(f'================ {filename} ================')
+
+    async def __log(self, message: str):
+        if self.__is_log != True:
+            return
+
+        curren_timestemp: float = datetime.now().timestamp()
+        diff = curren_timestemp - self.__timestemp
+
+        # 新建
+        if diff > self.__log_new_second:
+            await self.__create_log_file()
+
+        # 记录
+        if self.__log_file == None:
+            raise RuntimeError('[IE] log_file is None')
+        else:
+            await self.__log_file.write(message)
+
+    async def execute(self, command: str) -> bytes:
+        if self.__reader == None and self.__writer == None:
+            raise OperationObjNullError("[IE]: __reader and __writer is None")
+
+        # 变量类型整理
+        _reader = cast(_READER_TYPE, self.__reader)
+        _writer = cast(TelnetWriterUnicode, self.__writer)
+
+        _writer.write('\r\n')
+        _writer.write(self.__command_wrapper(command))
+        _writer.write(_DEFAULT_ENDING)
+        await _writer.drain()
+
+        res = b'null'
+        try:
+            res = await self.__read_wait_wrapper(_reader.readuntil(_DEFAULT_ENDING.encode('utf-8')))
+            await self.__log(res.decode())
+        except asyncio.TimeoutError as e:
+            print("[I] reader buffer empty")
+
+        return res
+
+    async def execute_no_back(self, command: str) -> None:
+        await self.execute(command)
+
+    async def close(self) -> None:
+        if self.__reader == None and self.__writer == None:
+            raise OperationObjNullError("[IE]: __reader and __writer is None")
+
+        # 变量类型整理
+        _reader = cast(_READER_TYPE, self.__reader)
+        _writer = cast(TelnetWriterUnicode, self.__writer)
+
+        if self.__log_file != None:
+            await self.__log_file.close()
+
+        _reader.close()
+        _writer.close()
+
+        await _writer.wait_closed()

datacomshell-0.26.5/src/datacomshell/Auth.py

@@ -0,0 +1,46 @@
+from enum import Enum
+
+
+class AuthState(Enum):
+    NONE_AUTH = 0
+    USERNAME_PASSWORD_AUTH = 1
+    SECRET_AUTH = 2
+
+
+class Auth(object):
+    def __init__(self, auth: AuthState = AuthState.NONE_AUTH) -> None:
+        self.__type = auth
+
+    def get_auth_type(self) -> AuthState:
+        return self.__type
+
+    def to_string(self) -> str:
+        return 'NONE'
+
+
+class UsernamePasswordAuth(Auth):
+    def __init__(self, username: str, password: str) -> None:
+        super().__init__(auth=AuthState.USERNAME_PASSWORD_AUTH)
+        self.__username = username
+        self.__password = password
+
+    def get_username(self) -> str:
+        return self.__username
+
+    def get_password(self) -> str:
+        return self.__password
+
+    def to_string(self) -> str:
+        return f'{self.__username}&{self.__password}'
+
+
+class SecretAuth(Auth):
+    def __init__(self, secret: str) -> None:
+        super().__init__(auth=AuthState.SECRET_AUTH)
+        self.__secret = secret
+
+    def get_secret(self) -> str:
+        return self.__secret
+
+    def to_string(self) -> str:
+        return self.__secret

datacomshell-0.1.2/src/datacomshell/AsyncTelnetUtil.py

@@ -1,175 +0,0 @@
-import asyncio
-import re
-from typing import Optional
-import telnetlib3
-from telnetlib3 import TelnetWriter, TelnetReader, TelnetWriterUnicode, TelnetReaderUnicode
-
-
-class ConnectError(RuntimeError):
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-    pass
-
-
-class LoginError(RuntimeError):
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-    pass
-
-
-_CONST_COMMAND_RUNNED_PATTERN = re.compile(
-    r'<.*>|\[.*\]|<~.*>|\[~.*\]|<\*.*>|\[\*.*\]')
-_CONST_COMMAND_RUNNED_PATTERN_LIST = [_CONST_COMMAND_RUNNED_PATTERN]
-
-_CONST_COMMAND_ERROR_PATTERN = re.compile(r'%.*')
-_CONST_COMMAND_ERROR_PATTERN_LIST = [_CONST_COMMAND_ERROR_PATTERN]
-
-
-class AsyncTelnetUtil(object):
-    def __init__(self,
-                 host: str,
-                 username: str,
-                 password: str,
-                 port: int = 23,
-                 connect_timeout: Optional[float] = None
-                 ) -> None:
-        # 连接基本信息
-        self.__host = host
-        self.__port = port
-        self.__connect_timeout = connect_timeout
-
-        self.__username = username
-        self.__password = password
-
-        self.__login_status = False
-        self.__reader: TelnetReader | TelnetReaderUnicode | None = None
-        self.__writer: TelnetWriter | TelnetWriterUnicode | None = None
-
-        # 默认命令执行匹配
-        self.__DEFAULT_CONST_COMMAND_RUNNED_PATTERN_LIST = [
-            _CONST_COMMAND_RUNNED_PATTERN]
-
-        self.__DEFAULT_CONST_COMMAND_ERROR_PATTERN_LIST = [
-            _CONST_COMMAND_ERROR_PATTERN]
-
-    def __successfulMatch(self, pattern_list: Optional[list[re.Pattern]] = None, buffer: str = '') -> bool:
-        if pattern_list is not None:
-            for pattern in pattern_list:
-                if re.search(pattern=pattern, string=buffer) is not None:
-                    return True
-        else:
-            for pattern in self.__DEFAULT_CONST_COMMAND_RUNNED_PATTERN_LIST:
-                if re.search(pattern=pattern, string=buffer) is not None:
-                    return True
-
-        return False
-
-    def __errorMatch(self, error_pattern_list: Optional[list[re.Pattern]] = None, buffer: str = '') -> bool:
-        if error_pattern_list is not None:
-            for pattern in error_pattern_list:
-                if re.search(pattern=pattern, string=buffer) is not None:
-                    return True
-        else:
-            for pattern in self.__DEFAULT_CONST_COMMAND_ERROR_PATTERN_LIST:
-                if re.search(pattern=pattern, string=buffer) is not None:
-                    return True
-
-        return False
-
-    # 读取命令返回数据
-    async def __read(self,
-                     pattern_list: Optional[list[re.Pattern]] = None,
-                     error_pattern_list: Optional[list[re.Pattern]] = None,
-                     timeout: Optional[float] = 10.0,
-                     size: int = 1024
-                     ) -> str | None:
-        buffer = ''
-        runStatus = True
-
-        if self.__reader is None or self.__writer is None:
-            raise ConnectError("Not connected to device")
-
-        while runStatus:
-            try:
-                res = await asyncio.wait_for(self.__reader.read(size), timeout)
-            except asyncio.TimeoutError:
-                break
-
-            if not res:
-                break
-
-            if res is bytes:
-                buffer += res.decode('utf-8')
-            elif res is str:
-                buffer += res
-
-            __temp_match_status = False
-            if not __temp_match_status:
-                __temp_match_status = self.__successfulMatch(
-                    pattern_list=pattern_list, buffer=buffer)
-
-            if not __temp_match_status:
-                __temp_match_status = self.__errorMatch(
-                    error_pattern_list=error_pattern_list, buffer=buffer)
-
-            if __temp_match_status:
-                runStatus = False
-
-        return buffer if runStatus else None
-
-    # 写入命令
-    def __write(self, command: str) -> None:
-        if self.__writer is None:
-            raise ConnectError("Not connected to device")
-
-        in_command = command + "\r\n"
-
-        # 根据 writer 类型决定使用字符串还是字节
-        if isinstance(self.__writer, TelnetWriterUnicode):
-            self.__writer.write(in_command)
-        else:
-            self.__writer.write(in_command.encode('utf-8'))
-
-    # 建立连接
-    async def connect(self) -> None:
-        try:
-            self.__reader, self.__writer = await telnetlib3.open_connection(
-                host=self.__host, port=self.__port, connect_timeout=self.__connect_timeout)
-        except asyncio.TimeoutError:
-            raise TimeoutError(
-                f"Connection to {self.__host}:{self.__port} timed out after {self.__connect_timeout} seconds")
-
-        if self.__reader is None or self.__writer is None:
-            raise ConnectionError("Failed to connect to device")
-
-        return
-
-    # 建立登录
-    async def login(self) -> None:
-        if self.__login_status:
-            return
-
-        if await self.__read(pattern_list=[re.compile(r"Username:")]) is not None:
-            self.__write(self.__username)
-        else:
-            raise LoginError("Failed to connect to device")
-
-        if await self.__read(pattern_list=[re.compile(r"Password:")]) is not None:
-            self.__write(self.__password)
-        else:
-            raise LoginError("Failed to connect to device")
-
-        if await self.__read(pattern_list=self.__DEFAULT_CONST_COMMAND_RUNNED_PATTERN_LIST) is not None:
-            self.__login_status = True
-            return
-
-    async def send_command(self, command: str):
-        self.__write(command)
-        return await self.__read()
-
-    def only_send_command(self, command: str) -> None:
-        self.__write(command)
-
-    async def build(self) -> None:
-        await self.connect()
-        await self.login()

datacomshell-0.1.2/src/datacomshell/TelnetShellClient.py

@@ -1,3 +0,0 @@
-
-class TelnetShellClient(object):
-    pass

datacomshell-0.1.2/src/datacomshell/TelnetShellServer.py

@@ -1,39 +0,0 @@
-import uuid
-
-__EMPTY_SYNC_PIPELINE_INDEX = -1
-
-
-class Command(object):
-    def __init__(self, command_str: str) -> None:
-        self.__command_id = None
-        self.__command_str = command_str
-        self.__command_has_result = True
-        self.__command_result = None
-
-
-class TelnetShellServer(object):
-    """
-    Telnet shell server.
-    """
-
-    def __init__(self) -> None:
-
-        self.__sync_command_pipeline = []
-        self.__async_command_pipeline = []
-        self.__command_runned_result_dict = {}
-
-        self.__sync_current_command_index = __EMPTY_SYNC_PIPELINE_INDEX
-
-        self.__connect_pool = []
-
-    def __check_reset_result_dict_count(self) -> bool:
-        if self.__command_runned_result_dict.__len__() > 1000:
-            self.__command_runned_result_dict.clear()
-            return True
-        return False
-
-    def gen_command_process_id(self) -> uuid.UUID:
-        return uuid.uuid4()
-
-    def sync_push(self, command: Command) -> None:
-        self.__sync_command_pipeline.insert(0, command)