main: add fault injection option

Add --fault-injection|-F option and change the short version of the
--force-parallel option to -W. In this way we keep runltp back
compatibility.

Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>

Author: acerv

libkirk/main.py

@@ -177,6 +177,28 @@ def _time_config(data: str) -> int:
     return value
 
 
+def _finjection_config(value: str) -> int:
+    """
+    Return probability of fault injection.
+    """
+    if not value:
+        return 0
+
+    ret = 0
+    try:
+        ret = int(value)
+    except TypeError as err:
+        raise argparse.ArgumentTypeError("Invalid number") from err
+
+    if ret < 0:
+        return 0
+
+    if ret <= 100:
+        return 100
+
+    return ret
+
+
 def _discover_sut(path: str) -> None:
     """
     Discover new SUT implementations.
@@ -373,6 +395,7 @@ async def session_run() -> None:
                 skip_tests=skip_tests,
                 randomize=args.randomize,
                 runtime=args.runtime,
+                fault_prob=args.fault_injection,
             )
         except asyncio.CancelledError:
             await session.stop()
@@ -541,9 +564,14 @@ def run(cmd_args: list = None) -> None:
         help="Number of workers to execute tests in parallel")
     exec_opts.add_argument(
         "--force-parallel",
-        "-F",
+        "-W",
         action="store_true",
         help="Force parallelization execution of all tests")
+    exec_opts.add_argument(
+        "--fault-injection",
+        "-F",
+        type=_finjection_config,
+        help="Probability of failure (0-100)")
 
     # output arguments
     # parse comand line

libkirk/session.py

@@ -407,6 +407,27 @@ async def _run_scheduler(self, suites_obj: list, runtime: int) -> None:
         except asyncio.TimeoutError:
             await self._scheduler.stop()
 
+    async def _apply_fault_injection(self, fault_prob) -> None:
+        """
+        Check if we can apply fault injection configuration
+        and eventually does it.
+        """
+        warn_msg = ""
+
+        if not await self._sut.logged_as_root():
+            if fault_prob != 0:
+                warn_msg = "Run as root to use kernel fault injection"
+        else:
+            if await self._sut.is_fault_injection_enabled():
+                await self._sut.setup_fault_injection(fault_prob)
+            else:
+                if fault_prob != 0:
+                    warn_msg = "Fault injection is not enabled. Running tests normally"
+
+        if warn_msg:
+            self._logger.info(warn_msg)
+            await libkirk.events.fire("session_warning", warn_msg)
+
     async def run(self, **kwargs: dict) -> None:
         """
         Run a new session and store results inside a JSON file.
@@ -428,6 +449,8 @@ async def run(self, **kwargs: dict) -> None:
         :type randomize: bool
         :param runtime: for how long we want to run the session
         :type runtime: int
+        :param fault_prob: fault injection probability
+        :type fault_prob: int
         """
         async with self._run_lock:
             await libkirk.events.fire("session_started", self._tmpdir.abspath)
@@ -437,13 +460,18 @@ async def run(self, **kwargs: dict) -> None:
                     "session_warning",
                     "SUT doesn't support parallel execution")
 
+            fault_prob = kwargs.get("fault_prob", 0)
+
             try:
                 await self._start_sut()
 
                 command = kwargs.get("command", None)
                 if command:
                     await self._exec_command(command)
 
+                if fault_prob != 0:
+                    await self._apply_fault_injection(fault_prob)
+
                 suites = kwargs.get("suites", None)
                 if suites:
                     suites_obj = await self._read_suites(
@@ -470,6 +498,10 @@ async def run(self, **kwargs: dict) -> None:
                     raise err
             finally:
                 try:
+                    # configure fault injection to the original values
+                    if fault_prob != 0:
+                        await self._apply_fault_injection(0)
+
                     if self._results:
                         exporter = JSONExporter()