Merge branch 'development'

Author: karel26

core/data/impl/nodeimpl.py

@@ -506,19 +506,27 @@ async def upgrade_pending(self) -> bool:
             self.log.debug('- No update found for DCSServerBot.')
         return rc
 
-    async def upgrade(self):
+    async def _upgrade(self, conn: psycopg.AsyncConnection):
         # We do not want to run an upgrade, if we are on a cloud drive, so just restart in this case
         if not self.master and self.locals.get('cloud_drive', True):
             await self.restart()
-            return
         elif await self.upgrade_pending():
             if self.master:
-                async with self.cpool.connection() as conn:
-                    async with conn.transaction():
-                        await conn.execute("""
-                            UPDATE cluster SET update_pending = TRUE WHERE guild_id = %s
-                        """, (self.guild_id, ))
+                await conn.execute("""
+                    UPDATE cluster SET update_pending = TRUE WHERE guild_id = %s
+                """, (self.guild_id, ))
             await self.shutdown(UPDATE)
+        elif self.master:
+            await conn.execute("""
+               UPDATE cluster
+               SET update_pending = FALSE, version = %s
+               WHERE guild_id = %s
+           """, (__version__, self.guild_id))
+
+    async def upgrade(self):
+        async with self.cpool.connection() as conn:
+            async with conn.transaction():
+                await self._upgrade(conn)
 
     async def get_dcs_branch_and_version(self) -> tuple[str, str]:
         if not self.dcs_branch or not self.dcs_version:
@@ -858,8 +866,18 @@ async def check_nodes():
                         if update_pending:
                             return await handle_upgrade(master)
                         elif parse(version) > parse(__version__):
-                            await self.upgrade()
-                            return False
+                            # avoid update loops if we are the master
+                            if master == self.name:
+                                self.master = True
+                                self.log.warning("We are the master, but the cluster seems to have a newer version.\n"
+                                                 "Rolling back the cluser version to my version.")
+                            await self._upgrade(conn)
+                        elif parse(version) < parse(__version__):
+                            if master != self.name:
+                                raise FatalException(f"This node uses DCSServerBot version {__version__} "
+                                                     f"where the master uses version {version}!")
+                            self.master = True
+                            await self._upgrade(conn)
 
                         # I am the master
                         if master == self.name:
@@ -885,6 +903,9 @@ async def check_nodes():
             current_stats = self.cpool.get_stats()
             self.log.warning(f"Pool stats: {repr(current_stats)}")
             raise
+        except FatalException as ex:
+            self.log.critical(ex)
+            exit(SHUTDOWN)
         except Exception as ex:
             self.log.exception(ex)
             raise

core/data/impl/serverimpl.py

@@ -23,7 +23,7 @@
 from core.data.dataobject import DataObjectFactory
 from core.data.const import Status, Channel, Coalition
 from core.extension import Extension, InstallException, UninstallException
-from core.mizfile import MizFile, UnsupportedMizFileException
+from core.mizfile import MizFile
 from core.data.node import UploadStatus
 from core.utils.performance import performance_log
 from dataclasses import dataclass, field
@@ -159,8 +159,7 @@ def options(self) -> dict:
     def set_instance(self, instance: Instance):
         self._instance = instance
         self.locals |= self.instance.locals
-        if self.name != 'n/a':
-            self.prepare()
+        self.prepare()
 
     def start_observer(self):
         if not self.observer:
@@ -945,7 +944,7 @@ async def replaceMission(self, mission_id: int, path: str) -> list[str]:
 
     async def loadMission(self, mission: Union[int, str], modify_mission: Optional[bool] = True,
                           use_orig: Optional[bool] = True) -> bool:
-        start_index = int(self.settings['listStartIndex'])
+        start_index = int(self.settings.get('listStartIndex', 1))
         mission_list = self.settings['missionList']
         # check if we re-load the running mission
         if ((isinstance(mission, int) and mission == start_index) or

core/data/proxy/serverproxy.py

@@ -222,7 +222,7 @@ async def rename(self, new_name: str, update_settings: bool = False) -> None:
         }, node=self.node.name, timeout=timeout)
         self.name = new_name
 
-    async def render_extensions(self) -> list:
+    async def render_extensions(self) -> list[dict]:
         if not self._extensions:
             timeout = 60 if not self.node.slow_system else 120
             data = await self.bus.send_to_node_sync({

core/data/server.py

@@ -424,7 +424,7 @@ async def prepare_extensions(self):
     async def persist_settings(self):
         raise NotImplementedError()
 
-    async def render_extensions(self) -> list:
+    async def render_extensions(self) -> list[dict]:
         raise NotImplementedError()
 
     async def is_running(self) -> bool:

core/extension.py

@@ -42,9 +42,10 @@ def __init__(self, server: Server, config: dict):
         self.config: dict = config
         self.server: Server = server
         self.running = False
+        self.locals: dict = {}
         if not self.enabled or not self.is_installed():
             return
-        self.locals: dict = self.load_config()
+        self.locals = self.load_config()
         if self.__class__.__name__ not in Extension.started_schedulers:
             schedule = getattr(self, 'schedule', None)
             if schedule:

core/utils/discord.py

@@ -1594,13 +1594,16 @@ def __init__(self, server: Server, message: discord.Message, pattern: list[str])
         self.server = server
 
     @staticmethod
-    async def get_server(message: discord.Message) -> Optional[Server]:
+    async def get_server(message: discord.Message, channel_id: Optional[int] = None) -> Optional[Server]:
         from services.bot import BotService
         from services.servicebus import ServiceBus
 
         bot = ServiceRegistry.get(BotService).bot
         server = bot.get_server(message, admin_only=True)
-        if not server and message.channel.id == bot.locals.get('channels', {}).get('admin'):
+        if not channel_id:
+            channel_id = bot.locals.get('channels', {}).get('admin')
+
+        if not server and message.channel.id == channel_id:
             bus = ServiceRegistry.get(ServiceBus)
             ctx = await bot.get_context(message)
             server = await utils.server_selection(bus, ctx, title=_("To which server do you want to upload?"))

extensions/lotatc/extension.py

@@ -167,21 +167,21 @@ def version(self) -> str:
         return utils.get_windows_version(os.path.join(self.home, r'bin', 'lotatc.dll'))
 
     async def render(self, param: Optional[dict] = None) -> dict:
-        if self.locals:
-            host = self.config.get('host', self.node.public_ip)
-            value = f"{host}:{self.locals.get('port', 10310)}"
-            show_passwords = self.config.get('show_passwords', True)
-            blue = self.locals.get('blue_password', '')
-            red = self.locals.get('red_password', '')
-            if show_passwords and (blue or red):
-                value += f"\n🔹 Pass: {blue}\n🔸 Pass: {red}"
-            return {
-                "name": "LotAtc",
-                "version": self.version,
-                "value": value
-            }
-        else:
-            return {}
+        if not self.locals:
+            raise NotImplementedError()
+
+        host = self.config.get('host', self.node.public_ip)
+        value = f"{host}:{self.locals.get('port', 10310)}"
+        show_passwords = self.config.get('show_passwords', True)
+        blue = self.locals.get('blue_password', '')
+        red = self.locals.get('red_password', '')
+        if show_passwords and (blue or red):
+            value += f"\n🔹 Pass: {blue}\n🔸 Pass: {red}"
+        return {
+            "name": "LotAtc",
+            "version": self.version,
+            "value": value
+        }
 
     def is_installed(self) -> bool:
         if not super().is_installed():
@@ -267,6 +267,7 @@ async def install(self):
         major_version, _ = self.get_inst_version()
         from_path = os.path.join(self.get_inst_path(), 'server', major_version)
         shutil.copytree(from_path, self.server.instance.home, dirs_exist_ok=True)
+        self.locals = self.load_config()
         self.log.info(f"  => {self.name} {self.version} installed into instance {self.server.instance.name}.")
 
     async def uninstall(self):

extensions/modmanager/extension.py

@@ -28,10 +28,10 @@ def shutdown(self) -> bool:
 
     async def render(self, param: Optional[dict] = None) -> dict:
         mods = self.modules.get(self.server.name)
-        if mods:
-            return {
-                "name": "Required Mods",
-                "value": '\n'.join([f"- {mod}" for mod in mods])
-            }
-        else:
+        if not mods:
             raise NotImplementedError()
+
+        return {
+            "name": "Required Mods",
+            "value": '\n'.join([f"- {mod}" for mod in mods])
+        }

extensions/olympus/README.md

@@ -11,6 +11,8 @@ DCS_MERCS:
   - name: DCSOlympus
     version: latest
     source: SavedGames
+    # uncomment for auto-update:
+    # repo: https://github.com/Pax1601/DCSOlympus
 ```
 To use the DCS Olympus client, you need [Node.js](https://nodejs.org/download/release/latest-v20.x/) installed.
 Click on the link, download and install it. Remember the installation location, as you need to provide it in the 

extensions/olympus/extension.py

@@ -207,7 +207,9 @@ async def prepare_olympus_json(self) -> bool:
             if extension:
                 self.locals['audio'] = {
                     "SRSPort": extension.config.get('port', extension.locals['Server Settings']['SERVER_PORT'])
-                } | self.config.get('audio', {})
+                } | self.config.get('audio', {
+                    "WSPort": 4000
+                })
         with open(self.config_path, mode='w', encoding='utf-8') as cfg:
             json.dump(self.locals, cfg, indent=2)
         return True