ENHANCEMENTS:

- New command /dcs repair

Author: karel26

core/data/impl/nodeimpl.py

@@ -167,6 +167,10 @@ async def __aenter__(self):
         # check Python-version
         self.log.info(f'- Python version {platform.python_version()} detected.')
 
+        # check UAC
+        if utils.is_uac_enabled():
+            self.log.warning('- You need to disable User Access Control (UAC) to allow some commands to run.')
+
         # install plugins
         await self._install_plugins()
 
@@ -629,40 +633,115 @@ def run_subprocess() -> int:
                 message = _('Server is going down for a DCS update in {}!')
         ):
             self.log.info(f"Updating {self.installation} ...")
-            # call before update hooks
+            # call before_update hooks
             for callback in self.before_update.values():
                 await callback()
-            old_branch, old_version = await self.get_dcs_branch_and_version()
-            if not branch:
-                branch = old_branch
-            if not version:
-                version = await self.get_latest_version(branch)
-            rc = await do_update(branch, version)
-            if rc in [0, 350]:
-                self.dcs_branch = self.dcs_version = None
-                dcs_branch, dcs_version = await self.get_dcs_branch_and_version()
-                # if only the updater updated itself, run the update again
-                if old_branch == dcs_branch and old_version == dcs_version:
-                    self.log.info("dcs_updater.exe updated to the latest version, now updating DCS World ...")
-                    rc = await do_update(branch, version)
+            try:
+                old_branch, old_version = await self.get_dcs_branch_and_version()
+                if not branch:
+                    branch = old_branch
+                if not version:
+                    version = await self.get_latest_version(branch)
+                rc = await do_update(branch, version)
+                if rc in [0, 350]:
                     self.dcs_branch = self.dcs_version = None
-                    await self.get_dcs_branch_and_version()
-                    if rc not in [0, 350]:
-                        return rc
-                # Patch DCS files
-                if not self.locals['DCS'].get('cloud', False) or self.master:
-                    if self.locals['DCS'].get('desanitize', True):
-                        utils.desanitize(self)
-                    # init profanity filter, if needed
-                    if any(
-                            instance.server.locals.get('profanity_filter', False)
-                            for instance in self.instances if instance.server
-                    ):
-                        utils.init_profanity_filter(self)
-                # call after update hooks
+                    dcs_branch, dcs_version = await self.get_dcs_branch_and_version()
+                    # if only the updater updated itself, run the update again
+                    if old_branch == dcs_branch and old_version == dcs_version:
+                        self.log.info("dcs_updater.exe updated to the latest version, now updating DCS World ...")
+                        rc = await do_update(branch, version)
+                        self.dcs_branch = self.dcs_version = None
+                        await self.get_dcs_branch_and_version()
+                        if rc not in [0, 350]:
+                            return rc
+                    # Patch DCS files
+                    if not self.locals['DCS'].get('cloud', False) or self.master:
+                        if self.locals['DCS'].get('desanitize', True):
+                            utils.desanitize(self)
+                        # init profanity filter, if needed
+                        if any(
+                                instance.server.locals.get('profanity_filter', False)
+                                for instance in self.instances if instance.server
+                        ):
+                            utils.init_profanity_filter(self)
+                    self.log.info(f"{self.installation} updated to version {dcs_version}.")
+                return rc
+            finally:
+                # call after_update hooks
+                for callback in self.after_update.values():
+                    await callback()
+                self.update_pending = False
+
+    async def dcs_repair(self, warn_times: list[int] = None, slow: bool | None = False,
+                         check_extra_files: bool | None = False):
+
+        async def do_repair() -> int:
+            def run_subprocess() -> int:
+                if sys.platform != 'win32':
+                    raise NotImplementedError("DCS repair is not yet supported on Linux")
+
+                if utils.is_uac_enabled():
+                    raise PermissionError("You need to disable UAC to run a DCS repair.")
+
+                args = [
+                    "core/utils/updater_wrapper.py",
+                    "-d", os.path.normpath(self.installation),
+                ]
+                if slow:
+                    args.append("-s")
+                if check_extra_files:
+                    args.append("-c")
+                cmdline = subprocess.list2cmdline(args)
+                return utils.run_elevated(
+                    sys.executable,
+                    os.getcwd(),
+                    cmdline
+                )
+
+            # check if there is an update / repair running already
+            proc = next(utils.find_process("DCS_updater.exe"), None)
+            if proc:
+                self.log.info("- DCS Update / repair in progress, waiting ...")
+                while proc.is_running():
+                    await asyncio.sleep(1)
+
+            return await asyncio.to_thread(run_subprocess)
+
+        self.update_pending = True
+        async with ServerMaintenanceManager(
+                self.node,
+                warn_times = warn_times,
+                message = _('Server is going down for maintenance in {}!')
+        ):
+            self.log.info(f"Repairing {self.installation} ...")
+            # call before_update hooks
+            for callback in self.before_update.values():
+                await callback()
+            try:
+                rc = await do_repair()
+                if rc == 0:
+                    # Patch DCS files
+                    if not self.locals['DCS'].get('cloud', False) or self.master:
+                        if self.locals['DCS'].get('desanitize', True):
+                            utils.desanitize(self)
+                        # init profanity filter, if needed
+                        if any(
+                                instance.server.locals.get('profanity_filter', False)
+                                for instance in self.instances if instance.server
+                        ):
+                            utils.init_profanity_filter(self)
+                    self.log.info(f"{self.installation} repaired.")
+                else:
+                    self.log.error(f"Repair of {self.installation} failed with code {rc}.")
+            except PermissionError:
+                raise
+            except OSError as ex:
+                self.log.error(f"Repair of {self.installation} failed with code {ex.errno}.")
+                return ex.errno
+            finally:
+                # call after_update hooks
                 for callback in self.after_update.values():
                     await callback()
-                self.log.info(f"{self.installation} updated to version {dcs_version}.")
                 self.update_pending = False
             return rc
 

core/data/node.py

@@ -159,6 +159,9 @@ async def dcs_update(self, branch: Optional[str] = None, version: Optional[str]
                          warn_times: list[int] = None, announce: Optional[bool] = True):
         raise NotImplementedError()
 
+    async def dcs_repair(self, warn_times: list[int] = None):
+        raise NotImplementedError()
+
     async def get_dcs_branch_and_version(self) -> tuple[str, str]:
         raise NotImplementedError()
 

core/data/proxy/nodeproxy.py

@@ -120,6 +120,20 @@ async def dcs_update(self, branch: Optional[str] = None, version: Optional[str]
         }, node=self.name, timeout=600)
         return data['return']
 
+    async def dcs_repair(self, warn_times: list[int] = None, slow: bool | None = False,
+                         check_extra_files: bool | None = False):
+        data = await self.bus.send_to_node_sync({
+            "command": "rpc",
+            "object": "Node",
+            "method": "repair",
+            "params": {
+                "warn_times": warn_times,
+                "slow": slow,
+                "check_extra_files": check_extra_files
+            }
+        }, node=self.name, timeout=600)
+        return data['return']
+
     @cache_with_expiration(expiration=30)
     async def get_dcs_branch_and_version(self) -> tuple[str, str]:
         timeout = 60 if not self.slow_system else 120

core/utils/os.py

@@ -14,12 +14,6 @@
 import subprocess
 import sys
 
-if sys.platform == 'win32':
-    import ctypes
-    import pywintypes
-    import win32api
-    import win32console
-
 from contextlib import closing, suppress
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
@@ -28,6 +22,15 @@
 if TYPE_CHECKING:
     from core import Node
 
+if sys.platform == 'win32':
+    import ctypes
+    import pywintypes
+    import win32api
+    import win32console
+    import winreg
+
+    from pywinauto.win32defines import SEE_MASK_NOCLOSEPROCESS, SW_HIDE
+
 API_URLS = [
     'https://api4.my-ip.io/ip',
     'https://api4.ipify.org/'
@@ -57,7 +60,9 @@
     "sanitize_filename",
     "is_upnp_available",
     "get_win32_error_message",
-    "CloudRotatingFileHandler"
+    "CloudRotatingFileHandler",
+    "run_elevated",
+    "is_uac_enabled"
 ]
 
 logger = logging.getLogger(__name__)
@@ -223,8 +228,11 @@ def terminate_process(process: Optional[psutil.Process]):
             process.wait(timeout=3)
 
 
-def quick_edit_mode(turn_on=None):
+def quick_edit_mode(turn_on=None) -> bool:
     """ Enable/Disable windows console Quick Edit Mode """
+    if sys.platform != 'win32':
+        return False
+
     screen_buffer = win32console.GetStdHandle(-10)
     orig_mode = screen_buffer.GetConsoleMode()
     is_on = (orig_mode & ENABLE_QUICK_EDIT_MODE)
@@ -300,8 +308,11 @@ def sanitize_filename(filename: str, base_directory: str) -> str:
     return resolved_path
 
 
-def get_win32_error_message(error_code: int):
+def get_win32_error_message(error_code: int) -> str:
     # Load the system message corresponding to the error code
+    if sys.platform != 'win32':
+        return ""
+
     buffer = ctypes.create_unicode_buffer(512)
     ctypes.windll.kernel32.FormatMessageW(
         0x00001000,  # FORMAT_MESSAGE_FROM_SYSTEM
@@ -345,3 +356,76 @@ def shouldRollover(self, record):
             if log_file_size >= self.maxBytes:
                 return 1
         return 0
+
+
+class SHELLEXECUTEINFO(ctypes.Structure):
+    _fields_ = [
+        ("cbSize",        ctypes.c_ulong),
+        ("fMask",         ctypes.c_ulong),
+        ("hwnd",          ctypes.c_void_p),
+        ("lpVerb",        ctypes.c_wchar_p),
+        ("lpFile",        ctypes.c_wchar_p),
+        ("lpParameters",  ctypes.c_wchar_p),
+        ("lpDirectory",   ctypes.c_wchar_p),
+        ("nShow",         ctypes.c_int),
+        ("hInstApp",      ctypes.c_void_p),
+        ("lpIDList",      ctypes.c_void_p),
+        ("lpClass",       ctypes.c_wchar_p),
+        ("hkeyClass",     ctypes.c_void_p),
+        ("dwHotKey",      ctypes.c_ulong),
+        ("hIcon",         ctypes.c_void_p),
+        ("hProcess",      ctypes.c_void_p),
+    ]
+
+
+def run_elevated(exe_path, cwd, *args):
+    """Start *exe_path* as Administrator and return the return code."""
+    if sys.platform != 'win32':
+        return -1
+
+    sei = SHELLEXECUTEINFO()
+    sei.cbSize = ctypes.sizeof(sei)
+    sei.fMask  = SEE_MASK_NOCLOSEPROCESS
+    sei.lpVerb = "runas"
+    sei.lpFile = os.path.abspath(exe_path)
+    sei.lpDirectory = os.path.abspath(cwd)
+    sei.lpParameters = ' '.join(map(str, args))
+    sei.nShow = SW_HIDE
+
+    # noinspection PyUnresolvedReferences
+    if not ctypes.windll.shell32.ShellExecuteExW(ctypes.byref(sei)):
+        raise ctypes.WinError()
+
+    hproc = sei.hProcess
+    # noinspection PyUnresolvedReferences
+    ctypes.windll.kernel32.WaitForSingleObject(hproc, ctypes.c_ulong(-1))
+
+    exit_code = ctypes.c_ulong()
+    # noinspection PyUnresolvedReferences
+    ctypes.windll.kernel32.GetExitCodeProcess(hproc, ctypes.byref(exit_code))
+
+    return int(exit_code.value)
+
+
+def is_uac_enabled() -> bool:
+    """Return True if UAC is enabled; False if it is disabled."""
+    if sys.platform != 'win32':
+        # non Win32 systems don't have a UAC, but need to tackle permissions differently
+        return False
+    try:
+        with winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"Software\Microsoft\Windows\CurrentVersion\Policies\System",
+            0,
+            winreg.KEY_READ | winreg.KEY_WOW64_64KEY,
+        ) as key:
+            # check if UAC is enabled at all
+            lua_enabled, _ = winreg.QueryValueEx(key, 'EnableLUA')
+            if lua_enabled == 0:
+                return False
+            # now check if we get prompted (if not, treat UAC as disabled)
+            admin_behaviour, _ = winreg.QueryValueEx(key, "ConsentPromptBehaviorAdmin")
+            return admin_behaviour > 0          # > 0 => True, 0 = False
+    except (FileNotFoundError, PermissionError):
+        # if not found or permission is denied, fall back to a safe default.
+        return True