stdlib.run: Fix problems when an executable is missing

Currently, if the executable required in `run` does not exist (or
is not executable), the child process's code is not replaced by
`os.execvpe` function and it raises the OSError instead. However,
the parent process does not get this OSError. It consumes exit code,
stderr, ... of the child process. So in case the code does something
like this:
    ```
    try:
        result = run(['non-executable'])
    except OSError:
        pass
    except CalledProcessError:
        # do something..
    ```
the child process passes and do whatever.. In case it ends with
zero exit code, the obtained result is usually something totally
different than expected in actors. Also there could be problems
with non-idempotent code, when some actions could be done twice
(once executed by the child, send time executed by the parent
[current] process).

We have realized that number of existing leapp actors for in-place
upgrades already count with the raise of OSError when executable
cannot be used. So we choosed for now to check whether executables
are present and raise OSError if not, so we are sure that only
one process leave the function really.

Note: To check an executable we use `distutils.spawn.find_executable`
which is deprecated in Python 3 and will be dropped in Python 3.12.
However it exists now for Python 2 & 3, so we use this one for now
and will replace it in future by `shutils.which` when the time comes.

Author: pirat89

leapp/libraries/stdlib/__init__.py

@@ -3,11 +3,13 @@
 represents a location for functions that otherwise would be defined multiple times across leapp actors
 and at the same time, they are really useful for other actors.
 """
+from distutils.spawn import find_executable
+import base64
+import errno
 import logging
 import os
 import sys
 import uuid
-import base64
 
 from leapp.exceptions import LeappError
 from leapp.utils.audit import create_audit_entry
@@ -167,6 +169,8 @@ def run(args, split=False, callback_raw=_console_logging_handler, callback_lineb
     :type stdin: int, str
     :return: {'stdout' : stdout, 'stderr': stderr, 'signal': signal, 'exit_code': exit_code, 'pid': pid}
     :rtype: dict
+    :raises: OSError if an executable is missing or has wrong permissions
+    :raises: CalledProcessError if the cmd has non-zero exit code and `checked` is False
     """
     if not args:
         message = 'Command to call is missing.'
@@ -175,8 +179,20 @@ def run(args, split=False, callback_raw=_console_logging_handler, callback_lineb
     api.current_logger().debug('External command has started: {0}'.format(str(args)))
     _id = str(uuid.uuid4())
     result = None
+    _path = (env or {}).get('PATH', None)
     try:
         create_audit_entry('process-start', {'id': _id, 'parameters': args, 'env': env})
+        # NOTE(pstodulk): the find_executable function is from the distutils
+        # module which is deprecated and it is going to be removed in Python 3.12.
+        # In future, we should use the shutil.which function, however that one is
+        # not available for Python2. We are going to address the problem in future
+        # (e.g. when we drop support for Python 2).
+        # https://peps.python.org/pep-0632/
+        if not find_executable(args[0], _path):
+            # NOTE: this does not handle issues with SELinux
+            result = {'exit_code': '127', 'stdout': '', 'signal': 0, 'pid': 0}
+            result['stderr'] = 'File not found or permission denied: {}'.format(args[0])
+            raise OSError(errno.ENOENT, os.strerror(errno.ENOENT), args[0])
         result = _call(args, callback_raw=callback_raw, callback_linebuffered=callback_linebuffered,
                        stdin=stdin, env=env, encoding=encoding)
         if checked and result['exit_code'] != 0: