Enhancements:

- /dcs update can now take a specific version also

BUGFIX:
- mission list replication between nodes did not work
- DCS version was not update on remote nodes properly
- DCS port and WebGUI port were not published properly by remote nodes

Author: karel26

core/data/impl/nodeimpl.py

@@ -24,7 +24,7 @@
 from core.translations import get_translation
 from discord.ext import tasks
 from migrate import migrate
-from packaging import version
+from packaging.version import parse
 from pathlib import Path
 from psycopg.errors import UndefinedTable, InFailedSqlTransaction, NotNullViolation, OperationalError
 from psycopg.rows import dict_row
@@ -90,7 +90,6 @@ def __init__(self, name: str, config_dir: Optional[str] = 'config'):
         self.is_shutdown = asyncio.Event()
         self.rc = 0
         self.dcs_branch = None
-        self.dcs_version = None
         self.all_nodes: dict[str, Optional[Node]] = {self.name: self}
         self.suspect: dict[str, Node] = {}
         self.instances: list[Instance] = []
@@ -129,6 +128,7 @@ async def __aexit__(self, type, value, traceback):
         await self.close_db()
 
     async def post_init(self):
+        await self.get_dcs_branch_and_version()
         self.pool, self.apool = await self.init_db()
         try:
             self._master = await self.heartbeat()
@@ -388,7 +388,7 @@ async def _upgrade_pending_non_git(self) -> bool:
                     current_version = re.sub('^v', '', __version__)
                     latest_version = re.sub('^v', '', result[0]["tag_name"])
 
-                    if version.parse(latest_version) > version.parse(current_version):
+                    if parse(latest_version) > parse(current_version):
                         return True
         except aiohttp.ClientResponseError as ex:
             # ignore rate limits
@@ -435,9 +435,9 @@ async def get_dcs_branch_and_version(self) -> tuple[str, str]:
                                "Use /dcs update if you want to switch to the release branch.")
         return self.dcs_branch, self.dcs_version
 
-    async def update(self, warn_times: list[int], branch: Optional[str] = None) -> int:
+    async def update(self, warn_times: list[int], branch: Optional[str] = None, version: Optional[str] = None) -> int:
 
-        async def do_update(branch: Optional[str] = None) -> int:
+        async def do_update(branch: str, version: Optional[str] = None) -> int:
             # disable any popup on the remote machine
             if sys.platform == 'win32':
                 startupinfo = subprocess.STARTUPINFO()
@@ -450,7 +450,9 @@ async def do_update(branch: Optional[str] = None) -> int:
             def run_subprocess() -> int:
                 try:
                     cmd = [os.path.join(self.installation, 'bin', 'dcs_updater.exe'), '--quiet', 'update']
-                    if branch:
+                    if version:
+                        cmd.append(f"{version}@{branch}")
+                    else:
                         cmd.append(f"@{branch}")
 
                     process = subprocess.run(
@@ -481,15 +483,16 @@ def run_subprocess() -> int:
             for callback in self.before_update.values():
                 await callback()
             old_branch, old_version = await self.get_dcs_branch_and_version()
-            rc = await do_update(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)
+                    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
                 if self.locals['DCS'].get('desanitize', True):
@@ -564,15 +567,15 @@ async def get_available_modules(self) -> list[str]:
                         pass
             return list(licenses)
 
-    async def get_latest_version(self, branch: str) -> Optional[str]:
-        async def _get_latest_version_no_auth():
+    async def get_available_dcs_versions(self, branch: str) -> Optional[list[str]]:
+        async def _get_latest_versions_no_auth() -> Optional[list[str]]:
             async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(
                     ssl=ssl.create_default_context(cafile=certifi.where()))) as session:
                 async with session.get(UPDATER_URL.format(branch)) as response:
                     if response.status == 200:
-                        return json.loads(gzip.decompress(await response.read()))['versions2'][-1]['version']
+                        return [x['version'] for x in json.loads(gzip.decompress(await response.read()))['versions2']]
 
-        async def _get_latest_version_auth():
+        async def _get_latest_versions_auth() -> Optional[list[str]]:
             user = self.locals['DCS'].get('user')
             password = utils.get_password('DCS', self.config_dir)
             headers = {
@@ -584,17 +587,22 @@ async def _get_latest_version_auth():
                     if r1.status == 200:
                         async with await session.get(UPDATER_URL.format(branch)) as r2:
                             if r2.status == 200:
-                                data = json.loads(gzip.decompress(await r2.read()))['versions2'][-1]['version']
+                                data = [x['version'] for x in json.loads(gzip.decompress(await r2.read()))['versions2']]
                             else:
                                 data = None
                         async with await session.get(LOGOUT_URL):
                             pass
                         return data
 
         if not self.locals['DCS'].get('user'):
-            return await _get_latest_version_no_auth()
+            return await _get_latest_versions_no_auth()
         else:
-            return await _get_latest_version_auth()
+            return await _get_latest_versions_auth()
+
+
+    async def get_latest_version(self, branch: str) -> Optional[str]:
+        versions = await self.get_available_dcs_versions(branch)
+        return versions[-1] if versions else None
 
     async def register(self):
         self._public_ip = self.locals.get('public_ip')
@@ -679,8 +687,8 @@ def has_timeout(row: dict, timeout: int):
                                         # noinspection PyAsyncCall
                                         asyncio.create_task(self.upgrade())
                                         return True
-                                elif version.parse(cluster['version']) != version.parse(__version__):
-                                    if version.parse(cluster['version']) > version.parse(__version__):
+                                elif parse(cluster['version']) != parse(__version__):
+                                    if parse(cluster['version']) > parse(__version__):
                                         self.log.warning(
                                             f"Bot version downgraded from {cluster['version']} to {__version__}. "
                                             f"This could lead to unexpected behavior if there have been database "
@@ -723,7 +731,7 @@ def has_timeout(row: dict, timeout: int):
                                                      (self.name, self.guild_id))
                                 return True
                             # we have a version mismatch on the agent, a cloud sync might still be pending
-                            if version.parse(__version__) < version.parse(cluster['version']):
+                            if parse(__version__) < parse(cluster['version']):
                                 self.log.error(f"We are running version {__version__} where the master is on version "
                                                f"{cluster['version']} already. Trying to upgrade ...")
                                 # TODO: we might not have bus access here yet, so be our own bus (dirty)
@@ -736,7 +744,7 @@ def has_timeout(row: dict, timeout: int):
                                     INSERT INTO intercom (guild_id, node, data) VALUES (%s, %s, %s)
                                 """, (self.guild_id, self.name, Json(data)))
                                 return False
-                            elif version.parse(__version__) > version.parse(cluster['version']):
+                            elif parse(__version__) > parse(cluster['version']):
                                 self.log.warning(
                                     f"This node is running on version {__version__} where the master still runs on "
                                     f"{cluster['version']}. You need to upgrade your master node!")
@@ -906,7 +914,7 @@ async def autoupdate(self):
             except aiohttp.ClientError:
                 self.log.warning("Update check failed, possible server outage at ED.")
                 return
-            if new_version and old_version != new_version:
+            if new_version and parse(old_version) < parse(new_version):
                 self.log.info('A new version of DCS World is available. Auto-updating ...')
                 rc = await self.update([300, 120, 60])
                 if rc == 0:

core/data/impl/serverimpl.py

@@ -890,6 +890,9 @@ async def loadNextMission(self, modify_mission: Optional[bool] = True) -> bool:
             return True
         return False
 
+    async def getMissionList(self) -> list[str]:
+        return self.settings.get('missionList', [])
+
     async def run_on_extension(self, extension: str, method: str, **kwargs) -> Any:
         ext = self.extensions.get(extension)
         if not ext:

core/data/node.py

@@ -59,6 +59,7 @@ def __init__(self, name: str, config_dir: Optional[str] = 'config'):
         self.locals = None
         self.config = self.read_config(os.path.join(config_dir, 'main.yaml'))
         self.guild_id: int = int(self.config['guild_id'])
+        self.dcs_version = None
         self.slow_system: bool = False
 
     def __repr__(self):
@@ -133,7 +134,7 @@ async def upgrade_pending(self) -> bool:
     async def upgrade(self):
         raise NotImplemented()
 
-    async def update(self, warn_times: list[int], branch: Optional[str] = None) -> int:
+    async def update(self, warn_times: list[int], branch: Optional[str] = None, version: Optional[str] = None) -> int:
         raise NotImplemented()
 
     async def get_dcs_branch_and_version(self) -> tuple[str, str]:
@@ -148,6 +149,9 @@ async def get_installed_modules(self) -> list[str]:
     async def get_available_modules(self) -> list[str]:
         raise NotImplemented()
 
+    async def get_available_dcs_versions(self, branch: str) -> Optional[list[str]]:
+        raise NotImplemented()
+
     async def get_latest_version(self, branch: str) -> Optional[str]:
         raise NotImplemented()
 

core/data/proxy/nodeproxy.py

@@ -20,7 +20,7 @@
 
 
 class NodeProxy(Node):
-    def __init__(self, local_node: "NodeImpl", name: str, public_ip: str):
+    def __init__(self, local_node: "NodeImpl", name: str, public_ip: str, dcs_version: str):
         from services.servicebus import ServiceBus
 
         super().__init__(name, local_node.config_dir)
@@ -32,6 +32,7 @@ def __init__(self, local_node: "NodeImpl", name: str, public_ip: str):
         self.locals = self.read_locals()
         self.bus = ServiceRegistry.get(ServiceBus)
         self.slow_system = self.locals.get('slow_system', False)
+        self.dcs_version = dcs_version
 
     @property
     def master(self) -> bool:
@@ -102,14 +103,15 @@ async def upgrade(self):
             "method": "upgrade"
         }, node=self.name)
 
-    async def update(self, warn_times: list[int], branch: Optional[str] = None) -> int:
+    async def update(self, warn_times: list[int], branch: Optional[str] = None, version: Optional[str] = None) -> int:
         data = await self.bus.send_to_node_sync({
             "command": "rpc",
             "object": "Node",
             "method": "update",
             "params": {
                 "warn_times": warn_times,
-                "branch": branch or ""
+                "branch": branch or "",
+                "version": version or ""
             }
         }, node=self.name, timeout=600)
         return data['return']
@@ -155,6 +157,20 @@ async def get_available_modules(self) -> list[str]:
         }, node=self.name, timeout=timeout)
         return data['return']
 
+    @cache_with_expiration(expiration=60)
+    async def get_available_dcs_versions(self, branch: str) -> Optional[list[str]]:
+        timeout = 60 if not self.slow_system else 120
+        data = await self.bus.send_to_node_sync({
+            "command": "rpc",
+            "object": "Node",
+            "method": "get_available_dcs_versions",
+            "params": {
+                "branch": branch
+            }
+        }, node=self.name, timeout=timeout)
+        return data['return']
+
+
     @cache_with_expiration(expiration=60)
     async def get_latest_version(self, branch: str) -> Optional[str]:
         timeout = 60 if not self.slow_system else 120

core/data/proxy/serverproxy.py

@@ -3,7 +3,7 @@
 import asyncio
 
 from core import Server, Status, utils, Coalition
-from core.utils.helper import async_cache
+from core.utils.helper import async_cache, cache_with_expiration
 from core.data.node import UploadStatus
 from dataclasses import dataclass, field
 from typing import Optional, Union, Any
@@ -279,14 +279,10 @@ async def addMission(self, path: str, *, autostart: Optional[bool] = False) -> l
                 "autostart": autostart
             }
         }, timeout=timeout, node=self.node.name)
-        # wait for the missionList sync
-        while path not in self.settings['missionList']:
-            await asyncio.sleep(1)
         return data['return']
 
     async def deleteMission(self, mission_id: int) -> list[str]:
         timeout = 60 if not self.node.slow_system else 120
-        path = self.settings['missionList'][mission_id - 1]
         data = await self.bus.send_to_node_sync({
             "command": "rpc",
             "object": "Server",
@@ -296,9 +292,6 @@ async def deleteMission(self, mission_id: int) -> list[str]:
                 "mission_id": mission_id
             }
         }, timeout=timeout, node=self.node.name)
-        # wait for the missionList sync
-        while path in self.settings['missionList']:
-            await asyncio.sleep(1)
         return data['return']
 
     async def replaceMission(self, mission_id: int, path: str) -> list[str]:
@@ -342,6 +335,17 @@ async def loadNextMission(self, modify_mission: Optional[bool] = True) -> bool:
         }, timeout=timeout, node=self.node.name)
         return data['return']
 
+    @cache_with_expiration(expiration=10)
+    async def getMissionList(self) -> list[str]:
+        timeout = 180 if not self.node.slow_system else 300
+        data = await self.bus.send_to_node_sync({
+            "command": "rpc",
+            "object": "Server",
+            "method": "getMissionList",
+            "server_name": self.name
+        }, timeout=timeout, node=self.node.name)
+        return data['return']
+
     async def run_on_extension(self, extension: str, method: str, **kwargs) -> Any:
         timeout = 180 if not self.node.slow_system else 300
         params = {

core/data/server.py

@@ -52,7 +52,6 @@ class Server(DataObject):
     restart_pending: bool = field(default=False, compare=False)
     on_mission_end: dict = field(default_factory=dict, compare=False)
     on_empty: dict = field(default_factory=dict, compare=False)
-    dcs_version: str = field(default=None, compare=False)
     extensions: dict[str, Extension] = field(default_factory=dict, compare=False)
     afk: dict[str, datetime] = field(default_factory=dict, compare=False)
     listeners: dict[str, asyncio.Future] = field(default_factory=dict, compare=False)
@@ -361,7 +360,7 @@ async def loadNextMission(self, modify_mission: Optional[bool] = True) -> bool:
         raise NotImplemented()
 
     async def getMissionList(self) -> list[str]:
-        return self.settings.get('missionList', [])
+        raise NotImplemented()
 
     async def modifyMission(self, filename: str, preset: Union[list, dict]) -> str:
         raise NotImplemented()

core/utils/discord.py

@@ -1037,7 +1037,7 @@ def get_name(base_dir: str, path: str):
         base_dir = await server.get_missions_dir()
         choices: list[app_commands.Choice[int]] = [
             app_commands.Choice(name=get_name(base_dir, x), value=idx)
-            for idx, x in enumerate(server.settings['missionList'])
+            for idx, x in enumerate(await server.getMissionList())
             if not current or current.casefold() in get_name(base_dir, x).casefold()
         ]
         return sorted(choices, key=lambda choice: choice.name)[:25]

install.cmd

@@ -18,6 +18,7 @@ if not exist "%VENV%" (
     echo Creating the Python Virtual Environment. This may take some time...
     python -m pip install --upgrade pip
     python -m venv "%VENV%"
+    "%VENV%\Scripts\python.exe" -m pip install --upgrade pip
     "%VENV%\Scripts\python.exe" -m pip install -r requirements.txt
 )
 "%VENV%\Scripts\python" install.py %*