session: implement forcibly stop

Change the way we complete session by introducing forcibly stop. The
way that kirk works after this patch is the following:

- if user sends SIGINT or CTRL+C, we simply wait for the running
  tests to complete and finally stop the session

- if user sends SIGINT or CTRL+C again, we stop any execution on the SUT
  and we terminate the testing suite, flagging the killed test as TSKIP

Signed-off-by: Andrea Cervesato <[email protected]>
Closes: #78

Author: acerv

libkirk/ltp.py

@@ -10,6 +10,7 @@
 import logging
 import os
 import re
+import signal
 from typing import (
     Any,
     Dict,
@@ -384,6 +385,8 @@ async def read_result(
                     warnings = 1
                 elif retcode == 32:
                     skipped = 1
+                elif retcode == -signal.SIGKILL:
+                    skipped = 1
                 elif not error:
                     failed = 1
 

libkirk/main.py

@@ -446,6 +446,21 @@ async def session_run() -> None:
             if monitor:
                 await monitor.stop()
 
+    def _session_stop() -> None:
+        """
+        Stop the session.
+        """
+        loop.run_until_complete(
+            # pyrefly: ignore[bad-argument-type]
+            asyncio.gather(
+                *[
+                    session.stop(),
+                    libkirk.events.stop(),
+                ]
+            )
+        )
+        libkirk.cancel_tasks(loop)
+
     loop = libkirk.get_event_loop()
     exit_code = RC_OK
 
@@ -460,20 +475,9 @@ async def session_run() -> None:
         exit_code = RC_ERROR
     finally:
         try:
-            # at this point loop has been closed, so we can collect all
-            # tasks and cancel them
-            loop.run_until_complete(
-                # pyrefly: ignore[bad-argument-type]
-                asyncio.gather(
-                    *[
-                        session.stop(),
-                        libkirk.events.stop(),
-                    ]
-                )
-            )
-            libkirk.cancel_tasks(loop)
+            _session_stop()
         except KeyboardInterrupt:
-            pass
+            _session_stop()
 
     parser.exit(exit_code)
 

libkirk/session.py

@@ -90,7 +90,8 @@ def __init__(
         self._sut = sut
         self._exec_timeout = exec_timeout
         self._force_parallel = force_parallel
-        self._stop = False
+        self._stop_cnt = 0
+        self._stop_lock = asyncio.Lock()
         self._exec_lock = asyncio.Lock()
         self._run_lock = asyncio.Lock()
         self._results = []
@@ -356,7 +357,7 @@ async def _exec_command(self, command: str) -> None:
             except asyncio.TimeoutError:
                 exc = KirkException(f"Command timeout: {repr(command)}")
             except KirkException as err:
-                if not self._stop:
+                if self._stop_cnt == 0:
                     exc = err
 
             if exc:
@@ -366,16 +367,24 @@ async def _inner_stop(self) -> None:
         """
         Stop scheduler and SUT.
         """
+        if self._stop_cnt > 1:
+            # by stopping SUT first, we cause scheduler to complete
+            # current test immediatelly without waiting
+            await self._stop_sut()
+
         if self._scheduler:
             await self._scheduler.stop()
 
-        await self._stop_sut()
+        if self._stop_cnt < 1:
+            await self._stop_sut()
 
     async def stop(self) -> None:
         """
         Stop the current session.
         """
-        self._stop = True
+        async with self._stop_lock:
+            self._stop_cnt += 1
+
         try:
             await self._inner_stop()
 
@@ -385,8 +394,12 @@ async def stop(self) -> None:
             async with self._exec_lock:
                 pass
         finally:
-            await libkirk.events.fire("session_stopped")
-            self._stop = False
+            if self._stop_cnt == 1:
+                await libkirk.events.fire("session_stopped")
+            elif self._stop_cnt > 1:
+                await libkirk.events.fire("session_killed")
+
+            self._stop_cnt = 0
 
     async def _schedule_once(self, suites_obj: List[Suite]) -> None:
         """
@@ -403,7 +416,7 @@ async def _schedule_infinite(self, suites_obj: List[Suite]) -> None:
         suites_list.extend(suites_obj)
 
         count = 1
-        while not self._stop:
+        while self._stop_cnt == 0:
             await self._schedule_once(suites_obj)
             if self._scheduler.stopped:
                 break
@@ -516,7 +529,7 @@ async def run(
 
                     await self._run_scheduler(suites_obj, runtime)
             except KirkException as err:
-                if not self._stop:
+                if self._stop_cnt == 0:
                     self._logger.exception(err)
                     await libkirk.events.fire("session_error", str(err))
                     raise err

libkirk/tests/test_session.py

@@ -86,6 +86,25 @@ async def stop():
             ]
         )
 
+    async def test_run_force_stop(self, session):
+        """
+        Test stop method when it's called twice. We just ensure that the
+        session implementation won't crash or generate exceptions and it will
+        forcibly stop the current run.
+        """
+
+        async def stop():
+            await asyncio.sleep(0.1)
+            await session.stop()
+
+        await asyncio.gather(
+            *[
+                session.run(suites=["sleep"]),
+                stop(),
+                stop(),
+            ]
+        )
+
     async def test_run_command(self, session):
         """
         Test run method when running a single command.

libkirk/ui.py

@@ -46,6 +46,7 @@ def __init__(self, no_colors: bool = False) -> None:
         libkirk.events.register("session_restore", self.session_restore)
         libkirk.events.register("session_started", self.session_started)
         libkirk.events.register("session_stopped", self.session_stopped)
+        libkirk.events.register("session_killed", self.session_killed)
         libkirk.events.register("sut_start", self.sut_start)
         libkirk.events.register("sut_stop", self.sut_stop)
         libkirk.events.register("sut_restart", self.sut_restart)
@@ -128,6 +129,9 @@ async def session_started(self, tmpdir: str) -> None:
     async def session_stopped(self) -> None:
         await self._print("Session stopped")
 
+    async def session_killed(self) -> None:
+        await self._print("Session killed")
+
     async def sut_start(self, sut: str) -> None:
         await self._print(f"Connecting to SUT: {sut}")