Merge branch 'development'

Author: karel26

core/data/impl/nodeimpl.py

@@ -1429,17 +1429,11 @@ async def add_instance(self, name: str, *, template: str = "") -> "Instance":
         }
         with open(config_file, mode='w', encoding='utf-8') as outfile:
             yaml.dump(config, outfile)
-        settings_path = os.path.join(instance.home, 'Config', 'serverSettings.lua')
-        if os.path.exists(settings_path):
-            # TODO: dirty cast
-            settings = SettingsDict(cast(DataObject, cast(object, self)), settings_path, root='cfg')
-            settings['port'] = int(instance.dcs_port)
-            settings['name'] = 'n/a'
-            settings['missionList'] = []
-            settings['listStartIndex'] = 0
         bus = ServiceRegistry.get(ServiceBus)
         server = DataObjectFactory().new(ServerImpl, node=self.node, port=instance.bot_port, name='n/a', bus=bus)
         instance.server = server
+        # we cannot use instance.dcs_port here as that would refer to the assigned serverSettings.lua already
+        server.settings["port"] = int(instance.locals['dcs_port'])
         self.instances[instance.name] = instance
         bus.servers[server.name] = server
         if not self.master:

core/data/impl/serverimpl.py

@@ -113,11 +113,15 @@ def __post_init__(self):
         self._lock = asyncio.Lock()
         with self.pool.connection() as conn:
             with conn.transaction():
-                conn.execute("INSERT INTO servers (server_name) VALUES (%s) ON CONFLICT (server_name) DO NOTHING",
-                             (self.name, ))
-            row = conn.execute("SELECT maintenance FROM servers WHERE server_name = %s", (self.name,)).fetchone()
-            if row:
-                self._maintenance = row[0]
+                cursor = conn.execute("""
+                    INSERT INTO servers (server_name) 
+                    VALUES (%s) 
+                    ON CONFLICT (server_name) DO NOTHING
+                    RETURNING maintenance
+                """, (self.name, ))
+                row = cursor.fetchone()
+                if row:
+                    self._maintenance = row[0]
         atexit.register(self.stop_observer)
 
     @override
@@ -141,6 +145,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
             elif isinstance(self._settings['missionList'], dict):
                 self._settings['missionList'] = list(self._settings['missionList'].values())
         return self._settings
@@ -447,9 +452,11 @@ async def update_database(old_name: str, new_name: str):
             # rename the server in the database
             async with self.apool.connection() as conn:
                 async with conn.transaction():
-                    # we need to remove any older server that might have had the same name
                     await conn.execute("UPDATE servers SET server_name = %s WHERE server_name = %s",
-                                       (new_name, old_name))
+                                       (new_name, old_name or 'n/a'))
+                    if not old_name:
+                        await conn.execute("UPDATE instances SET server_name = %s WHERE instance = %s",
+                                           (new_name, self.instance.name))
 
         async def update_cluster(new_name: str):
             # only the master can take care of a cluster-wide rename
@@ -484,6 +491,13 @@ async def update_cluster(new_name: str):
         except Exception:
             self.log.exception(f"Error during renaming of server {old_name} to {new_name}: ", exc_info=True)
 
+    async def unlink(self):
+        if self.name == 'n/a':
+            async with self.apool.connection() as conn:
+                async with conn.transaction():
+                    await conn.execute("DELETE FROM servers WHERE server_name = 'n/a'")
+        self.instance.server = None
+
     @performance_log()
     def do_startup(self):
         basepath = self.node.installation
@@ -788,20 +802,8 @@ async def apply_mission_changes(self, filename: str | None = None, *, use_orig:
                         if _dirty:
                             self.log.info(f'  => {ext.name} applied on {new_filename}.')
                         dirty |= _dirty
-                # we did not change anything in the mission
-                if not dirty:
-                    return filename
-                # check if the original mission can be written
-                if filename != new_filename:
-                    missions: list[str] = self.settings['missionList']
-                    try:
-                        index = missions.index(filename) + 1
-                        await self.replaceMission(index, new_filename)
-                    except ValueError:
-                        # we should not be here, but just in case
-                        if new_filename not in missions:
-                            await self.addMission(new_filename)
-                return new_filename
+
+                return filename if not dirty else new_filename
             except Exception as ex:
                 self.log.error(ex)
                 if filename != new_filename and os.path.exists(new_filename):
@@ -899,7 +901,7 @@ async def render_extensions(self) -> list[dict]:
 
     @override
     async def restart(self, modify_mission: bool | None = True, use_orig: bool | None = True) -> None:
-        await self.loadMission(int(self.settings['listStartIndex']), modify_mission=modify_mission, use_orig=use_orig)
+        await self.loadMission(self._get_current_mission_file(), modify_mission=modify_mission, use_orig=use_orig)
 
     @override
     async def setStartIndex(self, mission_id: int) -> None:
@@ -912,22 +914,32 @@ async def setStartIndex(self, mission_id: int) -> None:
 
     @override
     async def setPassword(self, password: str):
-        self.settings['password'] = password or ''
+        if self.status in [Status.STOPPED, Status.PAUSED, Status.RUNNING]:
+            await self.send_to_dcs({"command": "setPassword", "password": password})
+        else:
+            self.settings['password'] = password or ''
 
     @override
     async def setCoalitionPassword(self, coalition: Coalition, password: str):
-        advanced = self.settings['advanced']
-        if coalition == Coalition.BLUE:
-            if password:
-                advanced['bluePasswordHash'] = utils.hash_password(password)
-            else:
-                advanced.pop('bluePasswordHash', None)
+        if self.status in [Status.STOPPED, Status.PAUSED, Status.RUNNING]:
+            if coalition == Coalition.BLUE:
+                await self.send_to_dcs({"command": "setCoalitionPassword", "bluePassword": password or ''})
+            elif coalition == Coalition.RED:
+                await self.send_to_dcs({"command": "setCoalitionPassword", "redPassword": password or ''})
         else:
-            if password:
-                advanced['redPasswordHash'] = utils.hash_password(password)
+            advanced = self.settings['advanced']
+            if coalition == Coalition.BLUE:
+                if password:
+                    advanced['bluePasswordHash'] = utils.hash_password(password)
+                else:
+                    advanced.pop('bluePasswordHash', None)
             else:
-                advanced.pop('redPasswordHash', None)
-        self.settings['advanced'] = advanced
+                if password:
+                    advanced['redPasswordHash'] = utils.hash_password(password)
+                else:
+                    advanced.pop('redPasswordHash', None)
+            self.settings['advanced'] = advanced
+
         async with self.apool.connection() as conn:
             async with conn.transaction():
                 await conn.execute('UPDATE servers SET {} = %s WHERE server_name = %s'.format(
@@ -994,38 +1006,34 @@ async def replaceMission(self, mission_id: int, path: str) -> list[str]:
     @override
     async def loadMission(self, mission: int | str, modify_mission: bool | None = True,
                           use_orig: bool | None = True, no_reload: bool | None = False) -> bool | None:
-        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
-            (isinstance(mission, str) and mission == self._get_current_mission_file())):
-            # if we should not reload, then return here
-            if no_reload:
-                return None
-            mission = self._get_current_mission_file()
-            if not mission:
-                return False
-            if use_orig:
-                new_filename = utils.create_writable_mission(mission)
-                orig_mission = utils.get_orig_file(mission)
-                shutil.copy2(orig_mission, new_filename)
-                if new_filename != mission:
-                    mission_list = await self.replaceMission(start_index, new_filename)
-            elif modify_mission:
-                # don't use the orig file, still make sure we have a writable mission
-                new_filename = utils.create_writable_mission(mission)
-                if new_filename != mission:
-                    shutil.copy2(mission, new_filename)
-                    mission_list = await self.replaceMission(start_index, new_filename)
+        start_index = int(self.settings.get('listStartIndex', 1))
+        try:
+            current_mission = self._get_current_mission_file()
+            current_index = mission_list.index(current_mission) + 1
+        except ValueError:
+            current_index = start_index
+            current_mission = mission_list[current_index - 1]
 
         if isinstance(mission, int):
-            if mission > len(mission_list):
-                mission = 1
-            filename = mission_list[mission - 1]
+            mission = mission_list[mission - 1]
+
+        # we should not reload the running mission
+        if no_reload and mission == current_mission:
+            return None
+
+        if modify_mission:
+            filename = await self.apply_mission_changes(mission, use_orig=use_orig)
+        elif use_orig:
+            filename = utils.create_writable_mission(mission)
+            orig_mission = utils.get_orig_file(mission)
+            shutil.copy2(orig_mission, filename)
         else:
             filename = mission
-        if modify_mission:
-            filename = await self.apply_mission_changes(filename)
+
+        if mission == current_mission and filename != mission:
+            mission_list = await self.replaceMission(current_index, filename)
 
         if self.status == Status.STOPPED:
             try:
@@ -1039,7 +1047,7 @@ async def loadMission(self, mission: int | str, modify_mission: bool | None = Tr
             timeout = 300 if self.node.locals.get('slow_system', False) else 180
             try:
                 idx = mission_list.index(filename) + 1
-                if idx == start_index:
+                if idx == current_index:
                     rc = await self.send_to_dcs_sync({
                         "command": "startMission",
                         "filename": filename
@@ -1054,6 +1062,7 @@ async def loadMission(self, mission: int | str, modify_mission: bool | None = Tr
                     "command": "startMission",
                     "filename": filename
                 }, timeout=timeout)
+
             # We could not load the mission
             result = rc['result'] if isinstance(rc['result'], bool) else (rc['result'] == 0)
             if not result:

core/data/proxy/serverproxy.py

@@ -234,6 +234,15 @@ async def rename(self, new_name: str, update_settings: bool = False) -> None:
         }, node=self.node.name, timeout=timeout)
         self.name = new_name
 
+    @override
+    async def unlink(self):
+        await self.bus.send_to_node_sync({
+            "command": "rpc",
+            "object": "Server",
+            "method": "unlink",
+            "server_name": self.name
+        }, node=self.node.name, timeout=60)
+
     @override
     async def render_extensions(self) -> list[dict]:
         if not self._extensions:

core/data/server.py

@@ -44,7 +44,7 @@ class Server(DataObject, ABC):
     _options: utils.SettingsDict | utils.RemoteSettingsDict | None = field(default=None, compare=False)
     _settings: utils.SettingsDict | utils.RemoteSettingsDict | None = field(default=None, compare=False)
     current_mission: Mission | None = field(default=None, compare=False)
-    mission_id: int = field(default=-1, compare=False)
+    _mission_id: int = field(default=None, compare=False)
     players: dict[int, Player] = field(default_factory=dict, compare=False)
     process: Process | None = field(default=None, compare=False)
     _maintenance: bool = field(compare=False, default=False)
@@ -118,6 +118,26 @@ def status(self) -> Status:
     def status(self, status: Status | str):
         self.set_status(status)
 
+    @property
+    def mission_id(self) -> int:
+        if not self._mission_id:
+            with self.pool.connection() as conn:
+                cursor = conn.execute("""
+                    SELECT id FROM missions 
+                    WHERE server_name = %s AND mission_end IS NULL
+                    ORDER BY mission_start DESC
+                    LIMIT 1
+                """, (self.name, ))
+                if cursor.rowcount == 1:
+                    self._mission_id = cursor.fetchone()[0]
+                else:
+                    self._mission_id = -1
+        return self._mission_id
+
+    @mission_id.setter
+    def mission_id(self, mission_id: int):
+        self._mission_id = mission_id
+
     # allow overloading of setter
     def set_status(self, status: Status | str):
         if isinstance(status, str):
@@ -273,6 +293,10 @@ async def send_to_dcs(self, message: dict):
     async def rename(self, new_name: str, update_settings: bool = False) -> None:
         raise NotImplementedError()
 
+    @abstractmethod
+    async def unlink(self):
+        raise NotImplementedError()
+
     @abstractmethod
     async def startup(self, modify_mission: bool | None = True, use_orig: bool | None = True) -> None:
         raise NotImplementedError()

core/utils/network.py

@@ -1,7 +1,9 @@
 import aiohttp
+import asyncio
 import ipaddress
 import socket
 import sys
+import time
 
 from contextlib import closing, suppress
 from core import Port, PortType
@@ -14,7 +16,8 @@
     "is_open",
     "get_public_ip",
     "is_upnp_available",
-    "generate_firewall_rules"
+    "generate_firewall_rules",
+    "wait_for_internet"
 ]
 
 API_URLS = [
@@ -140,3 +143,56 @@ def generate_firewall_rules(ports: Iterable[Port]) -> str:
             lines.append("")
 
     return "\n".join(lines)
+
+
+async def _check_google_dns(
+    host: str = "8.8.8.8",
+    port: int = 53,
+    per_attempt_timeout: float = 3.0,
+) -> bool:
+    """
+    Try to open a TCP connection once with a per-attempt timeout.
+    Returns True if successful, False otherwise.
+    """
+    try:
+        conn_coro = asyncio.open_connection(host, port)
+        reader, writer = await asyncio.wait_for(conn_coro, timeout=per_attempt_timeout)
+        writer.close()
+        await writer.wait_closed()
+        return True
+    except (asyncio.TimeoutError, OSError):
+        return False
+
+
+async def wait_for_internet(
+    timeout: float,
+    interval: float = 1.0,
+    host: str = "8.8.8.8",
+    port: int = 53,
+    per_attempt_timeout: float = 3.0,
+) -> bool:
+    """
+    Wait until an internet connection is available or until 'timeout' seconds pass.
+
+    Returns:
+        True  if a connection was established before timeout,
+        False if timeout was reached without success.
+    """
+    deadline = time.monotonic() + timeout
+
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+
+        # Don't let a single attempt take longer than remaining time
+        attempt_timeout = min(per_attempt_timeout, remaining)
+
+        if await _check_google_dns(host=host, port=port, per_attempt_timeout=attempt_timeout):
+            return True
+
+        # Sleep before the next attempt, but don't overshoot the deadline
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+        await asyncio.sleep(min(interval, remaining))

locale/cn/LC_MESSAGES/admin.mo

@@ -362,7 +362,7 @@ msgstr "该实例正在被服务器使用 \"{}\".\n"
 msgid "Do you really want to delete instance {}?"
 msgstr "你真的想删除实例 {} 吗?"
 
-msgid "Do you want to remove the directory {}?"
+msgid "Do you want to remove the directory\n{}?"
 msgstr "你想删除目录 {} 吗?"
 
 msgid "Instance {instance} removed from node {node}."

locale/cn/LC_MESSAGES/admin.po

@@ -362,7 +362,7 @@ msgstr "Die Instanz wird zurzeit vom Server \"{}\" genutzt.\n"
 msgid "Do you really want to delete instance {}?"
 msgstr "Möchtest Du Instanz {} wirklich löschen?"
 
-msgid "Do you want to remove the directory {}?"
+msgid "Do you want to remove the directory\n{}?"
 msgstr "Möchtest Du das Verzeichnis {} auch löschen?"
 
 msgid "Instance {instance} removed from node {node}."