Created a cloud plugin to support server registration on remote servers.

karel26 · karel26 · commit 366d7647d403 · 2024-12-29T17:55:05.000+01:00
diff --git a/core/data/impl/serverimpl.py b/core/data/impl/serverimpl.py
@@ -43,7 +43,8 @@
     from services.bot import DCSServerBot
 
 DEFAULT_EXTENSIONS = {
-    "LogAnalyser": {}
+    "LogAnalyser": {},
+    "Cloud": {}
 }
 
 __all__ = ["ServerImpl"]
diff --git a/extensions/cloud/README.md b/extensions/cloud/README.md
@@ -0,0 +1,5 @@
+# Extension "Cloud"
+Used by the [Cloud-plugin](../../plugins/cloud/README.md) for updating the cloud server list.
+
+## Configuration
+All configuration is done in the cloud plugin.
diff --git a/extensions/cloud/__init__.py b/extensions/cloud/__init__.py
diff --git a/extensions/cloud/extension.py b/extensions/cloud/extension.py
@@ -0,0 +1,115 @@
+import aiohttp
+import certifi
+import os
+import ssl
+
+from aiohttp import BasicAuth
+from core import Extension, Server, utils, DEFAULT_TAG
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Any
+
+# ruamel YAML support
+from ruamel.yaml import YAML
+yaml = YAML()
+
+
+class Cloud(Extension):
+
+    def __init__(self, server: Server, config: dict):
+        super().__init__(server, config)
+        self.config = self.read_config()[DEFAULT_TAG]
+        self._session = None
+        self.client = None
+        self.base_url = f"{self.config['protocol']}://{self.config['host']}:{self.config['port']}"
+
+    def load_config(self) -> Optional[dict]:
+        return yaml.load(Path(os.path.join(self.node.config_dir, 'services', 'bot.yaml')).read_text(encoding='utf-8'))
+
+    def read_config(self):
+        return yaml.load(Path(os.path.join(self.node.config_dir, 'plugins', 'cloud.yaml')).read_text(encoding='utf-8'))
+
+    @property
+    def proxy(self) -> Optional[str]:
+        return self.locals.get('proxy', {}).get('url')
+
+    @property
+    def proxy_auth(self) -> Optional[BasicAuth]:
+        username = self.locals.get('proxy', {}).get('username')
+        try:
+            password = utils.get_password('proxy', self.node.config_dir)
+        except ValueError:
+            return None
+        if username and password:
+            return BasicAuth(username, password)
+
+    @property
+    def session(self):
+        if not self._session:
+            headers = {
+                "Content-type": "application/json"
+            }
+            if 'token' in self.config:
+                headers['Authorization'] = f"Bearer {self.config['token']}"
+            self._session = aiohttp.ClientSession(
+                connector=aiohttp.TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
+                raise_for_status=True, headers=headers
+            )
+        return self._session
+
+    async def post(self, request: str, data: Any) -> Any:
+        async def send(element: dict):
+            url = f"{self.base_url}/{request}/"
+            async with self.session.post(url, json=element, proxy=self.proxy, proxy_auth=self.proxy_auth) as response:
+                return await response.json()
+
+        if isinstance(data, list):
+            for line in data:
+                await send(line)
+        else:
+            await send(data)
+
+    async def cloud_register(self):
+        # we do not send cloud updates if we are not allowed and for non-public servers
+        if not self.config.get('register', True) or not self.server.settings['isPublic']:
+            return
+        try:
+            # noinspection PyUnresolvedReferences
+            await self.post('register_server', {
+                "guild_id": self.node.guild_id,
+                "server_name": self.server.name,
+                "ipaddr": self.server.instance.dcs_host,
+                "port": self.server.instance.dcs_port,
+                "password": (self.server.settings['password'] != ""),
+                "theatre": self.server.current_mission.map,
+                "dcs_version": self.node.dcs_version,
+                "num_players": len(self.server.get_active_players()) + 1,
+                "max_players": int(self.server.settings.get('maxPlayers', 16)),
+                "mission": self.server.current_mission.name,
+                "date": self.server.current_mission.date.strftime("%Y-%m-%d") if isinstance(self.server.current_mission.date, datetime) else self.server.current_mission.date,
+                "start_time": self.server.current_mission.start_time,
+                "time_in_mission": self.server.current_mission.mission_time,
+                "time_to_restart": (self.server.restart_time - datetime.now(tz=timezone.utc)).total_seconds() if self.server.restart_time else -1,
+            })
+            self.log.info(f"Server {self.server.name} registered with the cloud.")
+        except aiohttp.ClientError as ex:
+            self.log.error(f"Could not register server {self.server.name} with the cloud.", exc_info=ex)
+
+    async def cloud_unregister(self):
+        try:
+            # noinspection PyUnresolvedReferences
+            await self.plugin.post('unregister_server', {
+                "guild_id": self.node.guild_id,
+                "server_name": self.server.name,
+            })
+            self.log.info(f"Server {self.server.name} unregistered from the cloud.")
+        except aiohttp.ClientError as ex:
+            self.log.error(f"Could not unregister server {self.server.name} from the cloud.", exc_info=ex)
+
+    async def startup(self) -> bool:
+        await self.cloud_register()
+        return await super().startup()
+
+    def shutdown(self) -> bool:
+        self.loop.create_task(self.cloud_unregister())
+        return super().shutdown()
diff --git a/plugins/cloud/commands.py b/plugins/cloud/commands.py
@@ -228,9 +228,9 @@ async def serverlist(self, interaction: discord.Interaction, search: Optional[st
 
         def format_servers(servers: list[dict], marker, marker_emoji) -> discord.Embed:
             embed = discord.Embed(title=_('DCS Servers'), color=discord.Color.blue())
-            for server in servers:
-                name = ('🔐 ' if server['password'] else '🔓 ')
-                name += f"{server['server_name']} [{server['num_players']}/{server['max_players']}]\n"
+            for idx, server in enumerate(servers):
+                name = chr(0x31 + idx) + '\u20E3' + f" {server['server_name']} [{server['num_players']}/{server['max_players']}]"
+                name += (' 🔐' if server['password'] else ' 🔓') + '\n'
                 value = f"IP/Port:  {server['ipaddr']}:{server['port']}\n"
                 value += f"Map:      {server['theatre']}\n"
                 value += f"Time:     {timedelta(seconds=server['time_in_mission'])}\n"
@@ -239,19 +239,36 @@ def format_servers(servers: list[dict], marker, marker_emoji) -> discord.Embed:
                 embed.add_field(name=name, value='```' + value + '```', inline=False)
             return embed
 
+        async def display_server(server: dict):
+            embed = discord.Embed(color=discord.Color.blue())
+            embed.title = f"{server['server_name']} [{server['num_players']}/{server['max_players']}]"
+            embed.add_field(name=_("Address"), value=f"{server['ipaddr']}:{server['port']}", inline=False)
+            embed.add_field(name=_("Map"), value=f"{server['theatre']}", inline=False)
+            embed.add_field(name=_("Mission"), value=f"{server['mission']}", inline=False)
+            embed.add_field(name=_("Time"), value=f"{timedelta(seconds=server['time_in_mission'])}", inline=False)
+            if server['time_to_restart'] != -1:
+                embed.add_field(name=_("Restart in"), value=f"{timedelta(seconds=server['time_to_restart'])}", inline=False)
+            await interaction.followup.send(embed=embed)
+
         # noinspection PyUnresolvedReferences
         await interaction.response.defer()
         try:
             query = f'serverlist?dcs_version={self.node.dcs_version}'
             if search:
                 query += f'&wildcard={quote(search)}'
             else:
-                query += f'guild_id={self.node.guild_id}'
+                query += f'&guild_id={self.node.guild_id}'
             response = await self.get(query)
             if not len(response):
-                await interaction.followup.send(_('No server found.'), ephemeral=True)
+                if not search:
+                    await interaction.followup.send(_('No servers of this group are active.'), ephemeral=True)
+                else:
+                    await interaction.followup.send(
+                        _('No server found with the name "*{search}*".').format(search=search), ephemeral=True)
                 return
-            await utils.selection_list(interaction, response, format_servers)
+            n = await utils.selection_list(interaction, response, format_servers)
+            if n >= 0:
+                await display_server(response[n])
         except aiohttp.ClientError:
             await interaction.followup.send(_('Cloud not connected!'), ephemeral=True)
 
diff --git a/plugins/cloud/listener.py b/plugins/cloud/listener.py
@@ -1,31 +1,12 @@
-from contextlib import suppress
-
 import aiohttp
 import asyncio
 
-from core import EventListener, Server, Player, Side, event, Status
-from datetime import datetime, timezone
-from discord.ext import tasks
+from core import EventListener, Server, Player, Side, event
 from psycopg.rows import dict_row
 
 
 class CloudListener(EventListener):
 
-    def __init__(self, plugin):
-        super().__init__(plugin)
-        if self.plugin.get_config().get('register', True):
-            self.update_registration.start()
-
-    async def shutdown(self) -> None:
-        if self.plugin.get_config().get('register', True):
-            self.update_registration.cancel()
-        await super().shutdown()
-
-    @event(name="registerDCSServer")
-    async def registerDCSServer(self, server: Server, data: dict) -> None:
-        if self.plugin.get_config().get('register', True) and data['channel'].startswith('sync'):
-            await self.cloud_register(server)
-
     async def update_cloud_data(self, server: Server, player: Player):
         if not server.current_mission:
             return
@@ -72,48 +53,12 @@ async def onPlayerChangeSlot(self, server: Server, data: dict) -> None:
         # noinspection PyAsyncCall
         asyncio.create_task(self.update_cloud_data(server, player))
 
-    async def cloud_register(self, server: Server):
-        try:
-            # noinspection PyUnresolvedReferences
-            await self.plugin.post('register_server', {
-                "guild_id": self.node.guild_id,
-                "server_name": server.name,
-                "ipaddr": server.instance.dcs_host,
-                "port": server.instance.dcs_port,
-                "password": (server.settings['password'] != ""),
-                "theatre": server.current_mission.map,
-                "dcs_version": server.node.dcs_version,
-                "num_players": len(server.get_active_players()) + 1,
-                "max_players": int(server.settings.get('maxPlayers', 16)),
-                "mission": server.current_mission.name if server.current_mission else "",
-                "time_in_mission": int(server.current_mission.mission_time if server.current_mission else 0),
-                "time_to_restart": (server.restart_time - datetime.now(tz=timezone.utc)).total_seconds() if server.restart_time else -1,
-            })
-            self.log.info(f"Server {server.name} registered with the cloud.")
-        except aiohttp.ClientError as ex:
-            self.log.error(f"Could not register server {server.name} with the cloud.", exc_info=ex)
-
-    @event(name="onSimulationStart")
-    async def onSimulationStart(self, server: Server, _: dict) -> None:
-        if self.plugin.get_config().get('register', True):
-            await self.cloud_register(server)
-
-    @event(name="onSimulationStop")
-    async def onSimulationStop(self, server: Server, _: dict) -> None:
-        if self.plugin.get_config().get('register', True):
-            try:
-                # noinspection PyUnresolvedReferences
-                await self.plugin.post('unregister_server', {
-                    "guild_id": self.node.guild_id,
-                    "server_name": server.name,
-                })
-                self.log.info(f"Server {server.name} unregistered from the cloud.")
-            except aiohttp.ClientError as ex:
-                self.log.error(f"Could not unregister server {server.name} from the cloud.", exc_info=ex)
+    @event(name="onPlayerStart")
+    async def onPlayerStart(self, server: Server, data: dict) -> None:
+        if data['id'] != 1:
+            await server.run_on_extension(extension='Cloud', method='cloud_register')
 
-    @tasks.loop(minutes=5)
-    async def update_registration(self):
-        for server in self.bot.servers.values():
-            if server.status in [Status.RUNNING, Status.PAUSED]:
-                with suppress(Exception):
-                    await self.cloud_register(server)
+    @event(name="onPlayerStop")
+    async def onPlayerStop(self, server: Server, data: dict) -> None:
+        if data['id'] != 1:
+            await server.run_on_extension(extension='Cloud', method='cloud_register')

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,8 @@`
`43`	`43`	`from services.bot import DCSServerBot`
`44`	`44`
`45`	`45`	`DEFAULT_EXTENSIONS = {`
`46`		`- "LogAnalyser": {}`
	`46`	`+ "LogAnalyser": {},`
	`47`	`+ "Cloud": {}`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`__all__ = ["ServerImpl"]`