Merge branch 'development'

Author: karel26

core/data/impl/serverimpl.py

@@ -12,6 +12,7 @@
 import shutil
 import sys
 import tempfile
+import time
 import traceback
 
 if sys.platform == 'win32':
@@ -39,7 +40,8 @@
 from psycopg.errors import UndefinedTable
 from typing import TYPE_CHECKING, Any, Iterable
 from typing_extensions import override
-from watchdog.events import FileSystemEventHandler, FileSystemEvent, FileSystemMovedEvent
+from watchdog.events import (FileSystemEventHandler, DirCreatedEvent, FileCreatedEvent, DirDeletedEvent,
+                             FileDeletedEvent, DirMovedEvent, FileMovedEvent)
 from watchdog.observers import Observer, ObserverType
 
 # ruamel YAML support
@@ -59,34 +61,74 @@
 
 
 class MissionFileSystemEventHandler(FileSystemEventHandler):
-    def __init__(self, server: Server, loop: asyncio.AbstractEventLoop):
+    DEBOUNCE_WINDOW = 2.0           # seconds
+    TEMP_SUFFIXES = ('.tmp', '.part', '.swp', '~')
+    IGNORE_PREFIX = '.'             # hidden files
+
+    def __init__(self, server, loop):
+        super().__init__()
         self.server = server
         self.log = server.log
         self.loop = loop
         self.deleted: dict[str, int] = {}
+        self._seen: dict[str, float] = {}
 
-    @override
-    def on_created(self, event: FileSystemEvent):
-        path: str = os.path.normpath(event.src_path)
-        # ignore non-mission files and such that are in the .dcssb folder
-        if not (path.endswith('.miz') or path.endswith('.sav')) or '.dcssb' in path:
+    def _is_debounced(self, path):
+        now = time.monotonic()
+        last = self._seen.get(path, 0)
+        if now - last < self.DEBOUNCE_WINDOW:
+            return True
+        self._seen[path] = now
+        return False
+
+    def _is_valid_mission_file(self, path):
+        name = os.path.basename(path)
+        if name.startswith(self.IGNORE_PREFIX):
+            return False
+        if any(name.endswith(suf) for suf in self.TEMP_SUFFIXES):
+            return False
+        return path.endswith('.miz') or path.endswith('.sav')
+
+    def _wait_for_stable_file(self, path, timeout=5.0):
+        start = time.monotonic()
+        while time.monotonic() - start < timeout:
+            try:
+                size1 = os.path.getsize(path)
+            except FileNotFoundError:
+                return False
+            time.sleep(0.5)
+            try:
+                size2 = os.path.getsize(path)
+            except FileNotFoundError:
+                return False
+            if size1 == size2:
+                return True
+        return False
+
+    # ----------------------------------------------------------------------
+    # Core handlers
+    # ----------------------------------------------------------------------
+    def on_created(self, event: DirCreatedEvent | FileCreatedEvent) -> None:
+        path = os.path.normpath(event.src_path)
+        if not self._is_valid_mission_file(path):
+            return
+        if self._is_debounced(path):
             return
+
+        if not self._wait_for_stable_file(path):
+            self.log.warning(f"File {path} never stabilized – skipping.")
+            return
+
         if path in self.deleted:
-            asyncio.run_coroutine_threadsafe(self.server.addMission(path, idx=self.deleted[path]), self.loop)
-            del self.deleted[path]
+            idx = self.deleted.pop(path)
+            asyncio.run_coroutine_threadsafe(self.server.addMission(path, idx=idx), self.loop)
         else:
             asyncio.run_coroutine_threadsafe(self.server.addMission(path), self.loop)
-        self.log.info(f"=> New mission {os.path.basename(path)[:-4]} added to server {self.server.name}.")
 
-    @override
-    def on_moved(self, event: FileSystemMovedEvent):
-        self.on_deleted(event)
-        self.on_created(FileSystemEvent(event.dest_path))
+        self.log.info(f"=> New mission {os.path.basename(path)[:-4]} added to server {self.server.name}.")
 
-    @override
-    def on_deleted(self, event: FileSystemEvent):
-        path: str = os.path.normpath(event.src_path)
-        # ignore non-mission files
+    def on_deleted(self, event: DirDeletedEvent | FileDeletedEvent) -> None:
+        path = os.path.normpath(event.src_path)
         if not path.endswith('.miz'):
             return
         missions = self.server.settings['missionList']
@@ -97,13 +139,15 @@ def on_deleted(self, event: FileSystemEvent):
         if path in missions:
             idx = missions.index(path) + 1
             asyncio.run_coroutine_threadsafe(self.server.deleteMission(idx), self.loop)
-            # cache the index of the line to re-add the file at the correct position afterward
-            # if a cloud drive did a delete/add instead of a modification
             self.deleted[path] = idx
             self.log.info(f"=> Mission {os.path.basename(path)[:-4]} deleted from server {self.server.name}.")
         else:
             self.log.debug(f"Mission file {path} got deleted from disk.")
 
+    def on_moved(self, event: DirMovedEvent | FileMovedEvent) -> None:
+        self.on_deleted(event)
+        self.on_created(event)
+
 
 @dataclass
 @DataObjectFactory.register()
@@ -156,7 +200,7 @@ def settings(self) -> dict:
             # if someone managed to destroy the mission list, fix it...
             if 'missionList' not in self._settings:
                 self._settings['missionList'] = []
-                self._settings['listStartIndex'] = 0
+                self._settings['listStartIndex'] = self.settings['current'] = 0
             elif isinstance(self._settings['missionList'], dict):
                 self._settings['missionList'] = list(self._settings['missionList'].values())
         return self._settings
@@ -232,7 +276,7 @@ def _make_missions_unique(self):
                 new_start = self._settings['missionList'].index(current_mission)
             except ValueError:
                 new_start = 0
-            self._settings['listStartIndex'] = new_start + 1
+            self._settings['listStartIndex'] = self._settings['current'] = new_start + 1
 
     async def _load_mission_list(self):
         try:
@@ -257,8 +301,7 @@ def set_status(self, status: Status | str):
             if self._status == Status.UNREGISTERED and status == Status.SHUTDOWN:
                 if self.locals.get('autoscan', False):
                     self._init_mission_list()
-                else:
-                    self._make_missions_unique()
+                self._make_missions_unique()
             elif self._status in [Status.UNREGISTERED, Status.LOADING] and new_status in [Status.RUNNING, Status.PAUSED]:
                 # only check the mission list if we started that server
                 if self._status == Status.LOADING:
@@ -551,7 +594,7 @@ def do_startup(self):
                     idx = missions.index(start_mission) + 1
                 except ValueError:
                     idx = 1
-                self.settings['listStartIndex'] = idx
+                self.settings['listStartIndex'] = self.settings['current'] = idx
             self.log.warning('Removed non-existent missions from serverSettings.lua')
         self.log.debug(r'Launching DCS server with: "{}" --server --norender -w {}'.format(path, self.instance.name))
         try:
@@ -1059,8 +1102,7 @@ async def loadMission(self, mission: int | str, modify_mission: bool | None = Tr
         if self.status == Status.STOPPED:
             try:
                 idx = mission_list.index(filename) + 1
-                self.settings['listStartIndex'] = idx
-                self.settings['current'] = idx
+                self.settings['listStartIndex'] = self.settings['current'] = idx
                 return await self.start()
             except ValueError:
                 return False

extensions/olympus/extension.py

@@ -12,7 +12,6 @@
 import sys
 
 from core import utils, Server, get_translation, PortType, Port, ProcessManager, InstallableExtension
-from packaging.version import Version, InvalidVersion
 from threading import Thread
 from typing import cast
 from typing_extensions import override
@@ -81,6 +80,8 @@ def __init__(self, server: Server, config: dict):
                     instance=server.instance.name
                 )
                 self.log.debug("- Running Olympus process found.")
+        else:
+            self.process = None
 
         if self.version == '1.0.3':
             self.backend_tag = 'server'

plugins/admin/commands.py

@@ -476,7 +476,13 @@ async def repair(self, interaction: discord.Interaction,
                      slow: bool | None = False, check_extra_files: bool | None = False,
                      warn_time: app_commands.Range[int, 0] = 60):
         ephemeral = utils.get_ephemeral(interaction)
-        await interaction.response.defer(thinking=True, ephemeral=ephemeral)
+        if not await utils.yn_question(
+                interaction,
+                _("Do you want to run a DCS World repair on node {name}?").format(name=node.name)
+        ):
+            await interaction.followup.send(_("Aborted."))
+            return
+
         await self.bot.audit(f"started a repair of DCS World on node {node.name}.", user=interaction.user)
         msg = await interaction.followup.send(_("Repairing DCS World, please wait ..."), ephemeral=ephemeral)
         try:

plugins/discord/commands.py

@@ -3,11 +3,13 @@
 from core import Plugin, command, utils, get_translation, Group
 from datetime import timedelta
 from discord import app_commands, Permissions
+from discord.abc import GuildChannel
 from discord.ext import commands
-
-from plugins.discord.views import HealthcheckView
 from services.bot import DCSServerBot
 from services.cron.actions import purge_channel
+from typing import cast
+
+from .views import HealthcheckView
 
 _ = get_translation(__name__.split('.')[1])
 
@@ -30,7 +32,10 @@ async def on_ready(self):
             if config['ping_everyone'].get('timeout', False) and not self.bot.member.guild_permissions.moderate_members:
                 self.log.warning(f"{self.__class__.__name__}: Bot is missing permission to timeout members!")
         if 'reaction' in config:
-            channel = self.bot.get_channel(config['reaction']['channel'])
+            channel: GuildChannel | None = cast(GuildChannel, self.bot.get_channel(config['reaction']['channel']))
+            if not channel:
+                self.log.warning(f"{self.__class__.__name__}: Reaction channel {config['reaction']['channel']} not found!")
+                return
             message = await self.bot.fetch_embed('reaction', channel)
             if not message:
                 guild = self.bot.guilds[0]

plugins/greenieboard/listener.py

@@ -158,15 +158,15 @@ async def process_lso_event(self, config: dict, server: Server, player: Player,
         case = data.get('case', 1 if not night else 3)
         wire = data.get('wire')
         async with self.apool.connection() as conn:
-            min_flight_time = self.get_config(server).get('min_flight_time')
+            min_flight_time: int | None = self.get_config(server).get('min_flight_time')
             if min_flight_time:
                 cursor = await conn.execute("""
-                    SELECT EXTRACT(EPOCH FROM (NOW() AT TIME ZONE 'utc' - MAX(time))) FROM missionstats 
+                    SELECT COALESCE(EXTRACT(EPOCH FROM (NOW() AT TIME ZONE 'utc' - MAX(time))), 9999) FROM missionstats 
                     WHERE mission_id = %s 
                     AND init_id = %s 
                     AND event = 'S_EVENT_TAKEOFF'
                 """, (server.mission_id, player.ucid))
-                flight_time = await cursor.fetchone()
+                flight_time: tuple[float] | None = await cursor.fetchone()
                 if flight_time and flight_time[0] < min_flight_time:
                     # ignore this event, as the player has not flown for the minimum flight time
                     self.log.debug(f"Greenieboard: Player {player.name} has not flown for the minimum flight time.")

plugins/mission/commands.py

@@ -1435,8 +1435,10 @@ async def wstypes(self, interaction: discord.Interaction,
     async def _list(self, interaction: discord.Interaction,
                     server: app_commands.Transform[Server, utils.ServerTransformer(status=[Status.RUNNING])]):
         if server.status != Status.RUNNING:
-            await interaction.response.send_message(_("Server {} is not running.").format(server.display_name),
-                                                    ephemeral=True)
+            await interaction.response.send_message(
+                _("Server {} is {}.").format(server.display_name, server.status.value.lower()),
+                ephemeral=True
+            )
             return
         report = Report(self.bot, self.plugin_name, 'players.json')
         env = await report.render(server=server, sides=utils.get_sides(interaction.client, interaction, server))

plugins/mission/listener.py

@@ -887,7 +887,7 @@ async def _stop_player(self, server: Server, player: Player):
 
     @event(name="onPlayerStop")
     async def onPlayerStop(self, server: Server, data: dict) -> None:
-        if data['id'] == 1:
+        if data['id'] == 1 or 'ucid' not in data:
             return
         player = server.get_player(ucid=data['ucid'])
         if player:

plugins/missionstats/listener.py

@@ -264,14 +264,21 @@ async def onMissionEvent(self, server: Server, data: dict) -> None:
             # TODO: rewrite that code, so the initiator is not needed
             win_coalition = self.COALITION[data['initiator']['coalition']]
             lose_coalition = self.COALITION[(data['initiator']['coalition'] % 2) + 1]
-            name = data['place']['name']
+            name = data.get('place', {}).get('name')
+            # in the unlikely event that we do not have a name, return
+            if not name:
+                return
             # workaround for DCS base capture bug:
-            if name in stats['coalitions'][win_coalition.name]['airbases'] or \
-                    name not in stats['coalitions'][lose_coalition.name]['airbases']:
+            if (
+                    name in stats['coalitions'][win_coalition.name]['airbases'] or
+                    name not in stats['coalitions'][lose_coalition.name]['airbases']
+            ):
                 return
 
             wc = stats['coalitions'][win_coalition.name]
-            wc.setdefault('airbases', []).append(name)
+            if not wc.get('airbases'):
+                wc['airbases'] = []
+            wc['airbases'].append(name)
             wc['captures'] = wc.get('captures', 0) + 1
             lc = stats['coalitions'][lose_coalition.name]
             if name in lc['airbases']:

plugins/punishment/listener.py

@@ -82,6 +82,7 @@ def missile_threat_score(self, distance_old: float, age_s: float, weapon: str |
 
         v_avrg = params["v_avrg"]
         p_dstr = params["p_dstr"]
+        d_max = params["d_max"]
 
         if distance_old <= 0 or age_s < 0:
             return 0.0
@@ -90,7 +91,19 @@ def missile_threat_score(self, distance_old: float, age_s: float, weapon: str |
         if distance_new <= 0:
             return 0.0
 
-        return distance_new * p_dstr
+        # Up to d_max, keep the configured endgame probability.
+        if distance_old <= d_max:
+            energy_factor = 1.0
+        else:
+            # Past d_max, missile energy gradually decays.
+            # At roughly 3.5x d_max, consider the missile out of useful energy.
+            max_energy_range = d_max * 3.5
+            if distance_old >= max_energy_range:
+                return 0.0
+
+            energy_factor = 1.0 - ((distance_old - d_max) / (max_energy_range - d_max))
+
+        return p_dstr * energy_factor
 
     def is_missile_hot(self, distance_m: float, age_s: float, weapon: str | None) -> bool:
         return self.missile_threat_score(distance_m, age_s, weapon) >= 0.15
@@ -543,10 +556,11 @@ async def onMissionEvent(self, server: Server, data: dict) -> None:
                 return
 
             shot_time, s_event = self.pending_kill.get(target.ucid, (-1, None))
+            now = int(time.time())
             if data['eventName'] == 'S_EVENT_SHOT':
                 # if there is an older shot ...
                 if shot_time > 0 and s_event:
-                    delta_time = int(time.time()) - shot_time
+                    delta_time = now - shot_time
                     if s_event.get('eventName') == 'S_EVENT_HIT':
                         # we do not overwrite hit events with shot events if they are still hot
                         if delta_time < config.get('survival_window', 300):
@@ -576,7 +590,7 @@ async def onMissionEvent(self, server: Server, data: dict) -> None:
                                    f"where player {orig_name} was predicted.")
 
             # store the shot with the highest PBK or the latest hit event
-            self.pending_kill[target.ucid] = (int(time.time()), data)
+            self.pending_kill[target.ucid] = (now, data)
 
         elif data['eventName'] == 'S_EVENT_LAND':
             initiator = server.get_player(name=data.get('initiator', {}).get('name'))

plugins/scheduler/commands.py

@@ -1229,10 +1229,12 @@ async def config(self, interaction: discord.Interaction,
         ephemeral = utils.get_ephemeral(interaction)
         await interaction.response.defer(ephemeral=ephemeral)
 
+        stopped = False
         if server.status in [Status.RUNNING, Status.PAUSED]:
             if await utils.yn_question(interaction, question='Server has to be stopped to change its configuration.\n'
                                                              'Do you want to stop it?'):
                 await server.stop()
+                stopped = True
             else:
                 await interaction.followup.send('Aborted.')
                 return
@@ -1252,6 +1254,12 @@ async def config(self, interaction: discord.Interaction,
                     await server.update_channels(channels)
                 await interaction.followup.send(f'Server configuration for server "{server.display_name}" updated.',
                                                 ephemeral=ephemeral)
+            if stopped:
+                await server.start()
+        except (asyncio.TimeoutError, TimeoutError):
+            await interaction.followup.send(f'Timeout while starting server "{server.display_name}".\n'
+                                            f'Please check the server manually.',
+                                            ephemeral=ephemeral)
         finally:
             try:
                 await msg.delete()