Changes based on review commands

Introduce NonSshExecutor.
It Internally uses SerialConsole/RunCommand

Author: adityagesh

lisa/features/__init__.py

@@ -23,10 +23,10 @@
 from .nested_virtualization import NestedVirtualization
 from .network_interface import NetworkInterface, Sriov, Synthetic
 from .nfs import Nfs
+from .non_ssh_executor import NonSshExecutor
 from .nvme import Nvme, NvmeSettings
 from .password_extension import PasswordExtension
 from .resize import Resize, ResizeAction
-from .run_command import RunCommand
 from .security_profile import (
     SecureBootEnabled,
     SecurityProfile,
@@ -65,7 +65,6 @@
     "PasswordExtension",
     "Resize",
     "ResizeAction",
-    "RunCommand",
     "SecureBootEnabled",
     "SecurityProfile",
     "SecurityProfileSettings",
@@ -75,4 +74,5 @@
     "VMStatus",
     "Synthetic",
     "StartStop",
+    "NonSshExecutor",
 ]

lisa/features/non_ssh_executor.py

@@ -0,0 +1,53 @@
+from lisa.feature import Feature
+from lisa.features.serial_console import SerialConsole
+
+
+class NonSshExecutor(Feature):
+    """
+    NonSshExecutor is used to run commands on the node when SSH is not available.
+    Lisa by default uses SSH for connection, but this feature provides an alternative
+    execution method for scenarios where SSH connectivity is not possible or desired.
+    """
+
+    COMMANDS_TO_EXECUTE = [
+        "ip addr show",
+        "ip link show",
+        "systemctl status NetworkManager --no-pager --plain",
+        "systemctl status network --no-pager --plain",
+        "systemctl status systemd-networkd --no-pager --plain",
+        "ping -c 3 -n 8.8.8.8",
+    ]
+
+    @classmethod
+    def name(cls) -> str:
+        return "NonSshExecutor"
+
+    def enabled(self) -> bool:
+        return True
+
+    def execute(self, commands: list[str] = COMMANDS_TO_EXECUTE) -> list[str]:
+        """
+        Executes a list of commands on the node and returns their outputs.
+
+        :param commands: A list of shell commands to execute.
+        :return: A string containing the output of the executed commands.
+        """
+        out = []
+        serial_console = self._node.features[SerialConsole]
+        serial_console.login()
+        # clear the console before executing commands
+        serial_console.write("\n")
+        _ = serial_console.read()
+        for command in commands:
+            serial_console.write(self._add_newline(command))
+            out.append(serial_console.read())
+        return out
+
+    def _add_newline(self, command: str) -> str:
+        """
+        Adds a newline character to the command if it does not already end with one.
+        newline is required to run the command in serial console.
+        """
+        if not command.endswith("\n"):
+            return f"{command}\n"
+        return command

lisa/features/run_command.py

@@ -13,6 +13,7 @@
     get_datetime_path,
     get_matched_str,
 )
+from lisa.util.constants import ENVIRONMENTS_NODES_REMOTE_USERNAME
 
 FEATURE_NAME_SERIAL_CONSOLE = "SerialConsole"
 NAME_SERIAL_CONSOLE_LOG = "serial_console.log"
@@ -190,6 +191,34 @@ def check_initramfs(
                 f"{initramfs_logs} {filesystem_exception_logs}"
             )
 
+    def login(self) -> None:
+        # Clear the serial console and try to get the login prompt
+        self.read()
+        self.write("\n")
+        serial_output = self.read()
+
+        if "login" not in serial_output:
+            self._log.debug(
+                "No login prompt found, serial console is already logged in."
+            )
+            return
+
+        from lisa.node import RemoteNode
+
+        if not isinstance(self._node, RemoteNode):
+            raise LisaException(
+                "SerialConsole login is only implemented for RemoteNode"
+            )
+
+        username = self._node.connection_info[ENVIRONMENTS_NODES_REMOTE_USERNAME]
+        password = self._node.get_password()
+
+        self.write(f"{username}\n")
+        password_prompt = self.read()
+
+        if "password" in password_prompt.lower():
+            self.write(f"{password}\n")
+
     def read(self) -> str:
         raise NotImplementedError
 

lisa/features/serial_console.py

@@ -694,9 +694,16 @@ def _initialize(self, *args: Any, **kwargs: Any) -> None:
         try:
             super()._initialize(*args, **kwargs)
         except TcpConnectionException as e:
-            vm_logs = self._collect_logs_using_platform()
-            if vm_logs:
-                self.log.info(f"Collected information using platform:\n{vm_logs}")
+            try:
+                vm_logs = self._collect_logs_using_non_ssh_executor()
+                if vm_logs:
+                    self.log.info(
+                        f"Collected information using non-ssh executor:\n{vm_logs}"
+                    )
+            except Exception as log_error:
+                self.log.debug(
+                    f"Failed to collect logs using non-ssh executor: {log_error}"
+                )
             raise e
 
     def get_working_path(self) -> PurePath:
@@ -741,31 +748,22 @@ def check_sudo_password_required(self) -> None:
                     raise RequireUserPasswordException("Reset password failed")
             self._check_password_and_store_prompt()
 
-    def _collect_logs_using_platform(self) -> Optional[str]:
+    def _collect_logs_using_non_ssh_executor(self) -> Optional[str]:
         """
-        Collects information using the RunCommand feature.
+        Collects information using the NonSshExecutor feature.
         This is used when the connection to the node is not stable.
         """
-        from lisa.features import RunCommand
-
-        if self.features.is_supported(RunCommand):
-            run_command = self.features[RunCommand]
-            commands = [
-                "echo 'Executing: ip addr show'",
-                "ip addr show",
-                "echo 'Executing: ip link show'",
-                "ip link show",
-                "echo 'Executing: systemctl status NetworkManager --no-pager --plain'",
-                "systemctl status NetworkManager --no-pager --plain",
-                "echo 'Executing: systemctl status network --no-pager --plain'",
-                "systemctl status network --no-pager --plain",
-                "echo 'Executing: systemctl status systemd-networkd --no-pager --plain'",
-                "systemctl status systemd-networkd --no-pager --plain",
-                "echo 'Executing: ping -c 3 -n 8.8.8.8'",
-                "ping -c 3 -n 8.8.8.8",
-            ]
-            out = run_command.execute(commands=commands)
-            return out
+        from lisa.features import NonSshExecutor
+
+        if self.features.is_supported(NonSshExecutor):
+            non_ssh_executor = self.features[NonSshExecutor]
+            out = non_ssh_executor.execute()
+            return "\n".join(out)
+        else:
+            self.log.debug(
+                f"NonSshExecutor is not supported on {self.name}, "
+                "cannot collect logs using non-ssh executor."
+            )
         return None
 
     def _check_password_and_store_prompt(self) -> None:
@@ -815,29 +813,7 @@ def _check_bash_prompt(self) -> None:
                     ssh_shell.bash_prompt = bash_prompt
             self.has_checked_bash_prompt = True
 
-    def _login_to_serial_console(self) -> None:
-        from lisa.features import SerialConsole
-
-        if self.features.is_supported(SerialConsole):
-            serial_console = self.features[SerialConsole]
-            # clear the serial console
-            # write \n to serial console to get the prompt
-            # read the serial console output
-            _ = serial_console.read()
-            serial_console.write("\n")
-            serial_read = serial_console.read()
-            if "login" in serial_read:
-                password = self._get_password()
-                serial_console.write(f"{self._connection_info.username}\n")
-                password_prompt = serial_console.read()
-                if "password" in password_prompt.lower():
-                    serial_console.write(f"{password}\n")
-            else:
-                self.log.debug(
-                    "No login prompt found, serial console is already logged in."
-                )
-
-    def _get_password(self, generate: bool = True) -> str:
+    def get_password(self, generate: bool = True) -> str:
         """
         Get the password for the node. If the password is not set, it will
         generate a strong password and reset it.

lisa/node.py

@@ -3734,7 +3734,7 @@ def _prepare_azure_file_share(
             )
 
 
-class RunCommand(AzureFeatureMixin, features.RunCommand):
+class RunCommand(AzureFeatureMixin, Feature):
 
     @classmethod
     def create_setting(
@@ -3762,17 +3762,38 @@ def execute(self, commands: List[str]) -> str:
         compute_client = get_compute_client(platform)
 
         # Prepare the RunCommandInput for Azure
-        command = RunCommandInput(
+        run_command_input = RunCommandInput(
             command_id="RunShellScript",
-            script=commands,
+            script=self._add_echo_before_command(commands),
         )
 
         # Execute the command on the VM
         operation = compute_client.virtual_machines.begin_run_command(
             resource_group_name=context.resource_group_name,
             vm_name=context.vm_name,
-            parameters=command,
+            parameters=run_command_input,
         )
         result = wait_operation(operation=operation, failure_identity="run command")
 
         return result["value"][0]["message"]
+
+    def _add_echo_before_command(self, commands: List[str]):
+        """
+        Adds an echo command before each command in the list to ensure
+        that the output of each command is captured in the logs.
+        """
+        return [f"echo 'Running command: {cmd}' && {cmd}" for cmd in commands]
+
+
+class NonSshExecutor(AzureFeatureMixin, features.NonSshExecutor):
+    def execute(
+        self, commands: list[str] = features.NonSshExecutor.COMMANDS_TO_EXECUTE
+    ) -> list[str]:
+        # RunCommand is faster than SerialConsole. Hence attempt to use it first.
+        try:
+            output = self._node.features[RunCommand].execute(commands)
+            return [output]
+        except Exception as e:
+            self._log.info(f"RunCommand failed: {e}")
+            # Fallback to the default non-SSH executor behavior
+            return super().execute(commands)

lisa/sut_orchestrator/azure/features.py

@@ -494,6 +494,7 @@ def supported_features(cls) -> List[Type[feature.Feature]]:
             features.Infiniband,
             features.Hibernation,
             features.RunCommand,
+            features.NonSshExecutor,
         ]
 
     def _prepare_environment(self, environment: Environment, log: Logger) -> bool: