CHANGES:

- /realweather rewrite, it now uses the extension code and merges its config with the nodes config, if there is one.

BUGFIX:
- /realweather now updates the METAR in the server status embed.

Author: karel26

core/utils/dcs.py

@@ -166,6 +166,8 @@ def create_writable_mission(filename: str) -> str:
 
 
 def get_orig_file(filename: str, *, create_file: bool = True) -> Optional[str]:
+    if filename.endswith('.orig'):
+        return filename
     if '.dcssb' in filename:
         mission_file = os.path.join(os.path.dirname(filename).replace('.dcssb', ''),
                                     os.path.basename(filename))

core/utils/helper.py

@@ -24,6 +24,7 @@
 import random
 import math
 
+from collections.abc import Mapping
 from copy import deepcopy
 from croniter import croniter
 from datetime import datetime, timedelta
@@ -68,6 +69,7 @@
     "SettingsDict",
     "RemoteSettingsDict",
     "tree_delete",
+    "deep_merge",
     "hash_password",
     "evaluate",
     "for_each",
@@ -781,6 +783,18 @@ def tree_delete(d: dict, key: str, debug: Optional[bool] = False):
         curr_element.pop(int(keys[-1]))
 
 
+def deep_merge(dict1, dict2):
+    result = dict(dict1)  # Create a shallow copy of dict1
+    for key, value in dict2.items():
+        if key in result and isinstance(result[key], Mapping) and isinstance(value, Mapping):
+            # Recursively merge dictionaries
+            result[key] = deep_merge(result[key], value)
+        else:
+            # Overwrite or add the new key-value pair
+            result[key] = value
+    return result
+
+
 def hash_password(password: str) -> str:
     # Generate an 11 character alphanumeric string
     key = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(11))

extensions/realweather/extension.py

@@ -39,6 +39,13 @@ def version(self) -> Optional[str]:
         return utils.get_windows_version(os.path.join(os.path.expandvars(self.config['installation']),
                                                       'realweather.exe'))
 
+    def load_config(self) -> Optional[dict]:
+        try:
+            with open(self.config_path, mode='rb') as infile:
+                return tomli.load(infile)
+        except tomli.TOMLDecodeError as ex:
+            raise RealWeatherException(f"Error while reading {self.config_path}: {ex}")
+
     def get_config(self, filename: str) -> dict:
         if 'terrains' in self.config:
             miz = MizFile(filename)
@@ -62,7 +69,7 @@ def get_icao_code(filename: str) -> Optional[str]:
         else:
             return None
 
-    async def generate_config_1_0(self, input_mission: str, output_mission: str, cwd: str):
+    async def generate_config_1_0(self, input_mission: str, output_mission: str, override: Optional[dict] = None):
         try:
             with open(self.config_path, mode='r', encoding='utf-8') as infile:
                 cfg = json.load(infile)
@@ -88,10 +95,10 @@ async def generate_config_1_0(self, input_mission: str, output_mission: str, cwd
                 }
             }
             self.config['metar'] = {"icao": icao}
-        with open(os.path.join(cwd, 'config.json'), mode='w', encoding='utf-8') as outfile:
-            json.dump(cfg, outfile, indent=2)
+        self.locals = utils.deep_merge(cfg, override or {})
+        await self.write_config()
 
-    async def generate_config_2_0(self, input_mission: str, output_mission: str, cwd: str):
+    async def generate_config_2_0(self, input_mission: str, output_mission: str, override: Optional[dict] = None):
         tmpfd, tmpname = tempfile.mkstemp()
         os.close(tmpfd)
         try:
@@ -129,18 +136,26 @@ async def generate_config_2_0(self, input_mission: str, output_mission: str, cwd
                     "icao": icao
                 }
             }
-        with open(os.path.join(cwd, 'config.toml'), mode='wb') as outfile:
-            tomli_w.dump(cfg, outfile)
+        self.locals = utils.deep_merge(cfg, override or {})
+        await self.write_config()
 
-    async def beforeMissionLoad(self, filename: str) -> tuple[str, bool]:
-        tmpfd, tmpname = tempfile.mkstemp()
-        os.close(tmpfd)
+    async def write_config(self):
         cwd = await self.server.get_missions_dir()
+        if self.version.split('.')[0] == '1':
+            with open(os.path.join(cwd, 'config.json'), mode='w', encoding='utf-8') as outfile:
+                json.dump(self.locals, outfile, indent=2)
+        else:
+            with open(os.path.join(cwd, 'config.toml'), mode='wb') as outfile:
+                tomli_w.dump(self.locals, outfile)
 
+    async def generate_config(self, filename: str, tmpname: str, config: Optional[dict] = None):
         if self.version.split('.')[0] == '1':
-            await self.generate_config_1_0(filename, tmpname, cwd)
+            await self.generate_config_1_0(filename, tmpname, config)
         else:
-            await self.generate_config_2_0(filename, tmpname, cwd)
+            await self.generate_config_2_0(filename, tmpname, config)
+
+    async def run_realweather(self, filename: str, tmpname: str) -> tuple[str, bool]:
+        cwd = await self.server.get_missions_dir()
         rw_home = os.path.expandvars(self.config['installation'])
 
         def run_subprocess():
@@ -151,7 +166,7 @@ def run_subprocess():
                 self.log.error(stderr.decode('utf-8'))
             output = stdout.decode('utf-8')
             metar = next((x for x in output.split('\n') if 'METAR:' in x), "")
-            remarks = self.config.get('realweather', {}).get('mission', {}).get('brief', {}).get('remarks', 'RMK Generated by DCS Real Weather')
+            remarks = self.locals.get('realweather', {}).get('mission', {}).get('brief', {}).get('remarks', '')
             matches = re.search(rf"(?<=METAR: )(.*)(?= {remarks})", metar)
             if matches:
                 self.metar = matches.group(0)
@@ -171,6 +186,18 @@ def run_subprocess():
         os.remove(tmpname)
         return new_filename, True
 
+    async def beforeMissionLoad(self, filename: str) -> tuple[str, bool]:
+        tmpfd, tmpname = tempfile.mkstemp()
+        os.close(tmpfd)
+        await self.generate_config(filename, tmpname)
+        return await self.run_realweather(filename, tmpname)
+
+    async def apply_realweather(self, filename: str, config: dict) -> str:
+        tmpfd, tmpname = tempfile.mkstemp()
+        os.close(tmpfd)
+        await self.generate_config(utils.get_orig_file(filename), tmpname, config)
+        return (await self.run_realweather(filename, tmpname))[0]
+
     async def render(self, param: Optional[dict] = None) -> dict:
         if self.version.split('.')[0] == '1':
             icao = self.config.get('metar', {}).get('icao')

plugins/realweather/commands.py

@@ -1,14 +1,7 @@
-import asyncio
 import discord
-import json
 import os
-import shutil
-import subprocess
-import tempfile
-import tomli
-import tomli_w
 
-from core import Plugin, command, utils, Status, Server, PluginInstallationError, MizFile, UnsupportedMizFileException
+from core import Plugin, command, utils, Status, Server, PluginInstallationError, UnsupportedMizFileException
 from discord import app_commands
 from services.bot import DCSServerBot
 from typing import Optional
@@ -25,8 +18,9 @@ def __init__(self, bot: DCSServerBot):
             )
         self.version = utils.get_windows_version(os.path.join(os.path.expandvars(self.installation), 'realweather.exe'))
 
-    async def change_weather_1x(self, server: Server, filename: str, airbase: dict, config: dict) -> str:
-        config = {
+    @staticmethod
+    def generate_config_1_0(airbase: dict, config: dict) -> dict:
+        return {
             "metar": {
                 "icao": airbase['code']
             },
@@ -41,46 +35,10 @@ async def change_weather_1x(self, server: Server, filename: str, airbase: dict,
                 }
             }
         }
-        rw_home = os.path.expandvars(self.installation)
-        tmpfd, tmpname = tempfile.mkstemp()
-        os.close(tmpfd)
-        with open(os.path.join(rw_home, 'config.json'), mode='r', encoding='utf-8') as infile:
-            cfg = json.load(infile)
-        # create proper configuration
-        for name, element in cfg.items():
-            if name == 'files':
-                element['input-mission'] = filename
-                element['output-mission'] = tmpname
-            if name in config:
-                if isinstance(config[name], dict):
-                    element |= config[name]
-                else:
-                    cfg[name] = config[name]
-        cwd = await server.get_missions_dir()
-        with open(os.path.join(cwd, 'config.json'), mode='w', encoding='utf-8') as outfile:
-            json.dump(cfg, outfile, indent=2)
 
-        def run_subprocess():
-            subprocess.run([os.path.join(rw_home, 'realweather.exe')], cwd=cwd, stdout=subprocess.DEVNULL,
-                           stderr=subprocess.DEVNULL)
-        await asyncio.to_thread(run_subprocess)
-
-        # check if DCS Real Weather corrupted the miz file
-        # (as the original author does not see any reason to do that on his own)
-        await asyncio.to_thread(MizFile, tmpname)
-
-        # mission is good, take it
-        # make an initial backup, if there is none
-        if '.dcssb' not in filename and not os.path.exists(filename + '.orig'):
-            shutil.copy2(filename, filename + '.orig')
-
-        new_filename = utils.create_writable_mission(filename)
-        shutil.copy2(tmpname, new_filename)
-        os.remove(tmpname)
-        return new_filename
-
-    async def change_weather_2x(self, server: Server, filename: str, airbase: dict, config: dict) -> str:
-        config = {
+    @staticmethod
+    def generate_config_2_0(airbase: dict, config: dict) -> dict:
+        return {
             "options": {
                 "weather": {
                     "enable": True,
@@ -109,45 +67,12 @@ async def change_weather_2x(self, server: Server, filename: str, airbase: dict,
                 }
             }
         }
-        rw_home = os.path.expandvars(self.installation)
-        tmpfd, tmpname = tempfile.mkstemp()
-        os.close(tmpfd)
-        with open(os.path.join(rw_home, 'config.toml'), mode='rb') as infile:
-            cfg = tomli.load(infile)
-        # create proper configuration
-        for name, element in cfg.items():
-            if name == 'realweather':
-                element['mission'] = {
-                    "input": filename,
-                    "output": tmpname
-                }
-            elif name in config:
-                if isinstance(config[name], dict):
-                    element |= config[name]
-                else:
-                    cfg[name] = config[name]
-        cwd = await server.get_missions_dir()
-        with open(os.path.join(cwd, 'config.toml'), mode='wb') as outfile:
-            tomli_w.dump(cfg, outfile)
 
-        def run_subprocess():
-            subprocess.run([os.path.join(rw_home, 'realweather.exe')], cwd=cwd, stdout=subprocess.DEVNULL,
-                           stderr=subprocess.DEVNULL)
-        await asyncio.to_thread(run_subprocess)
-
-        # check if DCS Real Weather corrupted the miz file
-        # (as the original author does not see any reason to do that on his own)
-        await asyncio.to_thread(MizFile, tmpname)
-
-        # mission is good, take it
-        # make an initial backup, if there is none
-        if '.dcssb' not in filename and not os.path.exists(filename + '.orig'):
-            shutil.copy2(filename, filename + '.orig')
-
-        new_filename = utils.create_writable_mission(filename)
-        shutil.copy2(tmpname, new_filename)
-        os.remove(tmpname)
-        return new_filename
+    def generate_config(self, airbase: dict, config: dict) -> dict:
+        if self.version.split('.')[0] == '1':
+            return self.generate_config_1_0(airbase, config)
+        else:
+            return self.generate_config_2_0(airbase, config)
 
     @command(description='Modify mission with a preset')
     @app_commands.guild_only()
@@ -163,50 +88,62 @@ async def realweather(self, interaction: discord.Interaction,
                           temperature: Optional[bool] = False, pressure: Optional[bool] = False,
                           time: Optional[bool] = False):
         ephemeral = utils.get_ephemeral(interaction)
-        if server.status in [Status.PAUSED, Status.RUNNING]:
+        airbase = server.current_mission.airbases[idx]
+        # noinspection PyUnresolvedReferences
+        await interaction.response.defer(ephemeral=ephemeral)
+
+        msg = await interaction.followup.send('Changing weather...', ephemeral=ephemeral)
+        status = server.status
+        if not server.locals.get('mission_rewrite', True) and server.status in [Status.RUNNING, Status.PAUSED]:
             question = 'Do you want to restart the server for a weather change?'
             if server.is_populated():
                 result = await utils.populated_question(interaction, question, ephemeral=ephemeral)
+                if result:
+                    result = 'yes'
             else:
                 result = await utils.yn_question(interaction, question, ephemeral=ephemeral)
             if not result:
                 return
-        airbase = server.current_mission.airbases[idx]
-        startup = False
-        msg = await interaction.followup.send('Changing weather...', ephemeral=ephemeral)
-        if not server.locals.get('mission_rewrite', True) and server.status != Status.STOPPED:
-            await server.stop()
-            startup = True
-        filename = await server.get_current_mission_file()
-        config = {
-            "wind": wind,
-            "clouds": clouds,
-            "fog": fog,
-            "dust": dust,
-            "temperature": temperature,
-            "pressure": pressure,
-            "time": time
-        }
+            if result == 'yes':
+                await server.stop()
+        else:
+            result = None
         try:
-            if self.version.split('.')[0] == '1':
-                new_filename = await self.change_weather_1x(server, utils.get_orig_file(filename), airbase, config)
+            config = self.generate_config(airbase, {
+                "wind": wind,
+                "clouds": clouds,
+                "fog": fog,
+                "dust": dust,
+                "temperature": temperature,
+                "pressure": pressure,
+                "time": time
+            })
+            try:
+                filename = await server.get_current_mission_file()
+                new_filename = await server.run_on_extension('RealWeather', 'apply_realweather',
+                                                             filename=filename, config=config)
+            except (FileNotFoundError, UnsupportedMizFileException):
+                await msg.edit(content='Could not apply weather due to an error in RealWeather.')
+                return
+            message = 'Weather changed.'
+            if new_filename != filename:
+                self.log.info(f"  => New mission written: {new_filename}")
+                await server.replaceMission(int(server.settings['listStartIndex']), new_filename)
             else:
-                new_filename = await self.change_weather_2x(server, utils.get_orig_file(filename), airbase, config)
-            self.log.info(f"Realweather applied on server {server.name}.")
-        except (FileNotFoundError, UnsupportedMizFileException):
-            await msg.edit(content='Could not apply weather due to an error in RealWeather.')
-            return
-        message = 'Weather changed.'
-        if new_filename != filename:
-            self.log.info(f"  => New mission written: {new_filename}")
-            await server.replaceMission(int(server.settings['listStartIndex']), new_filename)
-        else:
-            self.log.info(f"  => Mission {filename} overwritten.")
-        if startup or server.status not in [Status.STOPPED, Status.SHUTDOWN]:
-            await server.restart(modify_mission=False)
-            message += '\nMission reloaded.'
-        await self.bot.audit("changed weather", server=server, user=interaction.user)
-        await msg.edit(content=message)
+                self.log.info(f"  => Mission {filename} overwritten.")
+
+            if status == server.status and status in [Status.RUNNING, Status.PAUSED]:
+                await server.restart(modify_mission=False)
+                message += '\nMission reloaded.'
+            elif result == 'later':
+                server.on_empty = {"command": "load", "mission_file": new_filename, "user": interaction.user}
+                msg += 'Mission will restart, when server is empty.'
+
+            await self.bot.audit("changed weather", server=server, user=interaction.user)
+            await msg.edit(content=message)
+        finally:
+            if status in [Status.RUNNING, Status.PAUSED] and server.status == Status.STOPPED:
+                await server.start()
 
 
 async def setup(bot: DCSServerBot):