pytest-testkit 1.0.2a2__tar.gz → 1.0.2b1__tar.gz

{pytest_testkit-1.0.2a2/pytest_testkit.egg-info → pytest_testkit-1.0.2b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest_testkit
-Version: 1.0.2a2
+Version: 1.0.2b1
 Summary: Pytest plugin for Infra logging framework and environment management
 Author: Huawei
 License: MIT License

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytest_testkit"
-version = "1.0.2a2"
+version = "1.0.2b1"
 description = "Pytest plugin for Infra logging framework and environment management"
 readme = "README.md"
 license = { file = "LICENSE" }

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1}/pytest_testkit/lib/base/ssh.py

@@ -69,6 +69,8 @@ class Ssh:
 
         self.recv_timeout = False  # 上一次recv操作是否超时
         self.send_only = False  # 是否发送过sendonly命令
+        self.login_echo = ""  # 首次交互 channel 登录时的 banner 回显
+        self.last_prompt = ""  # 最近一次从输出中识别到的 shell 提示符
         self.client = None
         self.jump_client = None
         self.target_client = None
@@ -169,7 +171,30 @@ class Ssh:
         return "\n".join(cleaned_lines)
 
     @staticmethod
-    def _clean_interactive_output(raw_output: str, cmd: str) -> str:
+    def _extract_last_prompt(raw_output: str) -> str:
+        """从交互输出中提取最后一次出现的 shell 提示符。
+
+        用于在日志中还原真实终端效果: 发送命令时带上下文提示符。
+
+        Args:
+            raw_output: 原始的终端输出(已去除 ANSI)
+
+        Returns:
+            str: 识别到的提示符, 未识别返回空串
+        """
+        prompt_regex = re.compile(
+            r"^\s*((?:\([^)]+\)\s*)*(?:\[.+@.+\s+.+\]|[^@\s]+@[^:\s]+:[^\s]*|"
+            r"bash-[0-9.]+|sh-[0-9.]+)[#$]|[$#%>])\s*$",
+            re.MULTILINE,
+        )
+        last = ""
+        for line in raw_output.splitlines():
+            m = prompt_regex.match(line)
+            if m:
+                last = m.group(1)
+        return last
+
+    def _clean_interactive_output(self, raw_output: str, cmd: str) -> str:
         """清理交互式命令输出中的多余信息。
 
         Args:
@@ -182,6 +207,11 @@ class Ssh:
         # Step 1: 移除 ANSI 转义序列
         output = Ssh._remove_ansi_escapes(raw_output)
 
+        # 记录输出中最后一次出现的提示符, 供日志还原终端上下文
+        prompt = Ssh._extract_last_prompt(output)
+        if prompt:
+            self.last_prompt = prompt
+
         # Step 2: 移除命令回显
         output = Ssh.remove_command_echo(output, cmd)
 
@@ -213,7 +243,6 @@ class Ssh:
             )
             return False
 
-        self.logger.info("[Ssh.login] Starting login to target ip")
         try:
             self.target_client = paramiko.SSHClient()
             self.target_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
@@ -227,7 +256,6 @@ class Ssh:
                 timeout=10,
             )
             self.target_client.get_transport().set_keepalive(keepalive)
-            self.logger.info("[Ssh.login] connect to target ip success")
         except Exception as e:
             self.logger.error(
                 f"[Ssh.login] target exception details: {traceback.format_exc()}"
@@ -251,8 +279,6 @@ class Ssh:
         self.logger.debug(
             f"[Ssh._jump_exec_command] executed: {cmd}, exit_code={exit_code}"
         )
-        if exit_code != 0:
-            self.logger.warning(f"[Ssh._jump_exec_command] error: {stderr_content}")
         if exit_code == 0:
             success = True
         elif param.ignore_err:
@@ -309,6 +335,90 @@ class Ssh:
             return self._jump_exec_command(param)
         return self._build_result(False, "No client", "", param.only_stdout)
 
+    def _drain_login_banner(self, channel):
+        """首次创建交互 channel 后发送一个空命令, 吸收登录 banner/欢迎信息。
+
+        发送的空命令不打印日志; 收到的回显保存到 self.login_echo,
+        可作为 login 的回显查看。这样后续真正执行的命令输出不受 banner 干扰。
+
+        Args:
+            channel: 交互式 shell channel
+
+        Returns:
+            str: 吸收到的登录 banner + 空命令回显
+        """
+        banner = b""
+        # 先等一小段时间让 banner 输出
+        banner_start = time.time()
+        while time.time() - banner_start < 2:
+            if channel.recv_ready():
+                while channel.recv_ready():
+                    chunk = channel.recv(4096)
+                    if not chunk:
+                        break
+                    banner += chunk
+            else:
+                time.sleep(0.05)
+            # 已经能看到提示符就不再等满 2 秒
+            if self._build_prompt_regex().search(
+                banner.decode("utf-8", errors="replace")
+            ):
+                break
+
+        # 发送空命令(单个换行), 触发一次新提示符
+        channel.send("\n")
+        # 注意: 只检查 send 之后的增量数据, 而非累计 banner。
+        # 阶段1 的宽松正则可能被 banner 里的伪提示符($ % > 结尾行)误匹配,
+        # 若此处仍检查累计 banner, 会立即 break 而等不到真实新提示符,
+        # 导致 last_prompt 为空、第一条 sendcmd 日志无提示符前缀
+        echo_new = b""
+        echo_start = time.time()
+        while time.time() - echo_start < 3:
+            if channel.recv_ready():
+                while channel.recv_ready():
+                    chunk = channel.recv(4096)
+                    if not chunk:
+                        break
+                    banner += chunk
+                    echo_new += chunk
+            else:
+                time.sleep(0.05)
+            if echo_new and self._build_prompt_regex().search(
+                echo_new.decode("utf-8", errors="replace")
+            ):
+                break
+
+        self.login_echo = banner.decode("utf-8", errors="replace")
+        # banner 末尾的提示符同时记录到 last_prompt,
+        # 使第一条 sendcmd 日志即带提示符前缀
+        prompt = self._extract_last_prompt(self._remove_ansi_escapes(self.login_echo))
+        if prompt:
+            self.last_prompt = prompt
+        return self.login_echo
+
+    def prepare_interactive_channel(self):
+        """预创建交互 shell channel 并吸收登录 banner。
+
+        在登录后立即调用, 使 banner 回显(login_echo)在第一条命令之前就绪。
+        幂等: channel 已存在时不做任何事。
+
+        Returns:
+            str: 吸收到的 banner 回显 (存入 self.login_echo)
+        """
+        if self.client:
+            if not self.channel or not self.channel.active:
+                self.channel = self.client.invoke_shell()
+                self.channel.resize_pty(width=1000, height=5000)
+                self._drain_login_banner(self.channel)
+            return self.login_echo
+        if self.target_client:
+            if not self.target_channel or not self.target_channel.active:
+                self.target_channel = self.target_client.invoke_shell()
+                self.target_channel.resize_pty(width=1000, height=5000)
+                self._drain_login_banner(self.target_channel)
+            return self.login_echo
+        return ""
+
     def ssh_cmd_interactive(self, param: SshCmdInteractiveParam):
         """Execute interactive command on SSH server.
 
@@ -329,11 +439,13 @@ class Ssh:
             if not self.channel or not self.channel.active:
                 self.channel = self.client.invoke_shell()
                 self.channel.resize_pty(width=1000, height=5000)
+                self._drain_login_banner(self.channel)
             return self._direct_exec_cmd_interactive(param)
         if self.target_client:
             if not self.target_channel or not self.target_channel.active:
                 self.target_channel = self.target_client.invoke_shell()
                 self.target_channel.resize_pty(width=1000, height=5000)
+                self._drain_login_banner(self.target_channel)
             return self._jump_exec_cmd_interactive(param)
         return self._build_result(False, "No client", "", param.only_stdout)
 
@@ -465,12 +577,10 @@ class Ssh:
         self.client = paramiko.SSHClient()
         self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         try:
-            self.logger.info("[Ssh.login] Starting login process...")
             self.client.connect(
                 self.target_ip, self.target_port, self.target_user, self.target_pwd
             )
             self.client.get_transport().set_keepalive(keepalive)
-            self.logger.info("[Ssh.login] Finish connect()...")
             return True
         except Exception as e:
             self.logger.error(
@@ -511,8 +621,6 @@ class Ssh:
         self.logger.debug(
             f"[Ssh._direct_exec_cmd] executed: {cmd}, exit_code={exit_code}"
         )
-        if exit_code != 0:
-            self.logger.warning(f"[Ssh._direct_exec_cmd] error: {stderr_content}")
         if exit_code == 0:
             success = True
         elif param.ignore_err:
@@ -531,9 +639,6 @@ class Ssh:
         try:
             with SCPClient(self.client.get_transport()) as scp:
                 scp.put(local_path, remote_path, recursive=True)
-            self.logger.info(
-                f"[Ssh._direct_put_file] Uploaded {local_path} to {remote_path} via SCP"
-            )
             return True
         except Exception as e:
             self.logger.error(
@@ -545,10 +650,6 @@ class Ssh:
         try:
             with SCPClient(self.client.get_transport()) as scp:
                 scp.get(remote_path, local_path, recursive=True)
-            self.logger.info(
-                f"[Ssh._direct_get_file] Downloaded {remote_path}"
-                f" to {local_path} via SCP"
-            )
             return True
         except Exception as e:
             self.logger.error(
@@ -560,10 +661,6 @@ class Ssh:
         try:
             with SCPClient(self.target_client.get_transport()) as scp:
                 scp.put(local_path, remote_path, recursive=True)
-            self.logger.info(
-                f"[Ssh._jump_put_file] Uploaded {local_path} to "
-                f"{remote_path} via SCP through jump server"
-            )
             return True
         except Exception as e:
             self.logger.error(
@@ -575,10 +672,6 @@ class Ssh:
         try:
             with SCPClient(self.target_client.get_transport()) as scp:
                 scp.get(remote_path, local_path, recursive=True)
-            self.logger.info(
-                f"[Ssh._jump_get_file] Downloaded {remote_path} to "
-                f"{local_path} via SCP through jump server"
-            )
             return True
         except Exception as e:
             self.logger.error(

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1}/pytest_testkit/lib/common/environment/device.py

@@ -7,6 +7,7 @@ and connection information.
 
 import shutil
 import re
+import shlex
 import threading
 import sys
 from dataclasses import dataclass
@@ -62,6 +63,26 @@ def set_session_quiet_stdout(enabled: bool) -> None:
     _SESSION_QUIET_STDOUT = bool(enabled)
 
 
+def _short_name(name: str) -> str:
+    """取设备名的最后一段用于日志显示。
+
+    如 'training_solution_two_nodes-computing_nodes-node_2' -> 'node_2',
+    'rack1/node_3' -> 'node_3'。不按 '_' 分割, 保留 node_2 这类名字。
+
+    Args:
+        name: 完整设备名
+
+    Returns:
+        str: 最后一段; 无分隔符时原样返回
+    """
+    if not name:
+        return name
+    for sep in ("/", "-"):
+        if sep in name:
+            return name.rsplit(sep, 1)[-1]
+    return name
+
+
 @dataclass
 class DeviceParam:
     name: str
@@ -161,7 +182,12 @@ class DockerProxy:
         """
         Execute a non-interactive command in the Docker container.
 
-        Each call starts a new docker exec process (independent of interactive session).
+        Executes on the device's persistent interactive shell channel, with
+        docker session awareness:
+        - If already in this container's interactive session: executes cmd directly
+        - If another container has an active session: returns failure immediately
+        - Otherwise: wraps as 'docker exec {docker_name} {cmd}' (does not create
+          a persistent session)
 
         Args:
             cmd: Command to execute
@@ -173,6 +199,26 @@ class DockerProxy:
             str (when only_stdout=True): stdout content
             dict (when only_stdout=False): {'success': bool, 'stdout': str, 'stderr': str}
         """
+        current_session = self._device.current_docker_session
+
+        if current_session == self._docker_name:
+            # 已在该容器的交互式 session 中, 直接执行命令
+            logger.info(f"[DockerProxy.sendcmd] Executing in docker session: {cmd}")
+            return self._device.sendcmd(
+                cmd, timeout=timeout, ignore_err=ignore_err, only_stdout=only_stdout
+            )
+
+        if current_session:
+            # 其他容器持有交互式 session, 直接返回失败
+            logger.warning(
+                f"[DockerProxy.sendcmd] Another session '{current_session}' "
+                f"is active, cannot execute in '{self._docker_name}'"
+            )
+            error_msg = "请退出上一个交互对话"
+            if only_stdout:
+                return error_msg
+            return {"success": False, "stdout": "", "stderr": error_msg}
+
         docker_cmd = f"docker exec {self._docker_name} {cmd}"
         return self._device.sendcmd(
             docker_cmd, timeout=timeout, ignore_err=ignore_err, only_stdout=only_stdout
@@ -540,9 +586,6 @@ class Device:
             bool: True if login successful
         """
         if self.local_exec:
-            logger.info(
-                f"[Device._login] local_exec=True, skipping SSH login for {self.name}"
-            )
             self._set_logged_in(True)
             return True
 
@@ -550,7 +593,11 @@ class Device:
         if self._get_logged_in():
             return True
 
-        logger.info(f"[Device._login] Logging in to device: {self.name}")
+        # 登录动作日志: HTML location 列显示 login[设备短名]
+        logger.info(
+            f"Logging in to device: {self.name}",
+            extra={"op_type": f"login[{_short_name(self.name)}]"},
+        )
 
         # Implement actual SSH connection logic
         # 由于有跳板机，需要先登录跳板机，再登录目标设备
@@ -570,10 +617,25 @@ class Device:
         )
         login_result = self._thread_local.sshConnect.login()
         if login_result is False:
-            logger.error(f"[Device._login] ssh login failed for {self.__str__()}")
+            logger.error(
+                f"ssh login failed for {self.__str__()}",
+                extra={"op_type": f"loginresult[{_short_name(self.name)}]"},
+            )
             return False
         self._set_logged_in(True)
-        logger.info(f"[Device._login] Successfully connected to {self.__str__()}")
+        logger.info(
+            f"Successfully connected to {self.__str__()}",
+            extra={"op_type": f"loginresult[{_short_name(self.name)}]"},
+        )
+        # 登录后立即预创建交互 channel 并吸收 banner,
+        # 保证 loginecho 出现在第一条 sendcmd 之前
+        login_echo = self._thread_local.sshConnect.prepare_interactive_channel()
+        if login_echo:
+            logger.info(
+                login_echo,
+                extra={"op_type": f"loginecho[{_short_name(self.name)}]"},
+            )
+            self._thread_local.sshConnect._login_echo_logged = True
         return True
 
     def _sftp_login(self):
@@ -621,24 +683,32 @@ class Device:
         only_stdout=True,
         echo_output=True,
     ):
-        """Send command to the device.
+        """Send command to the device via the persistent interactive shell channel.
 
         Automatically logs in if not already logged in in current thread.
         Each thread maintains its own independent login session.
-        If local_exec is True, executes command locally via subprocess instead of SSH.
+        Shell state (cd, export) persists across sendcmd calls within the same thread.
+
+        Behavior notes:
+        - env_vars is inlined as a per-command prefix (VAR=value cmd), scoped to
+          this command only, does not pollute the persistent shell
+        - stderr is merged into stdout by the PTY; result dict 'stderr' is usually ''
+        - Exit code is best-effort captured via the $? sentinel
+        - 一次性执行需求请用 sendcmd_oneshot (SSH exec_command / subprocess.run)
 
-        日志策略: 第 1 行打印命令, 第 2 行打印 exit/stdout/stderr.
-        失败且 ignore_err=False 时第 2 行升级为 ERROR.
-        echo_output=False 时不打印 stdout.
+        日志策略: sendcmd[设备] 打印命令(带 shell 提示符前缀),
+        recvcmd[设备] 打印文本回显(stdout+stderr 合并, 不打印 dict).
+        echo_output=False 或全局静默时不打印回显.
 
         Args:
             cmd: Command to execute
-            timeout: Timeout in seconds, supports int or str (e.g., 30 or "30")
-            env_vars: Environment variables for the command
+            timeout: Timeout in seconds, supports int or str (e.g., 30 or "30"),
+                defaults to 600 when None
+            env_vars: Environment variables for the command (inlined as VAR=value prefix)
             cwd: Working directory to execute command in
             ignore_err: If True, success=True even when command fails
             only_stdout: If True, return only stdout string; if False, return dict
-            echo_output: If True, print stdout in the 2nd log line; if False, only print exit_code
+            echo_output: If True, print the recvcmd echo log; if False, skip it
 
         Returns:
             str (when only_stdout=True): stdout content
@@ -646,125 +716,127 @@ class Device:
         """
         if isinstance(timeout, str):
             timeout = int(timeout)
+        if timeout is None:
+            timeout = 600
 
-        # 第 1 行: 默认打印执行的命令, 受 echo_output 和 _SESSION_QUIET_STDOUT 控制
-        if echo_output and not _SESSION_QUIET_STDOUT:
-            logger.info(f"[Device.sendcmd] $ {LogColor.CYAN}{cmd}{LogColor.RESET}")
+        # env_vars 内联为单命令前缀 (VAR=value cmd), 不污染持久化 shell
+        actual_cmd = cmd
+        if env_vars:
+            prefix = " ".join(f"{k}={shlex.quote(str(v))}" for k, v in env_vars.items())
+            actual_cmd = f"{prefix} {cmd}"
 
         if self.local_exec:
-            logger.debug(f"[Device.sendcmd] local_exec=True, executing locally: {cmd}")
-            param = LocalCmdParam(
-                cmd=cmd,
+            if not self._get_logged_in():
+                self._login()
+            logger.debug(
+                f"[Device.sendcmd] local_exec=True, executing interactively: {cmd}"
+            )
+            param = LocalCmdInteractiveParam(
+                cmd=actual_cmd,
                 timeout=timeout,
-                environment=env_vars,
                 cwd=cwd,
                 ignore_err=ignore_err,
                 only_stdout=False,  # 强制拿 dict 用于日志
             )
-            result_dict = self._get_local_client().cmd(param)
+            result_dict = self._get_local_client().cmd_interactive(param)
+            ssh_connect = None
         else:
             if not self._get_logged_in():
                 self._login()
 
-            param = SshCmdParam(
-                cmd=cmd,
+            ssh_connect = self._thread_local.sshConnect
+            # login banner 回显兜底: channel 为惰性创建时 banner 在首次交互命令
+            # 内部才被吸收, 此刻有内容可提前打印, 保证顺序在 sendcmd 之前
+            if getattr(ssh_connect, "login_echo", "") and not getattr(
+                ssh_connect, "_login_echo_logged", False
+            ):
+                logger.info(
+                    ssh_connect.login_echo,
+                    extra={"op_type": f"loginecho[{_short_name(self.name)}]"},
+                )
+                ssh_connect._login_echo_logged = True
+
+            param = SshCmdInteractiveParam(
+                cmd=actual_cmd,
+                expect_prompt=None,
                 timeout=timeout,
-                environment=env_vars,
                 cwd=cwd,
                 ignore_err=ignore_err,
                 only_stdout=False,  # 强制拿 dict 用于日志
             )
-            result_dict = self._thread_local.sshConnect.ssh_cmd(param)
+            result_dict = ssh_connect.ssh_cmd_interactive(param)
 
-        # 第 2 行: 打印 exit / stdout / stderr
-        self._log_exec_result("sendcmd", result_dict, ignore_err, echo_output, None)
+        # 发送命令日志: HTML location 列显示 sendcmd[设备短名],
+        # 消息带上 shell 提示符还原终端效果
+        if echo_output and not _SESSION_QUIET_STDOUT:
+            node_tag = f"[{_short_name(self.name)}]"
+            prompt = getattr(ssh_connect, "last_prompt", "") if ssh_connect else ""
+            send_msg = f"{prompt}{cmd}" if prompt else cmd
+            if cwd is not None:
+                send_msg += f"    (cwd: {cwd})"
+            logger.info(
+                f"{LogColor.CYAN}{send_msg}{LogColor.RESET}",
+                extra={"op_type": f"sendcmd{node_tag}"},
+            )
+            # 回显日志: 只打印文本回显(stdout+stderr), 不打印 dict,
+            # 末尾带上最新提示符
+            echo_parts = []
+            stdout = result_dict.get("stdout", "") or ""
+            stderr = result_dict.get("stderr", "") or ""
+            if stdout:
+                echo_parts.append(stdout)
+            if stderr:
+                echo_parts.append(stderr)
+            result_echo = "\n".join(echo_parts)
+            if result_echo:
+                new_prompt = (
+                    getattr(ssh_connect, "last_prompt", "") if ssh_connect else ""
+                )
+                recv_msg = (
+                    result_echo
+                    if result_echo.endswith(new_prompt)
+                    else (f"{result_echo}\n{new_prompt}" if new_prompt else result_echo)
+                )
+                logger.info(recv_msg, extra={"op_type": f"recvcmd{node_tag}"})
+            else:
+                logger.info("(empty)", extra={"op_type": f"recvcmd{node_tag}"})
 
         # 按用户原始 only_stdout 决定返回值
         if only_stdout:
             return result_dict.get("stdout", "")
         return result_dict
 
-    def _log_exec_result(
-        self,
-        method: str,
-        result_dict: dict,
-        ignore_err: bool,
-        echo_output: bool,
-        matched_prompt,
-    ):
-        """打 sendcmd / sendcmd_interactive 的第 2 行日志。
-
-        Args:
-            method: 方法名, 用于日志前缀 ('sendcmd' / 'sendcmd_interactive')
-            result_dict: 底层返回的 dict (only_stdout=False 模式)
-            ignore_err: 用户传入的 ignore_err
-            echo_output: 用户传入的 echo_output
-            matched_prompt: 仅 sendcmd_interactive 用; sendcmd 传 None
-        """
-        success = result_dict.get("success", True)
-        stdout = result_dict.get("stdout", "") or ""
-        stderr = result_dict.get("stderr", "") or ""
-        exit_code = result_dict.get("exit_code")
-
-        # ignore_err=True 时即使底层 success=False 也按成功处理(不打 ERROR)
-        is_failure = (not success) and (not ignore_err)
-
-        # echo_output=False 或 全局静默开关开启时, 任何返回值都不打印
-        if not echo_output or _SESSION_QUIET_STDOUT:
-            return
-
-        parts = []
-        if matched_prompt is not None:
-            parts.append(f"prompt={matched_prompt}")
-        if exit_code is not None:
-            suffix = " (ignored)" if ignore_err and exit_code != 0 else ""
-            parts.append(f"exit={exit_code}{suffix}")
-        if stdout:
-            parts.append(f"stdout={stdout}")
-        if stderr:
-            parts.append(f"stderr={stderr}")
-
-        if not parts:
-            # 拿不到 exit_code 等任何信息时的兜底
-            if is_failure:
-                parts.append("FAILED")
-            else:
-                parts.append("ok")
-
-        line = f"[Device.{method}] {', '.join(parts)}"
-        if is_failure:
-            logger.warning(line)
-        else:
-            logger.info(line)
-
-    def sendcmd_interactive(
+    def sendcmd_oneshot(
         self,
         cmd,
-        expect_prompt=None,
-        timeout=600,
+        timeout=None,
+        env_vars=None,
         cwd=None,
         ignore_err=False,
         only_stdout=True,
         echo_output=True,
     ):
-        """Send command to the device with interactive input.
+        """Send command to the device as a one-shot execution (original sendcmd logic).
 
-        Automatically logs in if not already logged in in current thread.
-        Each thread maintains its own independent login session.
-        If local_exec is True, executes command locally via subprocess instead of SSH.
+        Each call starts an independent exec_command / subprocess.run process:
+        - SSH path: wraps the command in 'bash -l -c' and runs it via
+          exec_command with native environment support; exit code is the
+          authoritative channel exit status; stderr is a separate stream
+        - local_exec path: runs via subprocess.run
+
+        No persistent shell state; independent of the interactive channel.
 
-        日志策略: 第 1 行打印命令, 第 2 行打印 prompt/exit/stdout.
-        失败(prompt 未匹配或 exit != 0)且 ignore_err=False 时第 2 行升级为 ERROR.
-        echo_output=False 时不打印 stdout.
+        日志策略与 sendcmd 相同: sendcmd[设备] 打印命令,
+        recvcmd[设备] 打印文本回显(stdout+stderr 合并, 不打印 dict).
 
         Args:
             cmd: Command to execute
-            expect_prompt: Expected prompt to wait for
-            timeout: Timeout in seconds, supports int or str (e.g., 600 or "600")
+            timeout: Timeout in seconds, supports int or str (e.g., 30 or "30")
+            env_vars: Environment variables for the command
             cwd: Working directory to execute command in
-            ignore_err: If True, success=True even when prompt not matched
+            ignore_err: If True, success=True even when command fails
             only_stdout: If True, return only stdout string; if False, return dict
-            echo_output: If True, print stdout in the 2nd log line; if False, only print exit_code/prompt
+            echo_output: If True, print the recvcmd echo log; if False, skip it
 
         Returns:
             str (when only_stdout=True): stdout content
@@ -773,52 +845,98 @@ class Device:
         if isinstance(timeout, str):
             timeout = int(timeout)
 
-        # 第 1 行: 默认打印执行的命令, 受 echo_output 和 _SESSION_QUIET_STDOUT 控制
-        if echo_output and not _SESSION_QUIET_STDOUT:
-            logger.info(
-                f"[Device.sendcmd_interactive] $ {LogColor.CYAN}{cmd}{LogColor.RESET}"
-            )
-
         if self.local_exec:
-            if not self._get_logged_in():
-                self._login()
             logger.debug(
-                f"[Device.sendcmd_interactive] local_exec=True, executing interactively: {cmd}"
+                f"[Device.sendcmd_oneshot] local_exec=True, executing locally: {cmd}"
             )
-            param = LocalCmdInteractiveParam(
+            param = LocalCmdParam(
                 cmd=cmd,
                 timeout=timeout,
+                environment=env_vars,
                 cwd=cwd,
                 ignore_err=ignore_err,
                 only_stdout=False,  # 强制拿 dict 用于日志
-                expect_prompt=expect_prompt,
             )
-            result_dict = self._get_local_client().cmd_interactive(param)
+            result_dict = self._get_local_client().cmd(param)
         else:
             if not self._get_logged_in():
                 self._login()
 
-            param = SshCmdInteractiveParam(
+            param = SshCmdParam(
                 cmd=cmd,
-                expect_prompt=expect_prompt,
                 timeout=timeout,
+                environment=env_vars,
                 cwd=cwd,
                 ignore_err=ignore_err,
                 only_stdout=False,  # 强制拿 dict 用于日志
             )
-            result_dict = self._thread_local.sshConnect.ssh_cmd_interactive(param)
+            result_dict = self._thread_local.sshConnect.ssh_cmd(param)
 
-        # 第 2 行: 打印 prompt / exit / stdout
-        matched_prompt = result_dict.get("matched_prompt")
-        self._log_exec_result(
-            "sendcmd_interactive", result_dict, ignore_err, echo_output, matched_prompt
-        )
+        # 命令与回显日志: sendcmd[设备短名] / recvcmd[设备短名]
+        if echo_output and not _SESSION_QUIET_STDOUT:
+            node_tag = f"[{_short_name(self.name)}]"
+            logger.info(
+                f"{LogColor.CYAN}{cmd}{LogColor.RESET}",
+                extra={"op_type": f"sendcmd{node_tag}"},
+            )
+            echo_parts = []
+            stdout = result_dict.get("stdout", "") or ""
+            stderr = result_dict.get("stderr", "") or ""
+            if stdout:
+                echo_parts.append(stdout)
+            if stderr:
+                echo_parts.append(stderr)
+            result_echo = "\n".join(echo_parts)
+            if result_echo:
+                logger.info(result_echo, extra={"op_type": f"recvcmd{node_tag}"})
+            else:
+                logger.info("(empty)", extra={"op_type": f"recvcmd{node_tag}"})
 
         # 按用户原始 only_stdout 决定返回值
         if only_stdout:
             return result_dict.get("stdout", "")
         return result_dict
 
+    def sendcmd_interactive(
+        self,
+        cmd,
+        expect_prompt=None,
+        timeout=600,
+        cwd=None,
+        ignore_err=False,
+        only_stdout=True,
+        echo_output=True,
+    ):
+        """Send command to the device with interactive input.
+
+        Same functionality as sendcmd (persistent interactive shell channel);
+        simply calls sendcmd. Kept for backward compatibility with existing
+        call sites.
+
+        日志策略与 sendcmd 相同: sendcmd[设备] 打印命令, recvcmd[设备] 打印文本回显.
+
+        Args:
+            cmd: Command to execute
+            expect_prompt: Unused, kept for signature compatibility
+            timeout: Timeout in seconds, supports int or str (e.g., 600 or "600")
+            cwd: Working directory to execute command in
+            ignore_err: If True, success=True even when prompt not matched
+            only_stdout: If True, return only stdout string; if False, return dict
+            echo_output: If True, print stdout in the 2nd log line; if False, only print exit_code/prompt
+
+        Returns:
+            str (when only_stdout=True): stdout content
+            dict (when only_stdout=False): {'success': bool, 'stdout': str, 'stderr': str}
+        """
+        return self.sendcmd(
+            cmd,
+            timeout=timeout,
+            cwd=cwd,
+            ignore_err=ignore_err,
+            only_stdout=only_stdout,
+            echo_output=echo_output,
+        )
+
     def upload_file(self, local_file, remote_file, trans_type="SCP"):
         """Upload a local file to remote device.
 
@@ -942,7 +1060,8 @@ class Device:
                     self._local_client.close()
                 self._set_logged_in(False)
                 logger.info(
-                    f"[Device._disconnect] Disconnected local exec for {self.__str__()}"
+                    f"Disconnected local exec for {self.__str__()}",
+                    extra={"op_type": f"disconnect[{_short_name(self.name)}]"},
                 )
                 return True
 
@@ -953,12 +1072,16 @@ class Device:
                 self._thread_local.sshConnect.close()
                 self._set_logged_in(False)
 
-                logger.info(f"[Device._disconnect] Disconnected from {self.__str__()}")
+                logger.info(
+                    f"Disconnected from {self.__str__()}",
+                    extra={"op_type": f"disconnect[{_short_name(self.name)}]"},
+                )
 
                 return True
         except Exception as e:
-            logger.info(
-                f"[Device.disconnect] Failed to disconnect device {self.__str__()}: {e}"
+            logger.error(
+                f"Failed to disconnect device {self.__str__()}: {e}",
+                extra={"op_type": f"disconnect[{_short_name(self.name)}]"},
             )
 
         return False

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1}/pytest_testkit/lib/common/log/infra_logger.py

@@ -53,39 +53,39 @@ class InfraLogger(logging.Logger):
 
     def tc_start(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.TC_START):
-            self._log(FileLogLevel.TC_START, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.TC_START, msg, args, stacklevel=2, **kwargs)
 
     def tc_end(self, msg="Test Case End", *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.TC_END):
-            self._log(FileLogLevel.TC_END, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.TC_END, msg, args, stacklevel=2, **kwargs)
 
     def tc_step(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.TC_STEP):
-            self._log(FileLogLevel.TC_STEP, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.TC_STEP, msg, args, stacklevel=2, **kwargs)
 
     def pass_info(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.PASS):
-            self._log(FileLogLevel.PASS, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.PASS, msg, args, stacklevel=2, **kwargs)
 
     def fail(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.FAIL):
-            self._log(FileLogLevel.FAIL, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.FAIL, msg, args, stacklevel=2, **kwargs)
 
     def pre_set(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.PRE_SET):
-            self._log(FileLogLevel.PRE_SET, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.PRE_SET, msg, args, stacklevel=2, **kwargs)
 
     def post_set(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.POST_SET):
-            self._log(FileLogLevel.POST_SET, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.POST_SET, msg, args, stacklevel=2, **kwargs)
 
     def cmd(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.CMD):
-            self._log(FileLogLevel.CMD, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.CMD, msg, args, stacklevel=2, **kwargs)
 
     def cmd_response(self, msg, *args, **kwargs):
         if self.isEnabledFor(FileLogLevel.CMD_RESPONSE):
-            self._log(FileLogLevel.CMD_RESPONSE, msg, args, stacklevel=4, **kwargs)
+            self._log(FileLogLevel.CMD_RESPONSE, msg, args, stacklevel=2, **kwargs)
 
     def set_header(self, html_content: Optional[str], append: bool = False) -> None:
         thread_id = threading.current_thread().ident

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1}/pytest_testkit/lib/common/log/manager.py

@@ -3,7 +3,7 @@ import os
 import re
 import threading
 import unicodedata
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Dict, Optional
 
 from .infra_logger import (
@@ -77,6 +77,97 @@ class LogFileManager:
             del self._handlers[thread_id]
             self.generate_html_report(logs, case_id, status, duration, thread_id)
 
+    # ANSI 前景色码 -> HTML 颜色
+    _ANSI_COLORS = {
+        "30": "#000000",
+        "31": "#F44336",
+        "32": "#2E8B57",
+        "33": "#FFC107",
+        "34": "#2196F3",
+        "35": "#9C27B0",
+        "36": "#00BCD4",
+        "37": "#9E9E9E",
+        "90": "#616161",
+        "91": "#FF5252",
+        "92": "#69F0AE",
+        "93": "#FFD740",
+        "94": "#40C4FF",
+        "95": "#E040FB",
+        "96": "#64FFDA",
+        "97": "#FFFFFF",
+    }
+
+    # 命令回显中标红的常用错误词 (大小写不敏感, 单词边界匹配)
+    _ERROR_WORDS = re.compile(
+        r"\b(error|errors|failed|fail|fails|failure|fatal|panic|exception|"
+        r"traceback|aborted|denied|refused|timeout|timed out|segmentation fault|"
+        r"core dumped|critical|unreachable|not found|"
+        r"no such file or directory)\b",
+        re.IGNORECASE,
+    )
+
+    @classmethod
+    def _ansi_to_html(cls, text):
+        """把 ANSI 转义序列转换为带颜色的 HTML span 标签。
+
+        支持前景色 (30-37, 90-97) 和 reset (0)。
+        在 _escape_html 之后调用: ANSI 转义序列本身不含 HTML 特殊字符,
+        转义不影响其识别, 而转换产生的 span 标签不会再被处理。
+
+        Args:
+            text: 包含 ANSI 转义序列的文本
+
+        Returns:
+            str: 带 HTML 颜色标签的文本
+        """
+        result = []
+        i = 0
+        n = len(text)
+        while i < n:
+            # 找到下一个 ESC[
+            idx = text.find("\x1b[", i)
+            if idx == -1:
+                result.append(text[i:])
+                break
+            result.append(text[i:idx])
+            # 找到序列结束符(字母)
+            end = idx + 2
+            while end < n and not text[end].isalpha():
+                end += 1
+            if end >= n:
+                result.append(text[idx:])
+                break
+            seq = text[idx + 2 : end]  # 如 "36" 或 "0"
+            final = text[end]  # 结束字母, 如 "m"
+            if final == "m":
+                if seq == "0" or seq == "":
+                    result.append("</span>")
+                elif seq in cls._ANSI_COLORS:
+                    result.append(f'<span style="color:{cls._ANSI_COLORS[seq]}">')
+                else:
+                    # 其他修饰(加粗/背景等), 忽略序列本身
+                    pass
+            # 非 'm' 结束的序列(如光标移动)也直接丢弃
+            i = end + 1
+        return "".join(result)
+
+    @classmethod
+    def _highlight_error_words(cls, text):
+        """把回显文本中的常用错误单词标红。
+
+        在 _escape_html / _ansi_to_html 之后调用, 生成的 span 标签
+        不会再被处理。错误词不会出现在已有标签的属性值中, 替换安全。
+
+        Args:
+            text: HTML 转义后的回显文本
+
+        Returns:
+            str: 错误词标红后的文本
+        """
+        return cls._ERROR_WORDS.sub(
+            r'<span style="color:#F44336;font-weight:bold">\g<0></span>', text
+        )
+
     @staticmethod
     def _escape_html(text):
         if not text:
@@ -122,9 +213,10 @@ class LogFileManager:
                 text = text.encode("latin-1").decode("utf-8", errors="replace")
         except (UnicodeEncodeError, UnicodeDecodeError):
             logger.debug("latin-1/utf-8 re-decode skipped due to encoding error")
-        # 只过滤控制字符，保留中文等合法非 ASCII 字符
+        # 只过滤控制字符，保留中文等合法非 ASCII 字符。
+        # 保留 ESC(\x1b): 后续 _ansi_to_html 需要识别 ANSI 颜色序列
         text = "".join(
-            c for c in text if c in "\n\r\t" or unicodedata.category(c)[0] != "C"
+            c for c in text if c in "\n\r\t\x1b" or unicodedata.category(c)[0] != "C"
         )
         try:
             encoded = text.encode("windows-1252")
@@ -196,13 +288,25 @@ class LogFileManager:
         for record in logs:
             formatted_msg = record.getMessage()
             formatted_msg = self._fix_encoding_issues(formatted_msg)
+            # 优先使用 op_type (sendcmd/recvcmd/login/loginecho 等操作类型),
+            # 否则回退到默认的 文件名:行号
+            op_type = getattr(record, "op_type", None)
+            # 先 HTML 转义, 再把 ANSI 颜色码转为带颜色的 span 标签
+            # (ANSI 转义序列本身不含 HTML 特殊字符, 转义不影响其识别)
             formatted_msg = self._escape_html(formatted_msg)
+            formatted_msg = self._ansi_to_html(formatted_msg)
+            # 命令回显(recvcmd)中的常用错误单词标红
+            if op_type and op_type.startswith("recvcmd"):
+                formatted_msg = self._highlight_error_words(formatted_msg)
             time_str = datetime.fromtimestamp(record.created).strftime(
                 "%Y-%m-%d %H:%M:%S.%f"
             )[:-3]
             level_str = record.levelname
             thread_str = record.thread
-            location_str = f"{record.filename}:{record.lineno}"
+            if op_type:
+                location_str = op_type
+            else:
+                location_str = f"{record.filename}:{record.lineno}"
 
             parsed_logs.append({
                 "time": time_str,
@@ -220,7 +324,7 @@ class LogFileManager:
 
         case_dir_path = getattr(_local, "case_log_path", None)
         if not case_dir_path:
-            now = datetime.now(tz=timezone.utc)
+            now = datetime.now()
             date_dir = now.strftime("%Y-%m-%d")
             time_dir = now.strftime("%H-%M-%S")
             case_dir_name = f"{safe_name}_{time_dir}"
@@ -273,9 +377,9 @@ class LogFileManager:
         .TRACE {{ color: #757575; }}
         .TC_STEP {{ color: #1976D2; font-weight: bold; }}
         th:nth-child(1), td:nth-child(1) {{ width: 220px; min-width: 150px; }}
-        th:nth-child(2), td:nth-child(2) {{ width: 90px; min-width: 90px; }}
-        th:nth-child(3), td:nth-child(3) {{ width: 70px; min-width: 70px; }}
-        th:nth-child(4), td:nth-child(4) {{ width: 320px; min-width: 280px; }}
+        th:nth-child(2), td:nth-child(2) {{ width: 70px; min-width: 60px; }}
+        th:nth-child(3), td:nth-child(3) {{ width: 50px; min-width: 40px; }}
+        th:nth-child(4), td:nth-child(4) {{ width: 128px; min-width: 112px; }}
         th:nth-child(5), td:nth-child(5) {{ width: auto; }}
 
         /* Step row status colors - all cells in the row */
@@ -459,7 +563,7 @@ class LogManager:
             log_dir = os.path.abspath(log_path)
         else:
             log_dir = os.path.join(
-                log_path, datetime.now(tz=timezone.utc).strftime("%Y-%m-%d-%H_%M_%S")
+                log_path, datetime.now().strftime("%Y-%m-%d-%H_%M_%S")
             )
             log_dir = os.path.abspath(log_dir)
 
@@ -496,7 +600,7 @@ class LogManager:
         safe_case_name = re.sub(r"[^\w\-_.]", "_", case_name)
         log_filename = f"{safe_case_name}.log"
 
-        now = datetime.now(tz=timezone.utc)
+        now = datetime.now()
         date_dir = now.strftime("%Y-%m-%d")
         time_dir = now.strftime("%H-%M-%S")
         case_dir_name = f"{safe_case_name}_{time_dir}"

{pytest_testkit-1.0.2a2 → pytest_testkit-1.0.2b1/pytest_testkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest_testkit
-Version: 1.0.2a2
+Version: 1.0.2b1
 Summary: Pytest plugin for Infra logging framework and environment management
 Author: Huawei
 License: MIT License