wrong ignore (oops)

Author: FoxeiZ

.gitignore

@@ -9,4 +9,4 @@
 nameless.sqlite
 
 # Ignore lavalink stuffs
-lavalink/
+**/bin/

nameless/custom/player/lavalink/__init__.py

@@ -0,0 +1,3 @@
+from .start import main, start, stop
+
+__all__ = ["start", "stop", "main"]

nameless/custom/player/lavalink/start.py

@@ -0,0 +1,91 @@
+import asyncio
+import base64
+import logging
+import signal
+from pathlib import Path
+
+import aiohttp
+
+from nameless.config import nameless_config
+
+CWD = Path(__file__).parent
+LAVALINK_URL = (
+    "https://github.com/lavalink-devs/Lavalink/releases/latest/download/Lavalink.jar"
+)
+LAVALINK_BIN = CWD / "bin" / "Lavalink.jar"
+LAVALINK_CONFIG = CWD / "bin" / "application.yml"
+
+proc: asyncio.subprocess.Process | None = None
+task: asyncio.Task[None] | None = None
+stop_event = asyncio.Event()
+
+
+async def start():
+    """Start the Lavalink server from /bin folder."""
+    global proc, stop_event
+    while True:
+        proc = await asyncio.create_subprocess_exec(
+            "java", "-jar", "Lavalink.jar", cwd=CWD / "bin", stdout=-3
+        )
+        await proc.wait()
+        if nameless_config["nameless"]["is_shutting_down"]:
+            stop_event.set()
+            break
+
+        logging.warning("Lavalink server stopped. Restarting in 5 seconds...")
+        await asyncio.sleep(5)
+
+
+async def stop():
+    """Stop the Lavalink server."""
+    global proc, task, stop_event
+
+    if proc:
+        proc.send_signal(signal.CTRL_C_EVENT)
+        await proc.wait()
+        proc = None
+
+    if task:
+        await stop_event.wait()
+        task.cancel()
+        task = None
+
+
+def check_file():
+    """Check if the Lavalink.jar file exists."""
+    try:
+        with open(LAVALINK_BIN):
+            return True
+    except FileNotFoundError:
+        return False
+
+
+async def default_config():
+    """Create a default Lavalink configuration file."""
+    LAVALINK_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+    with open(LAVALINK_CONFIG, "wb") as f:
+        config = base64.b64decode(
+            "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"
+        )
+        f.write(config)
+
+
+async def download_lavalink():
+    """Download Lavalink.jar from the official repo."""
+    LAVALINK_BIN.parent.mkdir(parents=True, exist_ok=True)
+    async with aiohttp.ClientSession() as session, session.get(
+        LAVALINK_URL, allow_redirects=True
+    ) as resp:
+        with open(LAVALINK_BIN, "wb") as f:
+            f.write(await resp.read())
+    await default_config()  # Create a default configuration file
+
+
+async def main(loop: asyncio.AbstractEventLoop):
+    """Main function to start the Lavalink server."""
+    global task
+
+    if not check_file():
+        logging.warning("Lavalink.jar not found. Downloading...")
+        await download_lavalink()
+    task = loop.create_task(start())