Initial commit — DRB client (edge node) stack

Includes edge-node (FastAPI/MQTT/Discord voice), op25-container (SDR decoder), and icecast (audio streaming).
2026-04-05 19:01:51 -04:00
commit 1a9c92b6db
47 changed files with 2496 additions and 0 deletions
@@ -0,0 +1,119 @@
+import asyncio
+from typing import Optional
+import discord
+from discord.ext import commands
+from app.config import settings
+from app.internal.logger import logger
+
+BOT_READY_TIMEOUT = 15  # seconds to wait for Discord bot to become ready
+
+
+class RadioBot:
+    def __init__(self):
+        self._bot: Optional[commands.Bot] = None
+        self._voice_client: Optional[discord.VoiceClient] = None
+        self._task: Optional[asyncio.Task] = None
+        self._ready_event: Optional[asyncio.Event] = None
+        self._current_token: Optional[str] = None
+        self._icecast_url = (
+            f"http://{settings.icecast_host}:{settings.icecast_port}{settings.icecast_mount}"
+        )
+
+    async def join(self, guild_id: int, channel_id: int, token: str) -> bool:
+        # (Re)start the bot if the token changed or the bot isn't running
+        if self._current_token != token or not self._is_bot_running():
+            if not await self._start_bot(token):
+                return False
+
+        guild = self._bot.get_guild(guild_id)
+        if not guild:
+            logger.error(f"Guild {guild_id} not found — bot may not be a member.")
+            return False
+
+        channel = guild.get_channel(channel_id)
+        if not isinstance(channel, discord.VoiceChannel):
+            logger.error(f"Channel {channel_id} is not a voice channel.")
+            return False
+
+        try:
+            if self._voice_client and self._voice_client.is_connected():
+                await self._voice_client.disconnect(force=True)
+            self._voice_client = await channel.connect()
+            self._play_stream()
+            logger.info(f"Streaming to #{channel.name} in {guild.name}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to join voice channel: {e}")
+            return False
+
+    async def leave(self) -> bool:
+        if self._voice_client and self._voice_client.is_connected():
+            try:
+                await self._voice_client.disconnect(force=True)
+                self._voice_client = None
+                logger.info("Disconnected from voice channel.")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to disconnect: {e}")
+        return False
+
+    async def stop(self):
+        await self.leave()
+        if self._task:
+            self._task.cancel()
+        if self._bot:
+            await self._bot.close()
+        self._bot = None
+        self._task = None
+        self._current_token = None
+        self._ready_event = None
+
+    def _play_stream(self):
+        if not self._voice_client:
+            return
+        source = discord.FFmpegPCMAudio(
+            self._icecast_url,
+            before_options="-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5",
+        )
+        self._voice_client.play(
+            discord.PCMVolumeTransformer(source, volume=1.0),
+            after=lambda e: logger.error(f"Stream ended unexpectedly: {e}") if e else None,
+        )
+
+    async def _start_bot(self, token: str) -> bool:
+        await self.stop()  # clean up any previous instance
+
+        intents = discord.Intents.default()
+        intents.voice_states = True
+        self._bot = commands.Bot(command_prefix="!", intents=intents)
+        self._ready_event = asyncio.Event()
+        self._current_token = token
+
+        @self._bot.event
+        async def on_ready():
+            logger.info(f"Discord bot ready: {self._bot.user} ({self._bot.user.id})")
+            self._ready_event.set()
+
+        self._task = asyncio.create_task(self._bot.start(token))
+
+        try:
+            await asyncio.wait_for(self._ready_event.wait(), timeout=BOT_READY_TIMEOUT)
+            return True
+        except asyncio.TimeoutError:
+            logger.error("Timed out waiting for Discord bot to become ready.")
+            await self.stop()
+            return False
+
+    def _is_bot_running(self) -> bool:
+        return (
+            self._bot is not None
+            and self._task is not None
+            and not self._task.done()
+        )
+
+    @property
+    def is_connected(self) -> bool:
+        return self._voice_client is not None and self._voice_client.is_connected()
+
+
+radio_bot = RadioBot()