diff --git a/.env.example b/.env.example index d0ad650..d7f6c5d 100644 --- a/.env.example +++ b/.env.example @@ -1,6 +1,6 @@ DISCORD_BOT_TOKEN = "..." DISCORD_APPLICATION_ID = "..." -SRC_API_TOKEN = "..." +API_KEY = "..." GUILD_ID = "..." QUEUE_STATUS_CHANNEL_ID = "..." QUEUE_CHANNEL_ID = "..." @@ -10,4 +10,10 @@ EVENT_STAFF_ID = "..." TRIAL_STAFF_ID = "..." LOBBY_VC_ID = "..." BOTS_ROLE_ID = "..." -RANKED_ADMIN_USERNAME = "..." \ No newline at end of file +RANKED_ADMIN_USERNAME = "..." +ORCHESTRATOR_BASE_URL = "http://127.0.0.1:3000" +ORCHESTRATOR_TOKEN = "..." +ORCHESTRATOR_MODERATION_TOKEN = "..." +ORCHESTRATOR_ADMIN_TOKEN = "..." +ORCHESTRATOR_RELAY_CHAT_TO_DISCORD = "false" +SECONDWEBSITE_BASE_URL = "https://secondrobotics.org" diff --git a/Makefile b/Makefile index c2f9390..2edd5af 100644 --- a/Makefile +++ b/Makefile @@ -13,14 +13,13 @@ lock: check-lock: $(PYTHON) -m pip install --upgrade pip pip-tools - tmpfile=$$(mktemp); \ - $(PIPTOOLS) compile --resolver=backtracking --output-file=$$tmpfile requirements.in; \ - perl -0pi -e 's|pip-compile --output-file=.*? requirements\\.in|pip-compile --output-file=requirements.txt requirements.in|' $$tmpfile; \ - diff -u requirements.txt $$tmpfile; \ - rm $$tmpfile + set -eu; tmpfile=$$(mktemp); trap 'rm -f "$$tmpfile"' EXIT; \ + CUSTOM_COMPILE_COMMAND='pip-compile --output-file=requirements.txt requirements.in' $(PIPTOOLS) compile --resolver=backtracking --output-file=$$tmpfile requirements.in; \ + diff -u requirements.txt $$tmpfile run: $(PYTHON) main.py test: $(PYTHON) -m unittest discover -s tests -v + $(PYTHON) -m unittest test_regex_log -v diff --git a/README.md b/README.md index daf4bcb..f674f5e 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ A Discord bot written in Discord.py that runs ranked competitive matches for xRC ## Game Selection -`/launchserver` and `/hangout_create` search the full game catalog as you type. +`/launchserver` and `/casual_start` search the full game catalog as you type. The dropdown shows up to 25 suggestions at a time; type part of a game name (for example, `bio` for BioBuzz) to find games outside the initial suggestions. You can also submit a full game name without selecting a suggestion. Names @@ -49,3 +49,15 @@ test modules `test_*.py` so discovery includes them. Tests use dummy configurati and mock external effects, so no `.env` file, credentials, or live Discord connection is needed. Live Discord API acceptance is checked separately by deploying and synchronizing the bot's commands. + +## Server orchestration + +The orchestrator owns game processes, ports, logs, chat, and score snapshots. +Ranked and staff commands use scoped orchestrator bearer tokens. Subscriber casual +commands always call SecondWebsite with the shared API key; the website checks +entitlements and reserves credits. See `.env.example` for the required URLs/tokens. +Old game hangouts have been replaced by `/casual_start`, `/casual_status`, and `/casual_stop`. + +Use a clean environment when upgrading: legacy plotting, spreadsheet, process, +and image-decoding dependencies are no longer needed. Profile avatars still +appear in embeds; embed color no longer requires decoding a remote image. diff --git a/cogs/casual.py b/cogs/casual.py new file mode 100644 index 0000000..fc06dd5 --- /dev/null +++ b/cogs/casual.py @@ -0,0 +1,199 @@ +import logging +from datetime import datetime, timezone +from typing import Optional + +import discord +from discord import app_commands +from discord.ext import commands + +from config import ( + API_KEY, + GUILD_ID, + SECONDWEBSITE_BASE_URL, + server_games, +) +from website_client import WebsiteAPIError, WebsiteClient +from game_selection import game_autocomplete, resolve_game_id + +logger = logging.getLogger("discord") + + +def _session_is_active(session: Optional[dict]) -> bool: + if not session: + return False + return session.get("status") in {"launching", "starting", "running", "ready"} or session.get("orchestrator_state") in { + "requested", + "starting", + "running", + } + + +def _format_connection(session: dict) -> str: + host = session.get("host") or "pending" + port = session.get("port") or "pending" + return f"||Host: {host} Port: {port}||" + + +def _casual_session_embed(title: str, session: dict, *, color: discord.Color) -> discord.Embed: + embed = discord.Embed( + title=title, + description=f"Server `{session.get('comment', session.get('game', 'Casual Server'))}` is {session.get('status', 'pending')}.", + color=color, + timestamp=datetime.now(timezone.utc), + ) + embed.add_field(name="Game", value=session.get("game") or session.get("game_code") or "Unknown", inline=True) + embed.add_field(name="Connection", value=_format_connection(session), inline=False) + if session.get("password"): + embed.add_field(name="Password", value=f"||{session['password']}||", inline=True) + if session.get("allocated_minutes") or session.get("requested_minutes"): + embed.add_field( + name="Minutes", + value=str(session.get("allocated_minutes") or session.get("requested_minutes")), + inline=True, + ) + if session.get("expires_at"): + embed.add_field(name="Expires", value=session["expires_at"], inline=False) + return embed + + +class CasualServers(commands.Cog): + def __init__(self, bot, website: Optional[WebsiteClient] = None): + self.bot = bot + self.website = website or WebsiteClient( + SECONDWEBSITE_BASE_URL, + API_KEY, + ) + self.sessions_by_owner: dict[int, dict] = {} + + async def cog_unload(self): + await self.website.close() + + async def _get_active_website_session(self, user_id: int) -> Optional[dict]: + entitlement = await self.website.get_entitlement(user_id) + active_session = entitlement.get("active_session") + if _session_is_active(active_session): + self.sessions_by_owner[user_id] = active_session + return active_session + return None + + @app_commands.autocomplete(game=game_autocomplete) + @app_commands.command(name="casual_start", description="Start a subscriber casual xRC server") + async def casual_start( + self, + interaction: discord.Interaction, + game: str, + minutes: app_commands.Range[int, 5, 1440] = 60, + password: str = "", + comment: str = "", + ): + logger.info("%s called /casual_start", interaction.user.name) + await interaction.response.defer(ephemeral=True) + + game = resolve_game_id(game) + if game is None: + await interaction.followup.send("Choose a supported game from autocomplete.", ephemeral=True) + return + try: + entitlement = await self.website.get_entitlement(interaction.user.id) + except WebsiteAPIError as e: + logger.warning("SecondWebsite entitlement check failed: %s", e) + await interaction.followup.send(f"⚠ Casual server check failed: {e}", ephemeral=True) + return + + if not entitlement.get("active"): + await interaction.followup.send( + "⚠ SecondWebsite does not see an active casual server subscription for your Discord account.", + ephemeral=True, + ) + return + + active_session = entitlement.get("active_session") + if active_session: + self.sessions_by_owner[interaction.user.id] = active_session + embed = _casual_session_embed("Casual Server Already Active", active_session, color=discord.Color.orange()) + await interaction.followup.send(embed=embed, ephemeral=True) + return + + try: + casual_games = await self.website.get_casual_games() + except WebsiteAPIError as e: + logger.warning("SecondWebsite casual game lookup failed: %s", e) + await interaction.followup.send(f"⚠ Could not load casual games from SecondWebsite: {e}", ephemeral=True) + return + + game_record = next((g for g in casual_games if str(g.get("gameCode")) == str(game) and g.get("casualEnabled", True)), None) + if not game_record: + await interaction.followup.send("⚠ SecondWebsite does not currently allow casual servers for that game.", ephemeral=True) + return + + game_name = game_record.get("name") or next((name for name, code in server_games.items() if code == str(game)), str(game)) + launch_comment = (comment or f"Casual{game_record.get('shortCode') or game}")[:120] + + try: + session = await self.website.start_casual_server( + owner_discord_id=interaction.user.id, + game_code=game, + game=game_name, + requested_minutes=minutes, + comment=launch_comment, + password=password, + guild_id=interaction.guild_id, + channel_id=interaction.channel_id, + interaction_id=interaction.id, + ) + except WebsiteAPIError as e: + logger.warning("SecondWebsite casual launch failed: %s", e) + await interaction.followup.send(f"⚠ Casual server launch failed: {e}", ephemeral=True) + return + + self.sessions_by_owner[interaction.user.id] = session + await interaction.followup.send( + embed=_casual_session_embed("Casual Server Started", session, color=discord.Color.green()), + ephemeral=True, + ) + + @app_commands.command(name="casual_status", description="Show your active casual xRC server") + async def casual_status(self, interaction: discord.Interaction): + logger.info("%s called /casual_status", interaction.user.name) + await interaction.response.defer(ephemeral=True) + try: + session = await self._get_active_website_session(interaction.user.id) + except WebsiteAPIError as e: + await interaction.followup.send(f"⚠ Could not fetch casual server status: {e}", ephemeral=True) + return + + if not session: + await interaction.followup.send("You do not have an active casual server.", ephemeral=True) + return + + await interaction.followup.send( + embed=_casual_session_embed("Casual Server Status", session, color=discord.Color.blue()), + ephemeral=True, + ) + + @app_commands.command(name="casual_stop", description="Stop your active casual xRC server") + async def casual_stop(self, interaction: discord.Interaction): + logger.info("%s called /casual_stop", interaction.user.name) + await interaction.response.defer(ephemeral=True) + + try: + session = await self._get_active_website_session(interaction.user.id) + if not session: + await interaction.followup.send("You do not have an active casual server.", ephemeral=True) + return + + stopped = await self.website.stop_casual_server(session["id"], reason="discord_bot_stop") + self.sessions_by_owner.pop(interaction.user.id, None) + await interaction.followup.send( + embed=_casual_session_embed("Casual Server Stopping", stopped or session, color=discord.Color.orange()), + ephemeral=True, + ) + except WebsiteAPIError as e: + await interaction.followup.send(f"⚠ Could not stop casual server: {e}", ephemeral=True) + + +async def setup(bot: commands.Bot) -> None: + cog = CasualServers(bot) + guild = await bot.fetch_guild(GUILD_ID) + assert guild is not None + await bot.add_cog(cog, guilds=[guild]) diff --git a/cogs/gamehangout.py b/cogs/gamehangout.py deleted file mode 100644 index 2e87973..0000000 --- a/cogs/gamehangout.py +++ /dev/null @@ -1,1415 +0,0 @@ -import asyncio -import discord -from discord import app_commands, ButtonStyle -from discord.ext import commands -from discord.ui import View, Button -import random -from datetime import datetime -import logging -from config import * -from game_selection import game_autocomplete, resolve_game_id - -logger = logging.getLogger('discord') - -class JoinHangoutButton(Button): - def __init__(self, hangout_session): - super().__init__(style=ButtonStyle.green, label="Join Hangout", emoji="🎮") - self.hangout_session = hangout_session - - async def callback(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - if interaction.user in self.hangout_session.players: - await interaction.response.send_message("You're already in this hangout!", ephemeral=True) - return - - # Defer the response first to avoid conflicts - await interaction.response.defer() - - # Add player to list - self.hangout_session.players.append(interaction.user) - - # Assign hangout role - try: - await interaction.user.add_roles(self.hangout_session.hangout_role) - logger.info(f"Added hangout role to {interaction.user.display_name}") - except Exception as e: - logger.error(f"Failed to assign hangout role: {e}") - - # Move player to hangout VC if they're in a voice channel - if interaction.user.voice and self.hangout_session.hangout_vc: - try: - await interaction.user.move_to(self.hangout_session.hangout_vc) - except Exception as e: - logger.error(f"Failed to move player to hangout VC: {e}") - - await self.hangout_session.update_embed_deferred(interaction) - -class LeaveHangoutButton(Button): - def __init__(self, hangout_session): - super().__init__(style=ButtonStyle.red, label="Leave Hangout", emoji="👋") - self.hangout_session = hangout_session - - async def callback(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - if interaction.user not in self.hangout_session.players: - await interaction.response.send_message("You're not in this hangout!", ephemeral=True) - return - - # Defer the response first to avoid conflicts - await interaction.response.defer() - - # Remove player from list - self.hangout_session.players.remove(interaction.user) - - # Remove hangout role - try: - await interaction.user.remove_roles(self.hangout_session.hangout_role) - logger.info(f"Removed hangout role from {interaction.user.display_name}") - except Exception as e: - logger.error(f"Failed to remove hangout role: {e}") - - # Remove from any team roles if in match - if self.hangout_session.red_role: - try: - await interaction.user.remove_roles(self.hangout_session.red_role) - except: - pass - if self.hangout_session.blue_role: - try: - await interaction.user.remove_roles(self.hangout_session.blue_role) - except: - pass - - await self.hangout_session.update_embed_deferred(interaction) - -class StartMatchButton(Button): - def __init__(self, hangout_session): - super().__init__(style=ButtonStyle.primary, label="Start Match", emoji="🚀") - self.hangout_session = hangout_session - - async def callback(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - # Check if user is in the hangout - if interaction.user not in self.hangout_session.players: - await interaction.response.send_message("You must be in the hangout to start a match!", ephemeral=True) - return - - if len(self.hangout_session.players) < 4: - await interaction.response.send_message("Need at least 4 players to start a match!", ephemeral=True) - return - - if self.hangout_session.match_in_progress: - await interaction.response.send_message("A match is already in progress!", ephemeral=True) - return - - if self.hangout_session.match_starting: - await interaction.response.send_message("A match is already being started! Please wait...", ephemeral=True) - return - - await self.hangout_session.start_match(interaction) - -class HangoutSession: - def __init__(self, host, game_type, guild, cog, channel): - self.host = host - self.game_type = game_type - self.guild = guild - self.cog = cog - self.channel = channel # Store the channel where command was run - self.players = [] - self.created_at = datetime.now() - self.message = None - - # Roles and VCs - self.hangout_role = None - self.hangout_vc = None - self.hangout_results_channel = None - self.red_role = None - self.blue_role = None - self.red_vc = None - self.blue_vc = None - - # Match tracking - self.match_in_progress = False - self.current_match_teams = {"red": [], "blue": [], "spectators": []} - self.matches_played = 0 - self.server_port = None - self.server_password = None - self.current_format = None # Track current server format (2v2 or 3v3) - self.last_result_message = None # Track last submit result message for cleanup - self.match_starting = False # Prevent double match starts - self.submitting_result = False # Prevent double submissions - - # Player statistics for this hangout session - self.player_stats = {} # player_id: {matches_sat_out, teammates, opponents, wins, losses, total_matches} - - async def create_hangout_resources(self): - """Create the hangout role, voice channel, and server""" - try: - # Create hangout role - role_name = f"Hangout - {self.game_type}" - self.hangout_role = await self.guild.create_role( - name=role_name, - color=discord.Color.green(), - mentionable=True, - reason=f"Hangout session for {self.game_type}" - ) - logger.info(f"Created hangout role: {role_name}") - - # Create hangout VC in same category as command channel with proper permissions - category = self.channel.category if self.channel.category else None - staff_role = discord.utils.get(self.guild.roles, id=EVENT_STAFF_ID) - trial_staff_role = discord.utils.get(self.guild.roles, id=TRIAL_STAFF_ID) - bots_role = discord.utils.get(self.guild.roles, id=BOTS_ROLE_ID) - - # Set permissions: only hangout role and staff can connect - overwrites = { - self.guild.default_role: discord.PermissionOverwrite(connect=False), - self.hangout_role: discord.PermissionOverwrite(connect=True), - } - - # Add staff permissions - if staff_role: - overwrites[staff_role] = discord.PermissionOverwrite(connect=True) - if trial_staff_role: - overwrites[trial_staff_role] = discord.PermissionOverwrite(connect=True) - if bots_role: - overwrites[bots_role] = discord.PermissionOverwrite(connect=True) - - vc_name = f"🎮 Hangout - {self.game_type}" - self.hangout_vc = await self.guild.create_voice_channel( - vc_name, - category=category, - overwrites=overwrites, - reason=f"Hangout voice channel for {self.game_type}" - ) - logger.info(f"Created hangout VC: {vc_name} in category: {category.name if category else 'None'}") - - # Create hangout results text channel - results_channel_name = f"hangout-results-{self.game_type.lower().replace(' ', '-')}" - results_overwrites = { - self.guild.default_role: discord.PermissionOverwrite(read_messages=False), - self.hangout_role: discord.PermissionOverwrite(read_messages=True, send_messages=False), - staff_role: discord.PermissionOverwrite(read_messages=True, send_messages=True), - trial_staff_role: discord.PermissionOverwrite(read_messages=True, send_messages=True), - bots_role: discord.PermissionOverwrite(read_messages=True, send_messages=True) - } - - self.hangout_results_channel = await self.guild.create_text_channel( - results_channel_name, - category=category, - overwrites=results_overwrites, - topic=f"Match results for {self.game_type} hangout session hosted by {self.host.display_name}", - reason=f"Hangout results channel for {self.game_type}" - ) - logger.info(f"Created hangout results channel: {results_channel_name}") - - # Start hangout server (default to 4 players for 2v2) - game_id = server_games[self.game_type] - password = str(random.randint(100, 999)) - min_players = 4 # Start with 2v2 format - - server_actions = self.cog.bot.get_cog('ServerActions') - if server_actions: - message, port = server_actions.start_server_process( - game_id, f"Hangout{self.game_type.replace(' ', '')}", password, - min_players=min_players, admin=RANKED_ADMIN_USERNAME - ) - if port != -1: - self.server_port = port - self.server_password = password - self.current_format = "2v2" # Track initial format - logger.info(f"Started hangout server on port {port} with 2v2 format") - else: - logger.warning(f"Failed to start hangout server: {message}") - - return True - except Exception as e: - logger.error(f"Failed to create hangout resources: {e}") - return False - - async def cleanup_hangout_resources(self): - """Clean up hangout role, voice channel, and server""" - # Move players to lobby first - lobby_vc = self.guild.get_channel(700415847294042162) - move_tasks = [] - for player in self.players: - if player.voice: - move_tasks.append(player.move_to(lobby_vc)) - - if move_tasks: - results = await asyncio.gather(*move_tasks, return_exceptions=True) - for i, result in enumerate(results): - if isinstance(result, Exception): - logger.error(f"Failed to move player to lobby: {result}") - - # Remove roles from all players - for player in self.players: - try: - if self.hangout_role: - await player.remove_roles(self.hangout_role) - if self.red_role: - await player.remove_roles(self.red_role) - if self.blue_role: - await player.remove_roles(self.blue_role) - except Exception as e: - logger.error(f"Failed to remove roles from {player.display_name}: {e}") - - # Stop hangout server - if self.server_port: - try: - server_actions = self.cog.bot.get_cog('ServerActions') - if server_actions: - server_actions.stop_server_process(self.server_port) - logger.info(f"Stopped hangout server on port {self.server_port}") - self.server_port = None - self.server_password = None - except Exception as e: - logger.error(f"Failed to stop hangout server: {e}") - - # Delete resources - try: - if self.hangout_role: - await self.hangout_role.delete(reason="Hangout session ended") - if self.hangout_vc: - await self.hangout_vc.delete(reason="Hangout session ended") - if self.hangout_results_channel: - await self.hangout_results_channel.delete(reason="Hangout session ended") - if self.message: - await self.message.delete() - logger.info("Deleted hangout creation message") - await self.cleanup_match_resources() - except Exception as e: - logger.error(f"Failed to cleanup hangout resources: {e}") - - async def cleanup_match_resources(self): - """Clean up match-specific roles and VCs (but keep server running)""" - try: - if self.red_role: - await self.red_role.delete(reason="Match ended") - self.red_role = None - if self.blue_role: - await self.blue_role.delete(reason="Match ended") - self.blue_role = None - if self.red_vc: - await self.red_vc.delete(reason="Match ended") - self.red_vc = None - if self.blue_vc: - await self.blue_vc.delete(reason="Match ended") - self.blue_vc = None - except Exception as e: - logger.error(f"Failed to cleanup match resources: {e}") - - # Note: Server stays running for the entire hangout session - - def init_player_stats(self, player_id): - """Initialize stats for a new player""" - if player_id not in self.player_stats: - self.player_stats[player_id] = { - "matches_sat_out": 0, - "teammates": {}, - "opponents": {}, - "wins": 0, - "losses": 0, - "total_matches": 0 - } - - def calculate_matchmaking_priority(self, available_players): - """Calculate priority for each player based on sitting out and relationship history""" - priorities = {} - - for player in available_players: - self.init_player_stats(player.id) - stats = self.player_stats[player.id] - - # Sitting out priority (exponential weight) - sitting_priority = 2 ** stats["matches_sat_out"] - - # Relationship diversity bonus (prefer players who haven't played with others much) - relationship_penalty = 0 - for other_player in available_players: - if other_player != player: - teammate_count = stats["teammates"].get(str(other_player.id), 0) - opponent_count = stats["opponents"].get(str(other_player.id), 0) - relationship_penalty += (teammate_count + opponent_count) * 0.1 - - priorities[player.id] = sitting_priority - relationship_penalty - - return priorities - - def select_match_players(self): - """Select players for the next match using matchmaking algorithm""" - if len(self.players) <= 6: - # Everyone plays if 6 or fewer players - return self.players, [] - - # Calculate priorities - priorities = self.calculate_matchmaking_priority(self.players) - - # Sort by priority (highest first) - sorted_players = sorted(self.players, key=lambda p: priorities[p.id], reverse=True) - - # Select top 6 players - match_players = sorted_players[:6] - spectators = sorted_players[6:] - - return match_players, spectators - - def assign_teams(self, match_players): - """Assign players to red and blue teams with balanced relationships""" - if len(match_players) == 4: - # 2v2 format - exactly 4 players - team_size = 2 - elif len(match_players) == 5: - # 2v2 format with 1 spectator - only use 4 players - team_size = 2 - match_players = match_players[:4] # Only use first 4 players - else: - # 3v3 format - 6+ players - team_size = 3 - - # Use sophisticated team balancing based on relationship history - best_assignment = self.find_optimal_team_assignment(match_players, team_size) - - red_team = best_assignment["red"] - blue_team = best_assignment["blue"] - spectators = best_assignment["spectators"] - - return red_team, blue_team, spectators - - def find_optimal_team_assignment(self, match_players, team_size): - """Find the optimal team assignment that maximizes relationship diversity""" - from itertools import combinations - - if len(match_players) < team_size * 2: - # Not enough players for full teams, use simple assignment - shuffled = match_players.copy() - random.shuffle(shuffled) - return { - "red": shuffled[:team_size], - "blue": shuffled[team_size:team_size*2], - "spectators": shuffled[team_size*2:] - } - - # Generate all possible team combinations - all_red_combinations = list(combinations(match_players, team_size)) - best_score = float('-inf') - best_assignment = None - - for red_team in all_red_combinations: - remaining_players = [p for p in match_players if p not in red_team] - - if len(remaining_players) >= team_size: - # Generate blue team combinations from remaining players - blue_combinations = list(combinations(remaining_players, team_size)) - - for blue_team in blue_combinations: - spectators = [p for p in remaining_players if p not in blue_team] - - # Calculate relationship diversity score for this assignment - score = self.calculate_team_balance_score(red_team, blue_team, spectators) - - if score > best_score: - best_score = score - best_assignment = { - "red": list(red_team), - "blue": list(blue_team), - "spectators": spectators - } - - # If no good assignment found, fall back to random - if best_assignment is None: - shuffled = match_players.copy() - random.shuffle(shuffled) - best_assignment = { - "red": shuffled[:team_size], - "blue": shuffled[team_size:team_size*2], - "spectators": shuffled[team_size*2:] - } - - return best_assignment - - def calculate_team_balance_score(self, red_team, blue_team, spectators): - """Calculate a score for how well-balanced this team assignment is""" - score = 0 - - # 1. Minimize frequent teammates playing together again - score += self.calculate_teammate_diversity_score(red_team) - score += self.calculate_teammate_diversity_score(blue_team) - - # 2. Maximize variety in opponents (prefer players who haven't faced each other much) - score += self.calculate_opponent_variety_score(red_team, blue_team) - - # 3. Bonus for including players who sat out recently - score += self.calculate_sitting_balance_score(red_team + blue_team, spectators) - - return score - - def get_relationship_stats(self, all_players): - """Get min, max, and average relationship counts for dynamic scaling""" - teammate_counts = [] - opponent_counts = [] - sitting_counts = [] - - for player in all_players: - self.init_player_stats(player.id) - stats = self.player_stats[player.id] - - # Collect all teammate relationship counts - teammate_counts.extend(stats["teammates"].values()) - - # Collect all opponent relationship counts - opponent_counts.extend(stats["opponents"].values()) - - # Collect sitting counts - sitting_counts.append(stats["matches_sat_out"]) - - return { - "teammate": { - "min": min(teammate_counts) if teammate_counts else 0, - "max": max(teammate_counts) if teammate_counts else 0, - "avg": sum(teammate_counts) / len(teammate_counts) if teammate_counts else 0 - }, - "opponent": { - "min": min(opponent_counts) if opponent_counts else 0, - "max": max(opponent_counts) if opponent_counts else 0, - "avg": sum(opponent_counts) / len(opponent_counts) if opponent_counts else 0 - }, - "sitting": { - "min": min(sitting_counts) if sitting_counts else 0, - "max": max(sitting_counts) if sitting_counts else 0, - "avg": sum(sitting_counts) / len(sitting_counts) if sitting_counts else 0 - } - } - - def calculate_teammate_diversity_score(self, team): - """Calculate score based on teammate diversity using dynamic scaling""" - if len(team) <= 1: - return 0 - - all_players = self.players - stats_ranges = self.get_relationship_stats(all_players) - - diversity_score = 0 - - for i, player1 in enumerate(team): - self.init_player_stats(player1.id) - stats1 = self.player_stats[player1.id] - - for j, player2 in enumerate(team): - if i >= j: # Avoid double counting - continue - - # Get how many times these players have been teammates - teammate_count = stats1["teammates"].get(str(player2.id), 0) - - # Dynamic scoring based on relative frequency - if stats_ranges["teammate"]["max"] == 0: - # No teammate history yet, all pairings are equal - diversity_score += 1 - else: - # Score inversely proportional to how common this pairing is - # Range from 1.0 (most common) to 2.0 (never paired) - relative_frequency = teammate_count / stats_ranges["teammate"]["max"] - diversity_score += 2.0 - relative_frequency - - return diversity_score - - def calculate_opponent_variety_score(self, red_team, blue_team): - """Calculate score based on opponent variety using dynamic scaling""" - all_players = self.players - stats_ranges = self.get_relationship_stats(all_players) - - variety_score = 0 - - for red_player in red_team: - self.init_player_stats(red_player.id) - red_stats = self.player_stats[red_player.id] - - for blue_player in blue_team: - # Get how many times these players have been opponents - opponent_count = red_stats["opponents"].get(str(blue_player.id), 0) - - # Dynamic scoring based on relative frequency - if stats_ranges["opponent"]["max"] == 0: - # No opponent history yet, all matchups are equal - variety_score += 1 - else: - # Score inversely proportional to how common this matchup is - # Range from 0.5 (most common) to 1.5 (never faced) - relative_frequency = opponent_count / stats_ranges["opponent"]["max"] - variety_score += 1.5 - relative_frequency - - return variety_score - - def calculate_sitting_balance_score(self, playing_players, spectators): - """Calculate score that favors including players who sat out recently using dynamic scaling""" - all_players = self.players - stats_ranges = self.get_relationship_stats(all_players) - - balance_score = 0 - - # If no sitting variation exists, treat all players equally - if stats_ranges["sitting"]["max"] == stats_ranges["sitting"]["min"]: - return 0 - - sitting_range = stats_ranges["sitting"]["max"] - stats_ranges["sitting"]["min"] - - # Bonus for including players who sat out (scaled to sitting range) - for player in playing_players: - self.init_player_stats(player.id) - sits = self.player_stats[player.id]["matches_sat_out"] - - # Players who sat out more get exponentially higher priority - if sitting_range > 0: - relative_sits = (sits - stats_ranges["sitting"]["min"]) / sitting_range - balance_score += relative_sits ** 2 * 10 # Quadratic scaling for sitting priority - - # Penalty for making players sit who haven't sat much (relative to others) - for player in spectators: - self.init_player_stats(player.id) - sits = self.player_stats[player.id]["matches_sat_out"] - - if sitting_range > 0: - relative_sits = (sits - stats_ranges["sitting"]["min"]) / sitting_range - # Higher penalty for making players sit who have sat less relative to others - balance_score -= (1.0 - relative_sits) * 3 - - return balance_score - - async def start_match(self, interaction): - """Start a new match with selected players""" - # Set starting flag to prevent double execution - self.match_starting = True - - try: - await interaction.response.defer() - - # Double-check conditions after defer (in case of race condition) - if self.match_in_progress: - await interaction.followup.send("A match is already in progress!", ephemeral=True) - return - - # Select players for match - match_players, session_spectators = self.select_match_players() - red_team, blue_team, match_spectators = self.assign_teams(match_players) - - all_spectators = session_spectators + match_spectators - - # Determine match format and check if server restart is needed - match_format = "2v2" if len(red_team) == 2 else "3v3" - min_players = 4 if match_format == "2v2" else 6 - - # Restart server if format changed - if self.current_format != match_format: - logger.info(f"Format changed from {self.current_format} to {match_format}, restarting server") - - # Stop current server - if self.server_port: - server_actions = self.cog.bot.get_cog('ServerActions') - if server_actions: - server_actions.stop_server_process(self.server_port) - logger.info(f"Stopped server on port {self.server_port}") - - # Start new server with correct player count - game_id = server_games[self.game_type] - password = str(random.randint(100, 999)) - - server_actions = self.cog.bot.get_cog('ServerActions') - if server_actions: - message, port = server_actions.start_server_process( - game_id, f"Hangout{self.game_type.replace(' ', '')}", password, - min_players=min_players, admin=RANKED_ADMIN_USERNAME - ) - if port != -1: - self.server_port = port - self.server_password = password - self.current_format = match_format - logger.info(f"Restarted hangout server on port {port} with {match_format} format") - - # Update main embed with new server info - await self.update_main_embed() - else: - logger.warning(f"Failed to restart hangout server: {message}") - - self.current_match_teams = { - "red": red_team, - "blue": blue_team, - "spectators": all_spectators - } - - # Create team roles - self.red_role = await self.guild.create_role( - name=f"Hangout Red - {self.game_type}", - color=discord.Color.red(), - mentionable=True, - reason=f"Red team for hangout match" - ) - - self.blue_role = await self.guild.create_role( - name=f"Hangout Blue - {self.game_type}", - color=discord.Color.blue(), - mentionable=True, - reason=f"Blue team for hangout match" - ) - - # Create team VCs with proper permissions in same category as hangout - category = self.channel.category if self.channel.category else None - staff_role = discord.utils.get(self.guild.roles, id=EVENT_STAFF_ID) - bots_role = discord.utils.get(self.guild.roles, id=BOTS_ROLE_ID) - - red_overwrites = { - self.guild.default_role: discord.PermissionOverwrite(connect=False, view_channel=False), - self.red_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True), - self.hangout_role: discord.PermissionOverwrite(view_channel=True, send_messages=False), - staff_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True), - bots_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True) - } - - blue_overwrites = { - self.guild.default_role: discord.PermissionOverwrite(connect=False, view_channel=False), - self.blue_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True), - self.hangout_role: discord.PermissionOverwrite(view_channel=True, send_messages=False), - staff_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True), - bots_role: discord.PermissionOverwrite(connect=True, view_channel=True, send_messages=True) - } - - self.red_vc = await self.guild.create_voice_channel( - f"🟥 Hangout Red - {self.game_type}", - category=category, - overwrites=red_overwrites - ) - - self.blue_vc = await self.guild.create_voice_channel( - f"🟦 Hangout Blue - {self.game_type}", - category=category, - overwrites=blue_overwrites - ) - - # Assign team roles and move players - move_tasks = [] - for player in red_team: - await player.add_roles(self.red_role) - if player.voice: - move_tasks.append(player.move_to(self.red_vc)) - - for player in blue_team: - await player.add_roles(self.blue_role) - if player.voice: - move_tasks.append(player.move_to(self.blue_vc)) - - # Execute all moves in parallel with better error handling - if move_tasks: - results = await asyncio.gather(*move_tasks, return_exceptions=True) - for i, result in enumerate(results): - if isinstance(result, Exception): - logger.error(f"Failed to move player to team VC: {result}") - - self.match_in_progress = True - - # Create match start embed - embed = discord.Embed( - title=f"🚀 Match #{self.matches_played + 1} Starting!", - description=f"**{self.game_type}** - {'2v2' if len(red_team) == 2 else '3v3'} Format", - color=0xff9900, - timestamp=datetime.now() - ) - - red_field = "\n".join([f"🟥 {player.display_name}" for player in red_team]) - blue_field = "\n".join([f"🟦 {player.display_name}" for player in blue_team]) - - embed.add_field(name="Red Team", value=red_field, inline=True) - embed.add_field(name="Blue Team", value=blue_field, inline=True) - - if all_spectators: - spectator_field = "\n".join([f"👁️ {player.display_name}" for player in all_spectators]) - embed.add_field(name="Spectators", value=spectator_field, inline=False) - - if self.server_port and self.server_password: - embed.add_field( - name="Server Info", - value=f"**Server:** Hangout{self.game_type.replace(' ', '')}\n**Password:** {self.server_password}\n**Port:** {self.server_port}", - inline=False - ) - - embed.set_footer(text="Teams have been moved to their voice channels. Good luck!") - - await interaction.followup.send( - f"{self.red_role.mention} {self.blue_role.mention}", - embed=embed - ) - - # Update main hangout message - await self.update_main_embed() - - except Exception as e: - logger.error(f"Failed to start match: {e}") - await interaction.followup.send("Failed to start match. Please try again.", ephemeral=True) - finally: - # Always reset the starting flag - self.match_starting = False - - def create_embed(self): - """Create the main hangout embed""" - embed = discord.Embed( - title=f"🎮 Game Hangout - {self.game_type}", - description=f"Casual hangout session for **{self.game_type}**", - color=0x00ff00 if not self.match_in_progress else 0xff9900, - timestamp=self.created_at - ) - - embed.add_field(name="Host", value=self.host.display_name, inline=True) - embed.add_field(name="Game", value=self.game_type, inline=True) - embed.add_field(name="Players", value=str(len(self.players)), inline=True) - embed.add_field(name="Matches Played", value=str(self.matches_played), inline=True) - - if self.hangout_role: - embed.add_field(name="Hangout Role", value=self.hangout_role.mention, inline=True) - - if self.hangout_vc: - embed.add_field(name="Voice Channel", value=self.hangout_vc.mention, inline=True) - - if self.server_port and self.server_password: - embed.add_field( - name="Server Info", - value=f"**Server:** Hangout{self.game_type.replace(' ', '')}\n**Password:** {self.server_password}\n**Port:** {self.server_port}", - inline=False - ) - - # Player list - if self.players: - player_list = "\n".join([f"• {player.display_name}" for player in self.players]) - if len(player_list) > 1024: - player_list = player_list[:1021] + "..." - - embed.add_field( - name=f"Player List ({len(self.players)})", - value=player_list, - inline=False - ) - else: - embed.add_field( - name="Player List", - value="No players yet - be the first to join!", - inline=False - ) - - # Match status - if self.match_in_progress: - embed.add_field( - name="Current Match", - value=f"🟥 **Red:** {', '.join([p.display_name for p in self.current_match_teams['red']])}\n" - f"🟦 **Blue:** {', '.join([p.display_name for p in self.current_match_teams['blue']])}", - inline=False - ) - embed.set_footer(text="Match in progress - Use /hangout_submit to submit scores") - else: - embed.set_footer(text="Use the buttons to join/leave • Staff can start matches with 4+ players") - - return embed - - def create_view(self): - """Create the interactive view with buttons""" - view = View(timeout=7200) # 2 hour timeout to prevent memory leaks - view.add_item(JoinHangoutButton(self)) - view.add_item(LeaveHangoutButton(self)) - - # Debug logging for start button visibility - should_show_start = not self.match_in_progress and len(self.players) >= 4 - logger.info(f"Start button check - Players: {len(self.players)}, Match in progress: {self.match_in_progress}, Should show start: {should_show_start}") - - if should_show_start: - view.add_item(StartMatchButton(self)) - return view - - async def update_embed(self, interaction): - """Update the main hangout embed""" - embed = self.create_embed() - view = self.create_view() - await interaction.response.edit_message(embed=embed, view=view) - - async def update_embed_deferred(self, interaction): - """Update the main hangout embed after deferring response""" - embed = self.create_embed() - view = self.create_view() - await interaction.edit_original_response(embed=embed, view=view) - - async def update_main_embed(self): - """Update the main hangout embed without interaction""" - if self.message: - embed = self.create_embed() - view = self.create_view() - logger.info(f"Updating main embed for hangout with {len(self.players)} players") - try: - await self.message.edit(embed=embed, view=view) - except Exception as e: - logger.error(f"Failed to update main embed: {e}") - - async def submit_match_result(self, red_score, blue_score): - """Submit match result and update stats""" - if not self.match_in_progress: - return False, "No match is currently in progress!" - - red_team = self.current_match_teams["red"] - blue_team = self.current_match_teams["blue"] - spectators = self.current_match_teams["spectators"] - - # Determine winner - red_wins = red_score > blue_score - - # Update player stats - for player in red_team + blue_team: - self.init_player_stats(player.id) - stats = self.player_stats[player.id] - - # Update win/loss - if player in red_team: - if red_wins: - stats["wins"] += 1 - else: - stats["losses"] += 1 - else: # blue team - if not red_wins: - stats["wins"] += 1 - else: - stats["losses"] += 1 - - stats["total_matches"] += 1 - stats["matches_sat_out"] = 0 # Reset sitting counter - - # Update teammate/opponent relationships - for other_player in red_team + blue_team: - if other_player != player: - other_id = str(other_player.id) - - if (player in red_team and other_player in red_team) or \ - (player in blue_team and other_player in blue_team): - # Teammate - stats["teammates"][other_id] = stats["teammates"].get(other_id, 0) + 1 - else: - # Opponent - stats["opponents"][other_id] = stats["opponents"].get(other_id, 0) + 1 - - # Update sitting counters for spectators - for player in spectators: - self.init_player_stats(player.id) - self.player_stats[player.id]["matches_sat_out"] += 1 - - # Move players back to main VC - move_tasks = [] - for player in red_team + blue_team: - if player.voice and self.hangout_vc: - move_tasks.append(player.move_to(self.hangout_vc)) - - if move_tasks: - results = await asyncio.gather(*move_tasks, return_exceptions=True) - for result in results: - if isinstance(result, Exception): - logger.error(f"Failed to move player back to hangout VC: {result}") - - # Clean up match resources - await self.cleanup_match_resources() - - # Update counters - self.matches_played += 1 - self.match_in_progress = False - self.current_match_teams = {"red": [], "blue": [], "spectators": []} - - # Update main embed - await self.update_main_embed() - - winner_team = "Red" if red_wins else "Blue" - return True, f"🏆 {winner_team} team wins {red_score}-{blue_score}! Match #{self.matches_played} complete." - - def generate_final_stats(self): - """Generate final statistics embed for the hangout session""" - embed = discord.Embed( - title=f"📊 Hangout Session Complete - {self.game_type}", - description=f"**Total Matches:** {self.matches_played}", - color=0x00ff00, - timestamp=datetime.now() - ) - - if not self.player_stats: - embed.add_field(name="No matches played", value="No statistics to display", inline=False) - return embed - - # Sort players by matches played, then by win rate - sorted_players = [] - for player_id, stats in self.player_stats.items(): - player = self.guild.get_member(int(player_id)) - if player and stats["total_matches"] > 0: - win_rate = (stats["wins"] / stats["total_matches"]) * 100 - sorted_players.append((player, stats, win_rate)) - - sorted_players.sort(key=lambda x: (x[1]["total_matches"], x[2]), reverse=True) - - # Player stats - stats_text = "" - for player, stats, win_rate in sorted_players: - stats_text += f"• **{player.display_name}**: {stats['wins']}W-{stats['losses']}L ({win_rate:.1f}%)\n" - - if stats_text: - embed.add_field(name="Player Stats", value=stats_text[:1024], inline=False) - - # Fun stats - if sorted_players: - most_matches = max(sorted_players, key=lambda x: x[1]["total_matches"]) - highest_wr = max([p for p in sorted_players if p[1]["total_matches"] >= 2], - key=lambda x: x[2], default=None) - - fun_stats = f"🏆 Most matches: **{most_matches[0].display_name}** ({most_matches[1]['total_matches']})\n" - if highest_wr: - fun_stats += f"🎯 Highest win rate: **{highest_wr[0].display_name}** ({highest_wr[2]:.1f}%)" - - embed.add_field(name="Session Highlights", value=fun_stats, inline=False) - - embed.set_footer(text=f"Session lasted from {self.created_at.strftime('%H:%M')} to {datetime.now().strftime('%H:%M')}") - return embed - -class GameHangout(commands.Cog): - def __init__(self, bot): - self.bot = bot - self.active_hangouts = {} # staff_user_id: HangoutSession - - @app_commands.command(description="Create a casual game hangout session (Staff Only)") - @app_commands.describe(game="Search for a game or enter its full name") - @app_commands.autocomplete(game=game_autocomplete) - async def hangout_create(self, interaction: discord.Interaction, game: str): - # Check if user is a Member and has staff permissions - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - if not any(role_id in [role.id for role in interaction.user.roles] for role_id in [EVENT_STAFF_ID, TRIAL_STAFF_ID]): - await interaction.response.send_message("Only staff members can create hangout sessions!", ephemeral=True) - return - - game_id = resolve_game_id(game) - if game_id is None: - await interaction.response.send_message( - "Unknown game. Choose a search suggestion or enter a full game name.", - ephemeral=True, - ) - return - - # Check if staff already has an active hangout - if interaction.user.id in self.active_hangouts: - await interaction.response.send_message("You already have an active hangout session! End it first with `/hangout_end`", ephemeral=True) - return - - # Check if any hangout already exists in this channel - for session in self.active_hangouts.values(): - if session.channel.id == interaction.channel.id: - await interaction.response.send_message(f"A hangout is already active in this channel! (Hosted by {session.host.display_name})", ephemeral=True) - return - - await interaction.response.defer() - - # Get game name from the choice value - game_name = next(name for name, value in server_games.items() if value == game_id) - - # Create hangout session - session = HangoutSession(interaction.user, game_name, interaction.guild, self, interaction.channel) - - # Create hangout resources - if not await session.create_hangout_resources(): - await interaction.followup.send("Failed to create hangout resources. Please try again.", ephemeral=True) - return - - # Store the session - self.active_hangouts[interaction.user.id] = session - - # Create and send the hangout message - embed = session.create_embed() - view = session.create_view() - - await interaction.followup.send(embed=embed, view=view) - - # Store message reference for updates - message = await interaction.original_response() - session.message = message - - logger.info(f"Hangout session created by {interaction.user.display_name} for {game_name}") - - @app_commands.command(description="End an active hangout session (Staff Only)") - async def hangout_end(self, interaction: discord.Interaction): - # Check if user is a Member and has staff permissions - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - if not any(role_id in [role.id for role in interaction.user.roles] for role_id in [EVENT_STAFF_ID, TRIAL_STAFF_ID]): - await interaction.response.send_message("Only staff members can end hangout sessions!", ephemeral=True) - return - - # Find hangout session in this channel (any staff can end any hangout) - session_to_end = None - session_host_id = None - for host_id, session in self.active_hangouts.items(): - if session.channel.id == interaction.channel.id: - session_to_end = session - session_host_id = host_id - break - - if not session_to_end: - await interaction.response.send_message("No active hangout session in this channel!", ephemeral=True) - return - - await interaction.response.defer() - - # Generate final stats - final_stats_embed = session_to_end.generate_final_stats() - - # Clean up all resources - await session_to_end.cleanup_hangout_resources() - - # Remove from active hangouts - del self.active_hangouts[session_host_id] - - # Post final stats to hangout results channel - if session_to_end.hangout_results_channel: - await session_to_end.hangout_results_channel.send(embed=final_stats_embed) - await interaction.followup.send(f"✅ Hangout session ended! Final stats posted to {session_to_end.hangout_results_channel.mention}") - else: - # Fallback to original channel if hangout results channel not found - await interaction.followup.send(embed=final_stats_embed) - logger.info(f"Hangout session ended by {interaction.user.display_name}") - - @app_commands.command(description="Submit match result for current hangout match") - @app_commands.describe( - red_score="Score for red team", - blue_score="Score for blue team" - ) - async def hangout_submit(self, interaction: discord.Interaction, red_score: int, blue_score: int): - # Check if user is a Member - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - # Find the hangout session this user is involved with - user_session = None - for session in self.active_hangouts.values(): - if interaction.user in session.players: - if session.match_in_progress: - # Any player in the hangout can submit scores - user_session = session - break - - if not user_session: - await interaction.response.send_message("You must be in an active hangout session with a match in progress to submit scores!", ephemeral=True) - return - - # Check if already submitting to prevent double submissions - if user_session.submitting_result: - await interaction.response.send_message("A match result is already being submitted! Please wait...", ephemeral=True) - return - - # Set submitting flag - user_session.submitting_result = True - - try: - await interaction.response.defer() - - # Double-check conditions after defer - if not user_session.match_in_progress: - await interaction.followup.send("No match is currently in progress!", ephemeral=True) - return - - success, message = await user_session.submit_match_result(red_score, blue_score) - - if success: - # Delete previous result message to prevent chat burial - if user_session.last_result_message: - try: - await user_session.last_result_message.delete() - logger.info("Deleted previous hangout result message") - except: - pass # Message might already be deleted - - # Create result embed - embed = discord.Embed( - title=f"🏆 Match Result Submitted", - description=message, - color=0x00ff00, - timestamp=datetime.now() - ) - - embed.add_field( - name="Final Score", - value=f"🟥 Red: {red_score}\n🟦 Blue: {blue_score}", - inline=True - ) - - embed.add_field( - name="Match Info", - value=f"**Game:** {user_session.game_type}\n**Match #:** {user_session.matches_played}", - inline=True - ) - - # Post to hangout results channel - if user_session.hangout_results_channel: - result_message = await user_session.hangout_results_channel.send(embed=embed) - user_session.last_result_message = result_message # Store for cleanup next time - # Also send a brief confirmation to the original channel - await interaction.followup.send(f"✅ Match result posted to {user_session.hangout_results_channel.mention}") - else: - # Fallback to original channel if hangout results channel not found - result_message = await interaction.followup.send(embed=embed) - user_session.last_result_message = result_message - else: - await interaction.followup.send(f"❌ {message}", ephemeral=True) - - except Exception as e: - logger.error(f"Failed to submit hangout match result: {e}") - await interaction.followup.send("Failed to submit match result. Please try again.", ephemeral=True) - finally: - # Always reset the submitting flag - user_session.submitting_result = False - - @app_commands.command(description="Skip current hangout match due to technical issues (Staff Only)") - @app_commands.describe(reason="Reason for skipping the match") - async def hangout_skip_match(self, interaction: discord.Interaction, reason: str = "Technical issues"): - # Check if user is a Member and has staff permissions - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - if not any(role_id in [role.id for role in interaction.user.roles] for role_id in [EVENT_STAFF_ID, TRIAL_STAFF_ID]): - await interaction.response.send_message("Only staff can skip matches!", ephemeral=True) - return - - # Find active hangout with match in progress - active_session = None - for session in self.active_hangouts.values(): - if session.match_in_progress: - active_session = session - break - - if not active_session: - await interaction.response.send_message("No match is currently in progress!", ephemeral=True) - return - - await interaction.response.defer() - - # Move players back to main VC - move_tasks = [] - for player in active_session.current_match_teams["red"] + active_session.current_match_teams["blue"]: - if player.voice and active_session.hangout_vc: - move_tasks.append(player.move_to(active_session.hangout_vc)) - - if move_tasks: - results = await asyncio.gather(*move_tasks, return_exceptions=True) - for result in results: - if isinstance(result, Exception): - logger.error(f"Failed to move player back to hangout VC during skip: {result}") - - # Clean up match resources but don't update stats - await active_session.cleanup_match_resources() - active_session.match_in_progress = False - active_session.current_match_teams = {"red": [], "blue": [], "spectators": []} - - # Update main embed - await active_session.update_main_embed() - - embed = discord.Embed( - title="⚠️ Match Skipped", - description=f"**Reason:** {reason}", - color=0xff9900, - timestamp=datetime.now() - ) - - embed.add_field( - name="Game", - value=active_session.game_type, - inline=True - ) - - embed.add_field( - name="Players Returned", - value="All players moved back to main hangout VC", - inline=False - ) - - await interaction.followup.send(embed=embed) - logger.info(f"Match skipped by {interaction.user.display_name}: {reason}") - - @app_commands.command(description="List all active hangout sessions") - async def hangout_list(self, interaction: discord.Interaction): - if not self.active_hangouts: - embed = discord.Embed( - title="🎮 Active Hangouts", - description="No active hangout sessions right now!", - color=0x808080 - ) - await interaction.response.send_message(embed=embed, ephemeral=True) - return - - embed = discord.Embed( - title="🎮 Active Hangout Sessions", - color=0x00ff00 - ) - - for staff_id, session in self.active_hangouts.items(): - status = "🔄 Match in progress" if session.match_in_progress else "💬 In lobby" - - embed.add_field( - name=f"{session.game_type}", - value=f"**Host:** {session.host.display_name}\n" - f"**Players:** {len(session.players)}\n" - f"**Matches:** {session.matches_played}\n" - f"**Status:** {status}", - inline=True - ) - - await interaction.response.send_message(embed=embed, ephemeral=True) - - # Slash commands for hangout operations - @app_commands.command(description="Join an active hangout session") - async def hangout_join(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - # Find hangout session in this channel - active_session = None - for session in self.active_hangouts.values(): - if session.channel.id == interaction.channel.id: - active_session = session - break - - if not active_session: - await interaction.response.send_message("No active hangout session in this channel! You can only join hangouts in the channel where they were created.", ephemeral=True) - return - - if interaction.user in active_session.players: - await interaction.response.send_message("You're already in this hangout!", ephemeral=True) - return - - # Add player to list - active_session.players.append(interaction.user) - - # Assign hangout role - try: - await interaction.user.add_roles(active_session.hangout_role) - logger.info(f"Added hangout role to {interaction.user.display_name}") - except Exception as e: - logger.error(f"Failed to assign hangout role: {e}") - - # Move player to hangout VC if they're in a voice channel - if interaction.user.voice and active_session.hangout_vc: - try: - await interaction.user.move_to(active_session.hangout_vc) - except Exception as e: - logger.error(f"Failed to move player to hangout VC: {e}") - - # Update main hangout embed - await active_session.update_main_embed() - - await interaction.response.send_message(f"✅ {interaction.user.display_name} joined the {active_session.game_type} hangout!") - - @app_commands.command(description="Leave the active hangout session") - async def hangout_leave(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - # Find hangout session this user is in - user_session = None - for session in self.active_hangouts.values(): - if interaction.user in session.players: - user_session = session - break - - if not user_session: - await interaction.response.send_message("You're not in any hangout session!", ephemeral=True) - return - - # Remove player from list - user_session.players.remove(interaction.user) - - # Remove hangout role - try: - await interaction.user.remove_roles(user_session.hangout_role) - logger.info(f"Removed hangout role from {interaction.user.display_name}") - except Exception as e: - logger.error(f"Failed to remove hangout role: {e}") - - # Remove from any team roles if in match - if user_session.red_role: - try: - await interaction.user.remove_roles(user_session.red_role) - except: - pass - if user_session.blue_role: - try: - await interaction.user.remove_roles(user_session.blue_role) - except: - pass - - # Update main hangout embed - await user_session.update_main_embed() - - await interaction.response.send_message(f"👋 {interaction.user.display_name} left the {user_session.game_type} hangout!") - - @app_commands.command(description="Start a match in the active hangout session") - async def hangout_start(self, interaction: discord.Interaction): - # Check if user is a Member (has roles) - if not isinstance(interaction.user, discord.Member): - await interaction.response.send_message("This command can only be used in a server!", ephemeral=True) - return - - # Find hangout session in this channel - active_session = None - for session in self.active_hangouts.values(): - if session.channel.id == interaction.channel.id: - active_session = session - break - - if not active_session: - await interaction.response.send_message("No active hangout session in this channel!", ephemeral=True) - return - - # Check if user is in the hangout - if interaction.user not in active_session.players: - await interaction.response.send_message("You must be in the hangout to start a match!", ephemeral=True) - return - - if len(active_session.players) < 4: - await interaction.response.send_message("Need at least 4 players to start a match!", ephemeral=True) - return - - if active_session.match_in_progress: - await interaction.response.send_message("A match is already in progress!", ephemeral=True) - return - - if active_session.match_starting: - await interaction.response.send_message("A match is already being started! Please wait...", ephemeral=True) - return - - # Start the match using the existing method - await active_session.start_match(interaction) - -async def setup(bot: commands.Bot) -> None: - cog = GameHangout(bot) - - guild = await bot.fetch_guild(GUILD_ID) - assert guild is not None - - await bot.add_cog( - cog, - guilds=[guild] - ) diff --git a/cogs/general.py b/cogs/general.py index b2f08da..e09f144 100644 --- a/cogs/general.py +++ b/cogs/general.py @@ -8,18 +8,16 @@ import os import threading import aiohttp -from PIL import Image import random -from io import BytesIO from config import * FALLBACK_AVATAR_URL = 'https://i0.wp.com/sbcf.fr/wp-content/uploads/2018/03/sbcf-default-avatar.png' # Replace with your fallback avatar URL logger = logging.getLogger('discord') -HEADER = {"x-api-key": SRC_API_TOKEN} +HEADER = {"X-API-KEY": API_KEY} -games = requests.get("https://secondrobotics.org/api/ranked/").json() +games = requests.get(f"{SECONDWEBSITE_BASE_URL}/api/ranked/", timeout=15).json() short_codes = [games['short_code'] for games in games] short_codes_sorted = sorted(short_codes) @@ -44,7 +42,7 @@ async def playerinfo(self, interaction: discord.Interaction, user: discord.Membe async with aiohttp.ClientSession(headers=HEADER, timeout=aiohttp.ClientTimeout(total=10)) as session: # Fetch player profile and avatar concurrently - async with session.get(f'https://secondrobotics.org/api/ranked/player/{user_id}') as response: + async with session.get(f'{SECONDWEBSITE_BASE_URL}/api/ranked/player/{user_id}') as response: res = await response.json() if not res["exists"]: @@ -53,22 +51,14 @@ async def playerinfo(self, interaction: discord.Interaction, user: discord.Membe ephemeral=True) return - # Fetch avatar for embed color + # Keep the avatar as a Discord-hosted image; decoding remote images + # just to choose an embed color is unnecessary. random_color = discord.Color.blue() - try: - async with session.get(res['avatar']) as response: - thumbnail_bytes = await response.read() - thumbnail_image = Image.open(BytesIO(thumbnail_bytes)) - w, h = thumbnail_image.size - random_pixel = thumbnail_image.getpixel((random.randint(0, w - 1), random.randint(0, h - 1))) - random_color = discord.Color.from_rgb(*random_pixel[:3]) - except Exception as e: - logger.error(f"Failed to fetch avatar: {e}") # Fetch all game stats concurrently async def fetch_game(game): try: - async with session.get(f'https://secondrobotics.org/api/ranked/{game}/player/{user_id}') as r: + async with session.get(f'{SECONDWEBSITE_BASE_URL}/api/ranked/{game}/player/{user_id}') as r: return await r.json() except Exception as e: logger.error(f"Failed to fetch game {game} for {user_id}: {e}") diff --git a/cogs/ranked.py b/cogs/ranked.py index d534347..939d10e 100644 --- a/cogs/ranked.py +++ b/cogs/ranked.py @@ -1,7 +1,5 @@ import asyncio from datetime import datetime, timedelta, timezone -from io import TextIOWrapper -import subprocess from typing import Dict, Optional from discord import app_commands, ButtonStyle from discord.ui import View, Button @@ -16,17 +14,10 @@ from dotenv import load_dotenv import os from discord.app_commands import Choice -import zipfile -import shutil from config import * import aiohttp import config -# Constants -SERVER_PATH = "./server/xRC Simulator.x86_64" -SERVER_LOGS_DIR = "./server_logs/" -XRC_SIM_ZIP_URL = "https://xrcsimulator.org/Downloads/xRC_Linux_Server.zip" -XRC_SIM_ZIP_PATH = "./xRC_Linux_Server.zip" XRC_SIM_LOGO_URL = "https://secondrobotics.org/logos/xRC%20Logo.png" RULES_CHANNEL_LINK = f"The rules can be found here: <#{RULES_CHANNEL_ID}>" QUEUE_CHANNEL_ERROR_MSG = f"<#{QUEUE_CHANNEL_ID}> >:(" @@ -45,11 +36,9 @@ team_size = 6 team_size_alt = 4 -HEADER = {"x-api-key": SRC_API_TOKEN} +HEADER = {"X-API-KEY": API_KEY} ip = requests.get('https://icanhazip.com').text -servers_active: Dict[int, subprocess.Popen] = {} -log_files: Dict[int, TextIOWrapper] = {} listener = commands.Cog.listener @@ -61,7 +50,7 @@ daily_game = random.choice(inactive_games) -games = requests.get("https://secondrobotics.org/api/ranked/").json() +games = requests.get(f"{SECONDWEBSITE_BASE_URL}/api/ranked/", timeout=15).json() games_choices = [Choice(name=game['name'], value=game['short_code']) for game in games if game['game'] in active_games] #or game['game'] == daily_game] @@ -224,6 +213,8 @@ def __init__(self, game, alliance_size: int, api_short: str, full_game_name: str self.api_short = api_short self.server_game = server_games[game] self.server_port = None # type: int | None + self.server_session_id = None # type: str | None + self.server_session = None # type: dict | None self.server_password = None # type: str | None self.full_game_name = full_game_name self.red_role = None # type: discord.Role | None @@ -269,7 +260,7 @@ def remove_match(self, match: XrcGame): async def handle_score_edit(interaction: discord.Interaction, qdata: XrcGame, red_score: int, blue_score: int): - url = f'https://secondrobotics.org/api/ranked/{qdata.api_short}/match/edit/' + url = f'{SECONDWEBSITE_BASE_URL}/api/ranked/{qdata.api_short}/match/edit/' json = { "red_score": red_score, "blue_score": blue_score @@ -809,7 +800,7 @@ async def get_player_info(self, player_id: int): return data del _player_cache[player_id] - url = f'https://secondrobotics.org/api/ranked/player/{player_id}' + url = f'{SECONDWEBSITE_BASE_URL}/api/ranked/player/{player_id}' try: async with self._get_session().get(url) as x: data = await x.json() @@ -960,12 +951,24 @@ async def random(self, qdata: Queue, interaction, game_type, from_button: bool = password = str(random.randint(100, 999)) min_players = games_players[qdata.api_short] server_actions = self.bot.get_cog('ServerActions') - message, port = server_actions.start_server_process( - match.server_game, f"Ranked{qdata.api_short}", password, min_players=min_players, admin=RANKED_ADMIN_USERNAME) + expected_discord_user_ids = [str(player.id) for player in (match.game.red | match.game.blue)] + message, port, session_id, session = await server_actions.start_server_process( + match.server_game, + f"Ranked{qdata.api_short}", + password, + min_players=min_players, + admin=RANKED_ADMIN_USERNAME, + kind="ranked", + match_id=f"{qdata.api_short}-{id(match)}", + ranked_game_mode=f"{match.full_game_name} {match.team_size}v{match.team_size}", + expected_discord_user_ids=expected_discord_user_ids, + ) if port == -1: logger.warning("Server couldn't auto-start for ranked: " + message) else: match.server_port = port + match.server_session_id = session_id + match.server_session = session match.server_password = password await self.display_teams(interaction, match) @@ -977,6 +980,13 @@ def find_match_by_port(self, port: int): return match return None + def find_match_by_session_id(self, session_id: str): + for queue in game_queues.values(): + for match in queue.matches: + if match.server_session_id == session_id: + return match + return None + def find_match_by_player(self, player: discord.Member): for queue in game_queues.values(): for match in queue.matches: @@ -986,7 +996,7 @@ def find_match_by_player(self, player: discord.Member): async def display_teams(self, ctx, match: XrcGame): async def fetch_player_elo(game, user_id): - url = f'https://secondrobotics.org/api/ranked/{game}/player/{user_id}' + url = f'{SECONDWEBSITE_BASE_URL}/api/ranked/{game}/player/{user_id}' try: async with self._get_session().get(url) as response: if response.status == 200: @@ -1177,7 +1187,12 @@ async def do_clear_match(self, guild: discord.Guild, match: XrcGame): if match.server_port: server_actions = self.bot.get_cog('ServerActions') - server_actions.stop_server_process(match.server_port) + if server_actions: + await server_actions.stop_server_process( + match.server_port, + session_id=match.server_session_id, + reason="ranked match cleared", + ) match.red_series = match.blue_series = 2 @@ -1221,6 +1236,67 @@ async def do_clear_match(self, guild: discord.Guild, match: XrcGame): queue.matches.remove(match) break + async def handle_orchestrator_inactivity_warning(self, event: dict): + match = self.find_match_by_session_id(event.get("sessionId")) or self.find_match_by_port(event.get("port")) + if not match or not match.game: + return + + for player in match.game.players: + try: + await player.send( + "Your ranked match has been inactive - if all players are not present soon, the match may be cleared." + ) + except discord.HTTPException: + pass + + if match.password_channel_id: + channel = self.bot.get_channel(match.password_channel_id) + if channel: + total = len(match.game.red | match.game.blue) + needed = total // 2 + 1 + embed = discord.Embed( + title="⏱ Match Inactivity", + description=( + "This match has been inactive.\n" + "Vote to clear if the match is not happening.\n" + f"**{needed}/{total}** votes needed to clear." + ), + color=discord.Color.orange(), + timestamp=datetime.now(timezone.utc) + ) + embed.set_footer(text="xRC Sim Ranked", icon_url=XRC_SIM_LOGO_URL) + view = ClearVoteView(self, channel.guild, match) + try: + msg = await channel.send( + f"{match.red_role.mention} {match.blue_role.mention}", + embed=embed, + view=view + ) + view.message = msg + except Exception as e: + logger.error(f"Error sending orchestrator inactivity warning: {e}") + + async def handle_orchestrator_inactivity_expired(self, event: dict): + match = self.find_match_by_session_id(event.get("sessionId")) or self.find_match_by_port(event.get("port")) + if not match: + return + + guild_obj = guild + if match.password_channel_id: + channel = self.bot.get_channel(match.password_channel_id) + guild_obj = channel.guild if channel else guild_obj + if not guild_obj: + return + + if match.game: + for player in match.game.players: + try: + await player.send("Your ranked match has been cancelled due to inactivity.") + except discord.HTTPException: + pass + + await self.do_clear_match(guild_obj, match) + @app_commands.command(name="queuevoting", description="Add yourself to a vote queue") @app_commands.choices(mode=[ Choice(name="3v3", value="3v3"), @@ -1401,27 +1477,28 @@ async def update(self, interaction: discord.Interaction): logger.info(f"{interaction.user.name} called /update") await interaction.response.defer(thinking=True) - if os.path.exists(XRC_SIM_ZIP_PATH): - os.remove(XRC_SIM_ZIP_PATH) + server_actions = self.bot.get_cog('ServerActions') + if not server_actions: + await interaction.followup.send("⚠ Update failed: orchestrator client is not loaded.") + return try: - file = download_file(XRC_SIM_ZIP_URL) + result = await server_actions.orchestrator.update_xrc_binary( + reason="Discord /update requested", + actor={ + "type": "discord_user", + "discordUserId": str(interaction.user.id), + "displayName": interaction.user.display_name, + }, + ) except Exception as e: - logger.error(e) - await interaction.followup.send("⚠ Update failed: Could not download file") + logger.error(f"Orchestrator xRC update failed: {e}") + await interaction.followup.send(f"⚠ Update failed: {e}") return - if os.path.exists("./server/"): - shutil.rmtree("./server/") - - with zipfile.ZipFile(file, 'r') as zip_ref: - zip_ref.extractall("./server") - - os.chmod(SERVER_PATH, 0o777) - os.remove(XRC_SIM_ZIP_PATH) - - await interaction.followup.send("✅ Updated to the latest release version of xRC Sim!") - logger.info("Updated successfully") + updated_at = result.get("updatedAt", "now") + await interaction.followup.send(f"✅ xRC server binary update started/completed via orchestrator at {updated_at}.") + logger.info("Orchestrator update succeeded") @app_commands.command(description="memes") @app_commands.checks.has_any_role("Event Staff") @@ -1880,7 +1957,7 @@ def check_series_end(self, current_match): return False, "Score Submitted" async def submit_score_to_api(self, current_match, red_score, blue_score): - url = f'https://secondrobotics.org/api/ranked/{current_match.api_short}/match/' + url = f'{SECONDWEBSITE_BASE_URL}/api/ranked/{current_match.api_short}/match/' json_data = { "red_alliance": [player.id for player in current_match.game.red] if current_match.game else [], "blue_alliance": [player.id for player in current_match.game.blue] if current_match.game else [], @@ -2011,7 +2088,12 @@ async def handle_game_end(self, interaction, qdata, current_match, embed): # Stop the server if it exists if current_match.server_port: server_actions = self.bot.get_cog('ServerActions') - server_actions.stop_server_process(current_match.server_port) + if server_actions: + await server_actions.stop_server_process( + current_match.server_port, + session_id=current_match.server_session_id, + reason="ranked series complete", + ) # Remove the match from queue qdata.remove_match(current_match) @@ -2071,7 +2153,19 @@ async def before_check_queue_joins(self): @tasks.loop(minutes=1) async def check_empty_servers(self): - for server in servers_active.copy(): + server_actions = self.bot.get_cog('ServerActions') + if not server_actions: + return + try: + active_ranked_sessions = await server_actions.orchestrator.list_servers(active="true", kind="ranked") + except Exception as e: + logger.error(f"Failed to fetch ranked sessions for inactivity check: {e}") + return + + for session in active_ranked_sessions: + server = session.get("port") + if not server: + continue if (await server_has_players(server)): last_active[server] = datetime.now() else: @@ -2126,9 +2220,6 @@ async def shutdown_server_inactivity(server: int): pass return - # stop_server_process(server) # FIXME - - async def server_has_players(server: int) -> bool: needed_players = 1 for queue in game_queues.values(): @@ -2137,29 +2228,17 @@ async def server_has_players(server: int) -> bool: needed_players = match.game_size break - process = servers_active.get(server, None) - if process is None or process.poll() is not None or process.stdout is None or process.stdin is None: + if not cog: return False - process.stdin.write(b"PLAYERS\n") - process.stdin.flush() - - while True: - line = process.stdout.readline().decode("utf-8") - if line != '_BEGIN_\n': - break - - players = [] - while True: - line = process.stdout.readline().decode("utf-8") - if line == '_END_\n': - break - players.append(line.strip()) - - if len(players) >= needed_players: - return True - - return False + server_actions = cog.bot.get_cog('ServerActions') + if not server_actions: + return False + try: + session = await server_actions.orchestrator.get_session_by_port(server) + return len(session.get("players") or []) >= needed_players + except Exception: + return False async def warn_server_inactivity(server: int): diff --git a/cogs/server.py b/cogs/server.py index 3baa1c1..8bdc029 100644 --- a/cogs/server.py +++ b/cogs/server.py @@ -1,870 +1,724 @@ -import os -import shutil # Ensure shutil is imported for directory operations -import subprocess +import asyncio import logging from datetime import datetime, timezone -from typing import Dict, Optional, List +from typing import Dict, Optional + import discord -from io import TextIOWrapper from discord import app_commands -from discord.ext import commands, tasks from discord.app_commands import Choice -import asyncio -import psutil -import json # For reading status.json -import re # Add import for regex -from dataclasses import dataclass # Add import for Player dataclass +from discord.ext import commands +from game_selection import game_autocomplete, resolve_game_id from config import ( - server_restart_modes, + GUILD_ID, + ORCHESTRATOR_ADMIN_TOKEN, + ORCHESTRATOR_BASE_URL, + ORCHESTRATOR_MODERATION_TOKEN, + ORCHESTRATOR_RELAY_CHAT_TO_DISCORD, + ORCHESTRATOR_TOKEN, PORTS, - server_game_settings, + QUEUE_STATUS_CHANNEL_ID, default_game_players, - GUILD_ID, server_games, - QUEUE_STATUS_CHANNEL_ID, + server_restart_modes, +) +from orchestrator_client import ( + OrchestratorAPIError, + OrchestratorClient, + OrchestratorTokens, + SERVICE_ACTOR, + discord_actor, ) -from game_selection import game_autocomplete, resolve_game_id -logger = logging.getLogger('discord') +logger = logging.getLogger("discord") -# Define other constants here -SERVER_PATH = "./server/xRC Simulator.x86_64" -SERVER_LOGS_DIR = "./server_logs/" -SERVER_GAME_DATA_DIR = "./server_game_data/" # Existing constant for score files -CHAT_LOGS_DIR = "./chat_logs/" # Directory for chat logs CHAT_LOG_CHANNEL_ID = 1505392192724799528 - ports_choices = [Choice(name=str(port), value=port) for port in PORTS] +ACTIVE_STATES = {"requested", "starting", "running", "stopping"} -@dataclass -class Player: - name: str - join_time: datetime - position: str - ip: str - -class ServerActions(commands.Cog): - servers_active: Dict[int, subprocess.Popen] = {} - log_files: Dict[int, TextIOWrapper] = {} - last_active: Dict[int, datetime] = {} - server_comments: Dict[int, str] = {} - server_games: Dict[int, str] = {} - watch_tasks: Dict[int, asyncio.Task] = {} # Keep track of watch tasks - players_active: Dict[int, List[Player]] = {} # New attribute to track players - log_read_positions: Dict[int, int] = {} # Added to track last read positions - watch_messages: Dict[int, discord.Message] = {} - chat_log_files: Dict[int, TextIOWrapper] = {} # Chat log files for each server - last_timer: Dict[int, float] = {} - score_posted: Dict[int, bool] = {} - chat_discord_buffer: List[str] = [] - server_data_cache: Dict[int, Optional[dict]] = {} - _CHAT_RE = re.compile(r"^(\d{1,2}/\d{1,2}/\d{4} \d{1,2}:\d{2}:\d{2} [AP]M): (\w+): (.+)\.$") - _JOIN_RE = re.compile(r"Player (\w+) joined on position (.+) from IP=(\d+\.\d+\.\d+\.\d+).") - _LEAVE_RE = re.compile(r"Removing (\w+)") - - def __init__(self, bot): - self.bot = bot - self.players_active = {} - self.log_read_positions = {} - self.watch_messages = {} - self.last_timer = {} - self.score_posted = {} - self.chat_discord_buffer = [] - self.server_data_cache = {} - self.chat_header_posted: set = set() - self.bot.loop.create_task(self.monitor_logs()) - self.bot.loop.create_task(self._flush_chat_buffer()) - - async def monitor_logs(self): - while True: - for port, process in list(self.servers_active.items()): - log_path = f"{SERVER_LOGS_DIR}{port}.log" - - if port not in self.log_read_positions: - try: - with open(log_path, "r") as f: - last_start_pos = 0 - while True: - line = f.readline() - if not line: - break - if "Done setting up TCP socket.." in line: # Updated start signal - last_start_pos = f.tell() - self.log_read_positions[port] = last_start_pos - except FileNotFoundError: - logger.error(f"Log file for port {port} not found.") - continue - except Exception as e: - logger.error(f"Error initializing log file for port {port}: {e}") - continue - - try: - with open(log_path, "r") as f: - f.seek(self.log_read_positions[port]) # Move to the last read position - while True: - line = f.readline() - if not line: - break - self.parse_log_line(port, line) - self.log_read_positions[port] = f.tell() # Update read position - except FileNotFoundError: - logger.error(f"Log file for port {port} not found.") - except Exception as e: - logger.error(f"Error reading log file for port {port}: {e}") - - self.server_data_cache[port] = self.get_server_data(port) - await self._check_match_end(port) - - await asyncio.sleep(1) - - def parse_log_line(self, port: int, line: str): - chat_match = self._CHAT_RE.match(line) - if chat_match: - timestamp_str, username, chat_message = chat_match.groups() - self.log_chat_message(port, timestamp_str, username, chat_message) - return - - # Extract timestamp from the beginning of the log line for other logics - try: - timestamp_str, message = line.split(': ', 1) # Split timestamp and message - timestamp = datetime.strptime(timestamp_str, "%m/%d/%Y %I:%M:%S %p") # Parse timestamp - except ValueError: - return - - # Initialize player list if not present - if port not in self.players_active: - self.players_active[port] = [] - - # Clear player list on server start - if "Done setting up TCP socket.." in message: # Updated condition - self.players_active[port].clear() # Clear existing players - return - - # Clear player list on server shutdown - if "Server shut down at" in message: - self.players_active[port].clear() # Clear existing players - return - - join_match = self._JOIN_RE.search(message) - if join_match: - name, position, ip = join_match.groups() - player = Player(name=name, join_time=timestamp, position=position, ip=ip) # Use log timestamp - logger.info(f"{port} - Player {player.name} joined on {player.position} with ip {player.ip}") - self.players_active.setdefault(port, []).append(player) - return - - leave_match = self._LEAVE_RE.match(message) - if leave_match: - name = leave_match.group(1) - logger.info(f"{port} - Player {name} left server") - players = self.players_active.get(port, []) - self.players_active[port] = [p for p in players if p.name != name] - return - - def log_chat_message(self, port: int, timestamp: str, username: str, message: str): - """Log chat messages to separate chat log files, including IP if available""" - try: - # Ensure chat log file is open - if port not in self.chat_log_files: - os.makedirs(CHAT_LOGS_DIR, exist_ok=True) - chat_log_path = os.path.join(CHAT_LOGS_DIR, f"{port}.log") - self.chat_log_files[port] = open(chat_log_path, "a", encoding="utf-8") - - game_number = self.server_games.get(port, "Unknown") - game_name = next((n for n, num in server_games.items() if num == game_number), game_number) - alliance_size = default_game_players.get(game_number, 4) // 2 - game_format = f"{alliance_size}v{alliance_size}" - - # Try to find the IP for the username - ip = None - for player in self.players_active.get(port, []): - if player.name == username: - ip = player.ip - break - if ip: - log_entry = f"{timestamp} [{game_name} {game_format}]: {username} ({ip}): {message}\n" - else: - log_entry = f"{timestamp} [{game_name} {game_format}]: {username}: {message}\n" - self.chat_log_files[port].write(log_entry) - self.chat_log_files[port].flush() # Ensure it's written immediately - self._buffer_chat_message(port, game_name, game_format, username, ip, message) +def _game_name(game_code: str) -> str: + return next((name for name, number in server_games.items() if number == str(game_code)), str(game_code)) - logger.info(f"Chat on port {port} [{game_name} {game_format}] - {username}{' (' + ip + ')' if ip else ''}: {message}") - except Exception as e: - logger.error(f"Error logging chat message for port {port}: {e}") - def _buffer_chat_message(self, port: int, game_name: str, game_format: str, username: str, ip, message: str): - RESET = "\x1b[0m" - DIM_CYAN = "\x1b[2;36m" - BOLD_YELLOW = "\x1b[1;33m" - BOLD_GREEN = "\x1b[1;32m" - DIM = "\x1b[2m" +def _score_value(score: Optional[dict], key: str, fallback: str = "0") -> str: + if not score: + return fallback + value = score.get(key) + return fallback if value is None else str(value) - if port not in self.chat_header_posted: - self.chat_header_posted.add(port) - sep = "─" * 44 - self.chat_discord_buffer.append( - f"{BOLD_GREEN}{sep}\n" - f" 🟢 {game_name} {game_format} · Port {port}\n" - f"{sep}{RESET}" - ) - header = f"{DIM_CYAN}[{port} | {game_name} {game_format}]{RESET}" - user_part = f"{BOLD_YELLOW}{username}{RESET}" - ip_part = f" {DIM}({ip}){RESET}" if ip else "" - safe_message = message.replace("```", "`​`​`") - self.chat_discord_buffer.append(f"{header} {user_part}{ip_part}: {safe_message}") +def _players_by_alliance(players: list[dict]) -> tuple[list[dict], list[dict], list[dict]]: + red = [p for p in players if str(p.get("position", "")).lower().startswith("red")] + blue = [p for p in players if str(p.get("position", "")).lower().startswith("blue")] + spectators = [p for p in players if p not in red and p not in blue] + return red, blue, spectators - async def _flush_chat_buffer(self): - await self.bot.wait_until_ready() - channel = self.bot.get_channel(CHAT_LOG_CHANNEL_ID) - while True: - await asyncio.sleep(2) - if not self.chat_discord_buffer or not channel: - continue - lines, self.chat_discord_buffer = self.chat_discord_buffer, [] - chunks = [] - current = [] - current_len = 0 - for line in lines: - if current_len + len(line) + 1 > 1900: - chunks.append(current) - current = [] - current_len = 0 - current.append(line) - current_len += len(line) + 1 - if current: - chunks.append(current) - for chunk in chunks: - try: - await channel.send("```ansi\n" + "\n".join(chunk) + "\n```") - except Exception as e: - logger.error(f"Error flushing chat buffer to Discord: {e}") - @staticmethod - def _read_opr(port: int) -> Optional[Dict[str, list]]: - opr_path = os.path.join(SERVER_GAME_DATA_DIR, str(port), 'OPR.txt') - try: - with open(opr_path, 'r', encoding='utf-8') as f: - raw = f.read() - except OSError: - return None - entries = [] - for line in raw.splitlines(): - line = line.strip() - if not line: - continue - name, _, score = line.partition(':') - try: - score_val = float(score.strip()) - except ValueError: - score_val = 0.0 - entries.append((name.strip(), score_val)) - if not entries: - return None - midpoint = -(-len(entries) // 2) - return {'red': entries[:midpoint], 'blue': entries[midpoint:]} - - @staticmethod - def _parse_timer(raw) -> Optional[float]: - if raw is None: - return None - s = str(raw).strip() - if not s: - return None - if ':' in s: - try: - minutes, seconds = s.split(':', 1) - return float(minutes) * 60.0 + float(seconds) - except ValueError: - return None - try: - return float(s) - except ValueError: - return None - async def _check_match_end(self, port: int): - if not self.players_active.get(port): - return - data = self.server_data_cache.get(port) - if not data: - return - timer = self._parse_timer(data.get('timer')) - if timer is None: - return +def _player_name(player: dict) -> str: + return player.get("playerName") or player.get("name") or "Unknown" - prev = self.last_timer.get(port, 0.0) - if timer > 0: - self.score_posted[port] = False +def _player_ip(player: dict) -> Optional[str]: + return player.get("ipAddress") or player.get("ip") - self.last_timer[port] = timer - if timer <= 0 and prev > 0 and not self.score_posted.get(port, False): - ranked_cog = self.bot.get_cog('Ranked') - if not ranked_cog: - logger.warning(f"[match_end] port {port}: Ranked cog not found") - return - match = ranked_cog.find_match_by_port(port) - if not match: - logger.warning(f"[match_end] port {port}: no match found for port") - return - if not match.password_channel_id: - logger.warning(f"[match_end] port {port}: match has no password_channel_id") - return - logger.info(f"[match_end] port {port}: posting scores (prev={prev}, timer={timer})") - await self._post_match_scores(port, data, match) - self.score_posted[port] = True +def _format_player_lines(players: list[dict], *, include_ip: bool = False) -> str: + if not players: + return "None" + lines = [] + for player in players: + line = f"{_player_name(player)} - {player.get('position', 'Unknown')}" + ip = _player_ip(player) + if include_ip and ip and ip != "redacted": + line = f"{line}\nIP: {ip}" + lines.append(line) + return "\n".join(lines) - async def _post_match_scores(self, port: int, data: dict, match): - try: - channel = self.bot.get_channel(match.password_channel_id) - if not channel: - return - red = int(float(data['Score_R'])) - blue = int(float(data['Score_B'])) - if red > blue: - result = "🟥 Red wins" - color = discord.Color(0xE74C3C) - elif blue > red: - result = "🟦 Blue wins" - color = discord.Color(0x3498DB) - else: - result = "🤝 Tie" - color = discord.Color(0x95A5A6) - embed = discord.Embed( - title=f"🏁 {match.full_game_name} — Match Over", - description=f"## 🟥 `{red:>3}` — `{blue:<3}` 🟦\n**{result}**", - color=color, - timestamp=datetime.now(timezone.utc), - ) +def _opr_rows(score: dict) -> list[tuple[str, float]]: + if score.get("opr"): + return [(name, float(value)) for name, value in score["opr"].items()] - opr = self._read_opr(port) - if opr: - def fmt(entries): - if not entries: - return "—" - name_w = max(len(n) for n, _ in entries) - rows = [f"{name:<{name_w}} {score:>6g}" - for name, score in sorted(entries, key=lambda e: -e[1])] - return "```\n" + "\n".join(rows) + "\n```" - embed.add_field(name="🟥 Red OPR", value=fmt(opr['red']), inline=True) - embed.add_field(name="🟦 Blue OPR", value=fmt(opr['blue']), inline=True) + rows = [] + for entry in (score.get("redOpr") or []) + (score.get("blueOpr") or []): + if "playerName" not in entry or "value" not in entry: + continue + rows.append((str(entry["playerName"]), float(entry["value"]))) + return rows - await channel.send(embed=embed) - except Exception as e: - logger.error(f"Error posting match scores for port {port}: {e}") - - def start_server_process(self, game: str, comment: str, password: str = "", admin: str = "Admin", - restart_mode: int = -1, frame_rate: int = 60, update_time: int = 20, - tournament_mode: bool = True, start_when_ready: bool = True, - register: bool = True, spectators: int = 4, min_players: int = -1, - restart_all: bool = True, timeout: int = -1): - if not os.path.exists(SERVER_PATH): - return "⚠ xRC Sim server not found, use `/update` to update", -1 - - if len(self.servers_active) >= len(PORTS): - return "⚠ The maximum number of servers are already running", -1 - - port = -1 - for p in PORTS: - if p not in self.servers_active: - port = p - break - if port == -1: - return "⚠ Could not find a port to run the server on", -1 +def build_status_embed(session: dict, *, title_prefix: str = "Server Status") -> discord.Embed: + port = session.get("port", "Unknown") + score = session.get("score") or {} + players = session.get("players") or [] + red, blue, _ = _players_by_alliance(players) - # Set up output score files directory - output_dir = os.path.join(SERVER_GAME_DATA_DIR, str(port)) - os.makedirs(output_dir, exist_ok=True) # Create directories if they don't exist + embed = discord.Embed( + title=f"{title_prefix} for Port {port}", + color=discord.Color.blue(), + timestamp=datetime.now(timezone.utc), + ) + embed.add_field(name="Timer", value=_score_value(score, "timer", "N/A"), inline=True) + embed.add_field(name="Red Alliance", value=_format_player_lines(red), inline=True) + embed.add_field(name="Blue Alliance", value=_format_player_lines(blue), inline=True) + embed.add_field(name="Red Score", value=_score_value(score, "redScore"), inline=True) + embed.add_field(name="Blue Score", value=_score_value(score, "blueScore"), inline=True) + embed.add_field(name="Game Type", value=session.get("gameName") or _game_name(session.get("gameCode")), inline=True) + return embed - logger.info(f"Launching server on port {port}") - game_settings = server_game_settings.get(game, "") +class ServerActions(commands.Cog): + def __init__(self, bot, orchestrator: Optional[OrchestratorClient] = None): + self.bot = bot + self.orchestrator = orchestrator or OrchestratorClient( + ORCHESTRATOR_BASE_URL, + OrchestratorTokens( + default=ORCHESTRATOR_TOKEN, + moderation=ORCHESTRATOR_MODERATION_TOKEN, + admin=ORCHESTRATOR_ADMIN_TOKEN, + ), + ) + self.server_sessions_by_port: Dict[int, str] = {} + self.server_metadata: Dict[int, dict] = {} + self.watch_tasks: Dict[int, asyncio.Task] = {} + self.watch_messages: Dict[int, discord.Message] = {} + self.score_posted: Dict[str, bool] = {} + self._events_task: Optional[asyncio.Task] = None + self._last_event_id: Optional[str] = None + self.chat_discord_buffer: list[str] = [] + self.chat_header_posted: set[int] = set() + + async def cog_load(self): + self._events_task = asyncio.create_task(self._consume_orchestrator_events()) + if ORCHESTRATOR_RELAY_CHAT_TO_DISCORD: + asyncio.create_task(self._flush_chat_buffer()) + + async def cog_unload(self): + if self._events_task: + self._events_task.cancel() + for task in self.watch_tasks.values(): + task.cancel() + await self.orchestrator.close() + + def _launch_options( + self, + *, + restart_mode: int, + frame_rate: int, + update_time: int, + tournament_mode: bool, + start_when_ready: bool, + register: bool, + spectators: int, + min_players: int, + restart_all: bool, + ) -> dict: + return { + "frameRate": frame_rate, + "updateTime": update_time, + "tournamentMode": tournament_mode, + "register": register, + "spectators": spectators, + "startWhenReady": start_when_ready, + "restartAll": restart_all, + "restartMode": str(restart_mode), + "netStats": False, + "profiling": False, + "minPlayers": min_players, + } + + async def start_server_process( + self, + game: str, + comment: str, + password: str = "", + admin: str = "Admin", + restart_mode: int = -1, + frame_rate: int = 60, + update_time: int = 20, + tournament_mode: bool = True, + start_when_ready: bool = True, + register: bool = True, + spectators: int = 4, + min_players: int = -1, + restart_all: bool = True, + timeout: int = -1, + *, + kind: str = "admin", + actor: Optional[dict] = None, + match_id: Optional[str] = None, + ranked_game_mode: Optional[str] = None, + expected_discord_user_ids: Optional[list[str]] = None, + discord_channel_ids: Optional[dict] = None, + owner_discord_user_id: Optional[str] = None, + website_server_session_id: Optional[str] = None, + requested_minutes: Optional[int] = None, + max_minutes: Optional[int] = None, + ) -> tuple[str, int, Optional[str], Optional[dict]]: if restart_mode == -1: - restart_mode = server_restart_modes.get(game, 1) - + restart_mode = server_restart_modes.get(str(game), 1) if min_players == -1: - min_players = default_game_players.get(game, 4) - - f = open(f"{SERVER_LOGS_DIR}{port}.log", "a") - self.log_files[port] = f - f.write(f"Server started at {datetime.now()}\n") - - # Initialize chat log file - os.makedirs(CHAT_LOGS_DIR, exist_ok=True) - chat_log_path = os.path.join(CHAT_LOGS_DIR, f"{port}.log") - chat_f = open(chat_log_path, "a", encoding="utf-8") - self.chat_log_files[port] = chat_f - chat_f.write(f"=== Chat log started at {datetime.now()} ===\n") - - command = [ - SERVER_PATH, "-batchmode", "-nographics", - f"RouterPort={port}", f"Port={port}", f"Game={game}", - f"GameOption={restart_mode}", f"FrameRate={frame_rate}", - f"Tmode={'On' if tournament_mode else 'Off'}", - f"Register={'On' if register else 'Off'}", - f"Spectators={spectators}", f"UpdateTime={update_time}", - "MaxData=1000000", - f"StartWhenReady={'On' if start_when_ready else 'Off'}", - f"Comment={comment}", f"Password={password}", - f"Admin={admin}", f"GameSettings={game_settings}", - f"MinPlayers={min_players}", - f"RestartAll={'On' if restart_all else 'Off'}", - "NetStats=Off", "Profiling=Off", - f"OUTPUT_SCORE_FILES={output_dir}" # Added parameter - ] - - process = subprocess.Popen(command, stdout=f, stderr=f, shell=False) - self.servers_active[port] = process - self.last_active[port] = datetime.now() - self.server_comments[port] = comment - self.server_games[port] = game - - logger.info(f"Server launched on port {port}: '{comment}'") + min_players = default_game_players.get(str(game), 4) + + payload = { + "kind": kind, + "gameCode": str(game), + "comment": comment, + "password": password, + "adminUsername": admin, + "launchSource": "discord_bot", + "actor": actor or SERVICE_ACTOR, + "launchOptions": self._launch_options( + restart_mode=restart_mode, + frame_rate=frame_rate, + update_time=update_time, + tournament_mode=tournament_mode, + start_when_ready=start_when_ready, + register=register, + spectators=spectators, + min_players=min_players, + restart_all=restart_all, + ), + } - # Start timeout task if timeout is specified if timeout > 0: - asyncio.create_task(self._handle_server_timeout(port, timeout)) - - return f"✅ Launched server '{comment}' on port {port}", port + payload["timeoutMinutes"] = timeout + if kind == "ranked": + payload.update({ + "matchId": match_id, + "rankedGameMode": ranked_game_mode, + "minPlayers": min_players, + "expectedDiscordUserIds": expected_discord_user_ids or [], + "discordChannelIds": discord_channel_ids or {}, + }) + if kind == "casual": + payload.update({ + "websiteServerSessionId": website_server_session_id, + "ownerDiscordUserId": owner_discord_user_id, + "requestedMinutes": requested_minutes, + "maxMinutes": max_minutes, + }) - async def _handle_server_timeout(self, port: int, timeout_minutes: int): - """Handle server timeout by shutting it down after specified minutes""" try: - await asyncio.sleep(timeout_minutes * 60) # Convert minutes to seconds - if port in self.servers_active: - logger.info(f"Server on port {port} timed out after {timeout_minutes} minutes") - self.stop_server_process(port) - except asyncio.CancelledError: - logger.info(f"Timeout task for port {port} was cancelled") - except Exception as e: - logger.error(f"Error in timeout task for port {port}: {e}") - - def stop_server_process(self, port: int): - if port not in self.servers_active: - return f"⚠ Server on port {port} not found" - - logger.info(f"Shutting down server on port {port}") - if port in self.log_files: - self.log_files[port].write(f"Server shut down at {datetime.now()}\n") - - # Close chat log file - if port in self.chat_log_files: - self.chat_log_files[port].write(f"=== Chat log ended at {datetime.now()} ===\n") - self.chat_log_files[port].close() - del self.chat_log_files[port] - - process = self.servers_active[port] - process.terminate() + session = await self.orchestrator.launch_server({k: v for k, v in payload.items() if v is not None}) + except OrchestratorAPIError as e: + return f"⚠ Orchestrator launch failed: {e}", -1, None, None + + port = int(session["port"]) + session_id = session["id"] + self.server_sessions_by_port[port] = session_id + self.server_metadata[port] = session + return f"✅ Launched server '{comment}' on port {port}", port, session_id, session + + async def stop_server_process( + self, + port: int, + *, + session_id: Optional[str] = None, + reason: str = "discord stop requested", + actor: Optional[dict] = None, + ) -> str: try: - process.wait(timeout=5) - except subprocess.TimeoutExpired: - process.kill() - process.wait() - if port in self.log_files: - self.log_files[port].close() - self.servers_active.pop(port, None) - self.last_active.pop(port, None) - self.log_files.pop(port, None) - self.server_comments.pop(port, None) - self.server_games.pop(port, None) - self.log_read_positions.pop(port, None) - self.last_timer.pop(port, None) - self.chat_header_posted.discard(port) - self.score_posted.pop(port, None) - self.server_data_cache.pop(port, None) - - # Delete server data directory for the port being shut down - output_dir = os.path.join(SERVER_GAME_DATA_DIR, str(port)) - if os.path.exists(output_dir): - shutil.rmtree(output_dir) - logger.info(f"Deleted server data directory for port {port}") - - logger.info(f"Server on port {port} shut down") - - # Delete watch message using helper method - asyncio.create_task(self._delete_watch_message(port)) # Use helper method - - return f"✅ Server on port {port} shut down" + if session_id: + session = await self.orchestrator.stop_session(session_id, reason=reason, actor=actor) + else: + session = await self.orchestrator.stop_session_by_port(port, reason=reason, actor=actor) + except OrchestratorAPIError as e: + return f"⚠ Server on port {port} could not be stopped: {e}" + + self.server_sessions_by_port.pop(port, None) + self.server_metadata.pop(port, None) + await self._delete_watch_message(port) + stopped_port = session.get("port", port) if isinstance(session, dict) else port + return f"✅ Server on port {stopped_port} shut down" async def _create_watch_message(self, port: int, game_type: str): channel = self.bot.get_channel(QUEUE_STATUS_CHANNEL_ID) if channel: watch_message = await channel.send(f"🔔 **Server Started** on port `{port}`\n**Game Type:** {game_type}") self.watch_messages[port] = watch_message - # Start the watch task for this server task = self.bot.loop.create_task(self.server_watch_task(port, watch_message)) self.watch_tasks[port] = task - + async def _delete_watch_message(self, port: int): - watch_message = self.watch_messages.get(port) + watch_message = self.watch_messages.pop(port, None) if watch_message: try: await watch_message.delete() - del self.watch_messages[port] except discord.NotFound: - logger.warning(f"Watch message for port {port} not found.") + logger.warning("Watch message for port %s not found.", port) except Exception as e: - logger.error(f"Error deleting watch message for port {port}: {e}") - # Cancel the associated watch task - task = self.watch_tasks.get(port) - if task: - task.cancel() - del self.watch_tasks[port] - + logger.error("Error deleting watch message for port %s: %s", port, e) + + task = self.watch_tasks.pop(port, None) + if task: + task.cancel() + async def server_watch_task(self, port: int, message: discord.Message): - while port in self.servers_active: - data = self.server_data_cache.get(port) - if data: - embed = discord.Embed( - title=f"🖥️ Server Watch for Port {port}", - color=discord.Color.blue(), - timestamp=datetime.now(timezone.utc) - ) - embed.add_field(name="Game Type", value=self.server_games.get(port, "Unknown"), inline=True) - embed.add_field(name="Timer", value=data.get("timer", "N/A"), inline=True) - embed.add_field(name="Red Score", value=data.get("Score_R", "0"), inline=True) - embed.add_field(name="Blue Score", value=data.get("Score_B", "0"), inline=True) - - # Display players by alliance - players = self.players_active.get(port, []) - red_alliance = [p for p in players if p.position.lower().startswith("red")] - blue_alliance = [p for p in players if p.position.lower().startswith("blue")] - spectators = [p for p in players if not p.position.lower().startswith(("red", "blue"))] - - if red_alliance: - red_players = "\n".join(f"{p.name} - {p.position}" for p in red_alliance) - else: - red_players = "None" - embed.add_field(name="🔴 Red Alliance", value=red_players, inline=False) - - if blue_alliance: - blue_players = "\n".join(f"{p.name} - {p.position}" for p in blue_alliance) - else: - blue_players = "None" - embed.add_field(name="🔵 Blue Alliance", value=blue_players, inline=False) - - if spectators: - spectator_list = "\n".join(f"{p.name} - {p.position}" for p in spectators) - else: - spectator_list = "None" - embed.add_field(name="👁️ Spectators", value=spectator_list, inline=False) - - try: - await message.edit(embed=embed) - except discord.HTTPException as e: - logger.error(f"Failed to update watch embed for port {port}: {e}") + while True: + try: + session = await self.orchestrator.get_session_by_port(port) + if session.get("state") not in ACTIVE_STATES: break - await asyncio.sleep(5) # Update every 5 seconds + await message.edit(embed=build_status_embed(session, title_prefix="Server Watch")) + except OrchestratorAPIError as e: + logger.warning("Stopping watch for port %s: %s", port, e) + break + except discord.HTTPException as e: + logger.error("Failed to update watch embed for port %s: %s", port, e) + break + await asyncio.sleep(5) @app_commands.autocomplete(game=game_autocomplete) @app_commands.command(description="Launches a new instance of xRC Sim server", name="launchserver") - @app_commands.describe(game="Search for a game or enter its full name") @app_commands.checks.has_any_role("Event Staff") - async def launch_server(self, interaction: discord.Interaction, - game: str, comment: str, password: str = "", admin: str = "Admin", - restart_mode: int = -1, frame_rate: int = 120, update_time: int = 10, - tournament_mode: bool = True, start_when_ready: bool = True, - register: bool = True, spectators: int = 4, min_players: int = -1, - restart_all: bool = True, timeout: int = -1, silent: bool = False): - """Launches a new instance of xRC Sim server. - - Args: - game: The game to launch - comment: A comment/description for the server - password: Server password (optional) - admin: Admin username (default: "Admin") - restart_mode: Server restart mode (default: -1) - frame_rate: Server frame rate (default: 120) - update_time: Server update time (default: 10) - tournament_mode: Whether to enable tournament mode (default: True) - start_when_ready: Whether to start when ready (default: True) - register: Whether to register the server (default: True) - spectators: Number of spectator slots (default: 4) - min_players: Minimum players required (default: -1) - restart_all: Whether to restart all (default: True) - timeout: Server timeout in minutes (-1 for no timeout) (default: -1) - silent: If True, do not post to the queue channel (default: False) - """ - logger.info(f"{interaction.user.name} called /launchserver") - - game_id = resolve_game_id(game) - if game_id is None: - await interaction.response.send_message( - "Unknown game. Choose a search suggestion or enter a full game name.", - ephemeral=True, - ) + async def launch_server( + self, + interaction: discord.Interaction, + game: str, + comment: str, + password: str = "", + admin: str = "Admin", + restart_mode: int = -1, + frame_rate: int = 120, + update_time: int = 10, + tournament_mode: bool = True, + start_when_ready: bool = True, + register: bool = True, + spectators: int = 4, + min_players: int = -1, + restart_all: bool = True, + timeout: int = -1, + silent: bool = False, + ): + logger.info("%s called /launchserver", interaction.user.name) + game = resolve_game_id(game) + if game is None: + await interaction.response.send_message("Choose a supported game from autocomplete.", ephemeral=True) return - game = game_id + await interaction.response.defer() - result, port = self.start_server_process(game, comment, password, admin, restart_mode, frame_rate, update_time, - tournament_mode, start_when_ready, register, spectators, min_players, restart_all, timeout) + result, port, _, _ = await self.start_server_process( + game, + comment, + password, + admin, + restart_mode, + frame_rate, + update_time, + tournament_mode, + start_when_ready, + register, + spectators, + min_players, + restart_all, + timeout, + kind="admin", + actor=discord_actor(interaction.user), + ) if not silent and port != -1: - game_type = next(name for name, game_id in server_games.items() if game_id == game) - asyncio.create_task(self._create_watch_message(port, game_type)) + asyncio.create_task(self._create_watch_message(port, _game_name(game))) - await interaction.response.send_message(result) + await interaction.followup.send(result) @app_commands.command(description="Shutdown a running xRC Sim server", name="landserver") @app_commands.checks.has_any_role("Event Staff") @app_commands.choices(port=ports_choices) async def land_server(self, interaction: discord.Interaction, port: int): - logger.info(f"{interaction.user.name} called /landserver") - - result = self.stop_server_process(port) - + logger.info("%s called /landserver", interaction.user.name) + result = await self.stop_server_process(port, actor=discord_actor(interaction.user)) await interaction.response.send_message(result) + @app_commands.command(description="Restart a running xRC Sim server", name="restartserver") + @app_commands.checks.has_any_role("Event Staff") + @app_commands.choices(port=ports_choices) + async def restart_server(self, interaction: discord.Interaction, port: int, reason: str = "discord restart requested"): + logger.info("%s called /restartserver", interaction.user.name) + await interaction.response.defer() + try: + session = await self.orchestrator.get_session_by_port(port) + restarted = await self.orchestrator.restart_session(session["id"], reason=reason, actor=discord_actor(interaction.user)) + self.server_sessions_by_port[int(restarted["port"])] = restarted["id"] + self.server_metadata[int(restarted["port"])] = restarted + await interaction.followup.send(f"✅ Restarted server on port {restarted['port']}") + except OrchestratorAPIError as e: + await interaction.followup.send(f"⚠ Restart failed: {e}", ephemeral=True) + + @app_commands.command(description="Force kill a running xRC Sim server", name="killserver") + @app_commands.checks.has_any_role("Admin") + @app_commands.choices(port=ports_choices) + async def kill_server(self, interaction: discord.Interaction, port: int, reason: str): + logger.info("%s called /killserver", interaction.user.name) + await interaction.response.defer(ephemeral=True) + try: + session = await self.orchestrator.get_session_by_port(port) + await self.orchestrator.kill_session(session["id"], reason=reason, actor=discord_actor(interaction.user)) + self.server_sessions_by_port.pop(port, None) + self.server_metadata.pop(port, None) + await self._delete_watch_message(port) + await interaction.followup.send(f"✅ Killed server on port {port}", ephemeral=True) + except OrchestratorAPIError as e: + await interaction.followup.send(f"⚠ Kill failed: {e}", ephemeral=True) + @app_commands.command(description="Lists the running server instances", name="listservers") @app_commands.checks.has_any_role("Event Staff") async def list_servers(self, interaction: discord.Interaction): - logger.info(f"{interaction.user.name} called /listservers") - if not self.servers_active: - await interaction.response.send_message("⚠ No servers are running") + logger.info("%s called /listservers", interaction.user.name) + try: + sessions = await self.orchestrator.list_servers(active="true") + except OrchestratorAPIError as e: + await interaction.response.send_message(f"⚠ Could not list servers: {e}", ephemeral=True) return - server_list = [] - for port, process in self.servers_active.items(): - comment = self.server_comments.get(port, "N/A") - game_number = self.server_games.get(port, "Unknown") - game_name = next((name for name, number in server_games.items() if number == game_number), "Unknown") - server_list.append(f"Port {port}: {game_name} - '{comment}'") + if not sessions: + await interaction.response.send_message("⚠ No servers are running") + return - response = "Running servers:\n" + "\n".join(server_list) - await interaction.response.send_message(response) + lines = [ + f"Port {s.get('port')}: {s.get('gameName') or _game_name(s.get('gameCode'))} - '{s.get('comment', 'N/A')}' ({s.get('kind')}/{s.get('state')})" + for s in sessions + ] + await interaction.response.send_message("Running servers:\n" + "\n".join(lines)) @app_commands.command(description="Show live performance stats for running servers", name="serverstats") @app_commands.checks.has_any_role("Event Staff") async def server_stats(self, interaction: discord.Interaction): - logger.info(f"{interaction.user.name} called /serverstats") + logger.info("%s called /serverstats", interaction.user.name) await interaction.response.defer() - if not self.servers_active: + try: + overview, sessions = await asyncio.gather( + self.orchestrator.admin_overview(), + self.orchestrator.list_servers(active="true"), + ) + except OrchestratorAPIError as e: + await interaction.followup.send(f"⚠ Could not fetch server stats: {e}", ephemeral=True) + return + + if not sessions: await interaction.followup.send("⚠ No servers are currently running.") return - embed = discord.Embed(title="Server Performance", color=0x34dceb) - embed.timestamp = datetime.now() - - for port, process in self.servers_active.items(): - game_number = self.server_games.get(port, "Unknown") - game_name = next((n for n, num in server_games.items() if num == game_number), "Unknown") - comment = self.server_comments.get(port, "N/A") - start_time = self.last_active.get(port) - player_count = len(self.players_active.get(port, [])) - - uptime_str = "Unknown" - if start_time: - delta = datetime.now() - start_time - h, rem = divmod(int(delta.total_seconds()), 3600) - m, s = divmod(rem, 60) - uptime_str = f"{h}h {m}m {s}s" if h else f"{m}m {s}s" - - cpu_pct = "N/A" - mem_mb = "N/A" - try: - proc = psutil.Process(process.pid) - cpu_pct = f"{await asyncio.to_thread(proc.cpu_percent, 0.1):.1f}%" - mem_mb = f"{proc.memory_info().rss / 1024 / 1024:.1f} MB" - except (psutil.NoSuchProcess, psutil.AccessDenied) as e: - logger.warning(f"Could not get stats for port {port}: {e}") + detail_tasks = [ + self.orchestrator.get_session(session["id"]) if session.get("id") else asyncio.sleep(0, result=session) + for session in sessions + ] + session_details = await asyncio.gather(*detail_tasks, return_exceptions=True) + detailed_sessions = [ + detail if isinstance(detail, dict) else session + for session, detail in zip(sessions, session_details) + ] + + embed = discord.Embed(title="Server Performance", color=0x34DCEB, timestamp=datetime.now(timezone.utc)) + embed.description = ( + f"Running: {overview.get('runningServerCount', len(sessions))} | " + f"Available ports: {', '.join(map(str, overview.get('availablePorts', []))) or 'N/A'}" + ) + for session in detailed_sessions: + players = session.get("players") or [] + player_count = len(players) if players else session.get("playerCount", "N/A") embed.add_field( - name=f"Port {port} — {game_name}", + name=f"Port {session.get('port')} - {session.get('gameName') or _game_name(session.get('gameCode'))}", value=( - f"**Comment:** {comment}\n" - f"**Uptime:** {uptime_str}\n" + f"**Comment:** {session.get('comment', 'N/A')}\n" + f"**State:** {session.get('state', 'unknown')}\n" + f"**Kind:** {session.get('kind', 'unknown')}\n" f"**Players:** {player_count}\n" - f"**CPU:** {cpu_pct} | **RAM:** {mem_mb}" + f"**Last Activity:** {session.get('lastActivityAt') or 'N/A'}" ), - inline=False + inline=False, ) await interaction.followup.send(embed=embed) - def get_server_data(self, port: int) -> Optional[Dict[str, any]]: - """ - Retrieves server data for the specified port. - Reads Timer.txt, Score_R.txt, and Score_B.txt from the server data directory. - """ - server_data_dir = os.path.join(SERVER_GAME_DATA_DIR, str(port)) - timer_path = os.path.join(server_data_dir, 'Timer.txt') - score_r_path = os.path.join(server_data_dir, 'Score_R.txt') - score_b_path = os.path.join(server_data_dir, 'Score_B.txt') - - server_data = {} - - try: - with open(timer_path, 'r') as f: - server_data['timer'] = f.read().strip() - with open(score_r_path, 'r') as f: - server_data['Score_R'] = f.read().strip() - with open(score_b_path, 'r') as f: - server_data['Score_B'] = f.read().strip() - except FileNotFoundError: - logger.debug(f"Score files not yet available for port {port}") - return None - - return server_data - @app_commands.command(description="Retrieve server data once", name="server_peep") @app_commands.choices(port=ports_choices) async def server_peep(self, interaction: discord.Interaction, port: int): - logger.info(f"{interaction.user.name} called /server_peep for port {port}") - - data = self.get_server_data(port) - if not data: - await interaction.response.send_message(f"⚠ Unable to retrieve data for port {port}.", ephemeral=True) + logger.info("%s called /server_peep for port %s", interaction.user.name, port) + try: + session = await self.orchestrator.get_session_by_port(port) + except OrchestratorAPIError as e: + await interaction.response.send_message(f"⚠ Unable to retrieve data for port {port}: {e}", ephemeral=True) return - players = self.players_active.get(port, []) - red_alliance = [player.name for player in players if player.position.lower().startswith("red")] - blue_alliance = [player.name for player in players if player.position.lower().startswith("blue")] - - red_players = "\n".join(red_alliance) if red_alliance else "No players in Red Alliance." - blue_players = "\n".join(blue_alliance) if blue_alliance else "No players in Blue Alliance." - - red_score = data.get("Score_R", "0") - blue_score = data.get("Score_B", "0") - - game_type = self.server_games.get(port, "Unknown") - - embed = discord.Embed( - title=f"Server Status for Port {port}", - color=discord.Color.blue(), - timestamp=datetime.now(timezone.utc) + embed = build_status_embed(session) + embed.set_footer( + text=f"Requested by {interaction.user.display_name}", + icon_url=interaction.user.avatar.url if interaction.user.avatar else None, ) - embed.add_field(name="Timer", value=data.get("timer", "N/A"), inline=True) - embed.add_field(name="Red Alliance", value=red_players, inline=True) - embed.add_field(name="Blue Alliance", value=blue_players, inline=True) - embed.add_field(name="Red Score", value=red_score, inline=True) - embed.add_field(name="Blue Score", value=blue_score, inline=True) - embed.add_field(name="Game Type", value=game_type, inline=True) - embed.set_footer(text=f"Requested by {interaction.user.display_name}", icon_url=interaction.user.avatar.url if interaction.user.avatar else None) - await interaction.response.send_message(embed=embed) @app_commands.command(description="Watch server data and update every 5 seconds", name="server_watch") @app_commands.choices(port=ports_choices) async def server_watch(self, interaction: discord.Interaction, port: int): - logger.info(f"{interaction.user.name} called /server_watch for port {port}") - - if port not in self.servers_active: - await interaction.response.send_message(f"⚠ No active server on port {port}.", ephemeral=True) + logger.info("%s called /server_watch for port %s", interaction.user.name, port) + try: + session = await self.orchestrator.get_session_by_port(port) + except OrchestratorAPIError as e: + await interaction.response.send_message(f"⚠ No active server on port {port}: {e}", ephemeral=True) return - data = self.get_server_data(port) - if not data: - await interaction.response.send_message(f"⚠ Unable to retrieve data for port {port}.", ephemeral=True) + if session.get("state") not in ACTIVE_STATES: + await interaction.response.send_message(f"⚠ No active server on port {port}.", ephemeral=True) return - players = self.players_active.get(port, []) - red_alliance = [player.name for player in players if player.position.lower().startswith("red")] - blue_alliance = [player.name for player in players if player.position.lower().startswith("blue")] - - red_players = "\n".join(red_alliance) if red_alliance else "No players in Red Alliance." - blue_players = "\n".join(blue_alliance) if blue_alliance else "No players in Blue Alliance." - - red_score = data.get("Score_R", "0") - blue_score = data.get("Score_B", "0") - - game_type = self.server_games.get(port, "Unknown") - - embed = discord.Embed( - title=f"Watching Server Status for Port {port}", - color=discord.Color.green(), - timestamp=datetime.now(timezone.utc) + await interaction.response.send_message(embed=build_status_embed(session, title_prefix="Watching Server Status")) + self.watch_tasks[port] = self.bot.loop.create_task( + self.server_watch_task(port, await interaction.original_response()) ) - embed.add_field(name="Timer", value=data.get("timer", "N/A"), inline=True) - embed.add_field(name="Red Alliance", value=red_players, inline=True) - embed.add_field(name="Blue Alliance", value=blue_players, inline=True) - embed.add_field(name="Red Score", value=red_score, inline=True) - embed.add_field(name="Blue Score", value=blue_score, inline=True) - embed.add_field(name="Game Type", value=game_type, inline=True) - embed.set_footer(text=f"Watching by {interaction.user.display_name}", icon_url=interaction.user.avatar.url if interaction.user.avatar else None) - - await interaction.response.send_message(embed=embed) - - # Start the server_watch_task instead of defining update_embed - self.watch_tasks[port] = self.bot.loop.create_task(self.server_watch_task(port, await interaction.original_response())) @app_commands.command(description="Stops watching server data", name="stop_server_watch") @app_commands.choices(port=ports_choices) @app_commands.checks.has_any_role("Event Staff") async def stop_server_watch(self, interaction: discord.Interaction, port: int): - logger.info(f"{interaction.user.name} called /stop_server_watch for port {port}") - - if port not in self.watch_tasks: + logger.info("%s called /stop_server_watch for port %s", interaction.user.name, port) + task = self.watch_tasks.pop(port, None) + if not task: await interaction.response.send_message(f"⚠ No watch task running for port {port}.", ephemeral=True) return - - task = self.watch_tasks[port] task.cancel() - del self.watch_tasks[port] await interaction.response.send_message(f"✅ Stopped watching server on port {port}.") @app_commands.command(description="Investigate server players", name="investigate") @app_commands.checks.has_any_role("Admin", "Mod") @app_commands.choices(port=ports_choices) - async def investigate(self, interaction: discord.Interaction, port: int, public: bool = False): # Added 'public' parameter - logger.info(f"{interaction.user.name} called /investigate for port {port}") - players = self.players_active.get(port, []) + async def investigate(self, interaction: discord.Interaction, port: int, public: bool = False): + logger.info("%s called /investigate for port %s", interaction.user.name, port) + try: + session = await self.orchestrator.get_session_by_port(port, moderation=not public) + except OrchestratorAPIError as e: + await interaction.response.send_message(f"⚠ Could not inspect players: {e}", ephemeral=True) + return + + players = session.get("players") or [] if not players: await interaction.response.send_message("No active players on this server.", ephemeral=True) return - - # Sort players into alliances and spectators - red_alliance = [p for p in players if p.position.lower().startswith("red")] - blue_alliance = [p for p in players if p.position.lower().startswith("blue")] - spectators = [p for p in players if not p.position.lower().startswith(("red", "blue"))] - + + red, blue, spectators = _players_by_alliance(players) embed = discord.Embed( title=f"Players on Server Port {port}", color=discord.Color.purple(), - timestamp=datetime.now(timezone.utc) + timestamp=datetime.now(timezone.utc), ) - - # Add Red Alliance section - if red_alliance: - red_players = "\n".join( - [f"{p.name} - {p.position}" + (f"\nIP: {p.ip}" if not public else "") for p in red_alliance] - ) - else: - red_players = "None" - embed.add_field(name="🔴 Red Alliance", value=red_players, inline=False) - - # Add Blue Alliance section - if blue_alliance: - blue_players = "\n".join( - [f"{p.name} - {p.position}" + (f"\nIP: {p.ip}" if not public else "") for p in blue_alliance] + embed.add_field(name="🔴 Red Alliance", value=_format_player_lines(red, include_ip=not public), inline=False) + embed.add_field(name="🔵 Blue Alliance", value=_format_player_lines(blue, include_ip=not public), inline=False) + embed.add_field(name="👁️ Spectators", value=_format_player_lines(spectators, include_ip=not public), inline=False) + embed.set_footer( + text=f"Requested by {interaction.user.display_name}", + icon_url=interaction.user.avatar.url if interaction.user.avatar else None, + ) + await interaction.response.send_message(embed=embed, ephemeral=not public) + + async def _consume_orchestrator_events(self): + await self.bot.wait_until_ready() + types = ["match_timer_finished", "ranked_inactivity_warning", "ranked_inactivity_expired", "server_stopped"] + if ORCHESTRATOR_RELAY_CHAT_TO_DISCORD: + types.append("chat_message") + + while not self.bot.is_closed(): + try: + events = await self.orchestrator.get_events( + after_event_id=self._last_event_id, + types=types, + wait_ms=25000, + ) + for event in events: + await self._handle_orchestrator_event(event) + self._last_event_id = str(event.get("id")) + await self._reconcile_ranked_sessions() + except asyncio.CancelledError: + raise + except Exception as e: + logger.error("Orchestrator event consumer error: %s", e) + await asyncio.sleep(5) + + async def _reconcile_ranked_sessions(self): + ranked = self.bot.get_cog("Ranked") + if not ranked: + return + # Reachability failure raises; never clear Discord matches on an outage. + active = await self.orchestrator.list_servers(kind="ranked", active=True) + live_ids = {session["id"] for session in active} + for session_id in list(self.server_sessions_by_port.values()): + match = ranked.find_match_by_session_id(session_id) + if match and session_id not in live_ids: + await ranked.handle_orchestrator_inactivity_expired({"sessionId": session_id}) + + async def _handle_orchestrator_event(self, event: dict): + event_type = event.get("type") + if event_type == "server_stopped": + await self._reconcile_ranked_sessions() + elif event_type == "match_timer_finished": + await self._handle_match_timer_finished(event) + elif event_type == "ranked_inactivity_warning": + ranked = self.bot.get_cog("Ranked") + if ranked: + await ranked.handle_orchestrator_inactivity_warning(event) + elif event_type == "ranked_inactivity_expired": + ranked = self.bot.get_cog("Ranked") + if ranked: + await ranked.handle_orchestrator_inactivity_expired(event) + elif event_type == "chat_message" and ORCHESTRATOR_RELAY_CHAT_TO_DISCORD: + await self._handle_chat_message(event) + + async def _handle_match_timer_finished(self, event: dict): + session_id = event.get("sessionId") + if not session_id or self.score_posted.get(session_id): + return + + ranked = self.bot.get_cog("Ranked") + if not ranked: + return + + match = ranked.find_match_by_session_id(session_id) or ranked.find_match_by_port(event.get("port")) + if not match or not match.password_channel_id: + return + + try: + score = await self.orchestrator.get_latest_score(session_id) + except OrchestratorAPIError as e: + logger.error("Could not fetch score for session %s: %s", session_id, e) + return + + await self._post_match_scores(event.get("port"), score or {}, match) + self.score_posted[session_id] = True + + async def _post_match_scores(self, port: int, score: dict, match): + try: + channel = self.bot.get_channel(match.password_channel_id) + if not channel: + return + red = int(float(score.get("redScore", 0))) + blue = int(float(score.get("blueScore", 0))) + if red > blue: + result = "🟥 Red wins" + color = discord.Color(0xE74C3C) + elif blue > red: + result = "🟦 Blue wins" + color = discord.Color(0x3498DB) + else: + result = "🤝 Tie" + color = discord.Color(0x95A5A6) + + embed = discord.Embed( + title=f"🏁 {match.full_game_name} - Match Over", + description=f"## 🟥 `{red:>3}` - `{blue:<3}` 🟦\n**{result}**", + color=color, + timestamp=datetime.now(timezone.utc), ) - else: - blue_players = "None" - embed.add_field(name="🔵 Blue Alliance", value=blue_players, inline=False) - - # Add Spectators section - if spectators: - spectator_list = "\n".join( - [f"{p.name} - {p.position}" + (f"\nIP: {p.ip}" if not public else "") for p in spectators] + + opr = _opr_rows(score) + if opr: + rows = [f"{name:<20} {value:>6g}" for name, value in sorted(opr, key=lambda item: -item[1])] + embed.add_field(name="OPR", value="```\n" + "\n".join(rows[:20]) + "\n```", inline=False) + + await channel.send(embed=embed) + except Exception as e: + logger.error("Error posting match scores for port %s: %s", port, e) + + async def _handle_chat_message(self, event: dict): + port = int(event.get("port") or 0) + data = event.get("data") or {} + username = data.get("playerName", "Unknown") + message = data.get("message") or event.get("message") or "" + session = self.server_metadata.get(port) or {} + game_name = session.get("gameName") or _game_name(session.get("gameCode", "Unknown")) + game_number = str(session.get("gameCode", "")) + alliance_size = default_game_players.get(game_number, 4) // 2 + game_format = f"{alliance_size}v{alliance_size}" + self._buffer_chat_message(port, game_name, game_format, username, message) + + def _buffer_chat_message(self, port: int, game_name: str, game_format: str, username: str, message: str): + reset = "\x1b[0m" + dim_cyan = "\x1b[2;36m" + bold_yellow = "\x1b[1;33m" + bold_green = "\x1b[1;32m" + + if port not in self.chat_header_posted: + self.chat_header_posted.add(port) + sep = "-" * 44 + self.chat_discord_buffer.append( + f"{bold_green}{sep}\n {game_name} {game_format} | Port {port}\n{sep}{reset}" ) - else: - spectator_list = "None" - embed.add_field(name="👁️ Spectators", value=spectator_list, inline=False) - - embed.set_footer(text=f"Requested by {interaction.user.display_name}", icon_url=interaction.user.avatar.url if interaction.user.avatar else None) - await interaction.response.send_message(embed=embed, ephemeral=not public) # Set ephemeral based on 'public' + + safe_message = message.replace("```", "`\u200b`\u200b`") + self.chat_discord_buffer.append( + f"{dim_cyan}[{port} | {game_name} {game_format}]{reset} {bold_yellow}{username}{reset}: {safe_message}" + ) + + async def _flush_chat_buffer(self): + await self.bot.wait_until_ready() + channel = self.bot.get_channel(CHAT_LOG_CHANNEL_ID) + while True: + await asyncio.sleep(2) + if not self.chat_discord_buffer or not channel: + continue + lines, self.chat_discord_buffer = self.chat_discord_buffer, [] + chunks = [] + current = [] + current_len = 0 + for line in lines: + if current_len + len(line) + 1 > 1900: + chunks.append(current) + current = [] + current_len = 0 + current.append(line) + current_len += len(line) + 1 + if current: + chunks.append(current) + for chunk in chunks: + try: + await channel.send("```ansi\n" + "\n".join(chunk) + "\n```") + except Exception as e: + logger.error("Error flushing chat buffer to Discord: %s", e) + async def setup(bot: commands.Bot) -> None: cog = ServerActions(bot) guild = await bot.fetch_guild(GUILD_ID) assert guild is not None - - await bot.add_cog( - cog, - guilds=[guild] - ) + await bot.add_cog(cog, guilds=[guild]) diff --git a/cogs/userManagement.py b/cogs/userManagement.py index e157412..d71ca7f 100644 --- a/cogs/userManagement.py +++ b/cogs/userManagement.py @@ -3,11 +3,11 @@ from datetime import datetime import aiohttp import logging -from config import GUILD_ID, SRC_API_TOKEN +from config import GUILD_ID, API_KEY, SECONDWEBSITE_BASE_URL import time logger = logging.getLogger('discord') -HEADER = {"x-api-key": SRC_API_TOKEN} +HEADER = {"X-API-KEY": API_KEY} class UserManagement(commands.Cog): def __init__(self, bot): @@ -31,7 +31,7 @@ async def update_player_roles(self): logger.error("Guild not found.") return - url = "https://secondrobotics.org/api/ranked/leaderboard/RB3v3/" + url = f"{SECONDWEBSITE_BASE_URL}/api/ranked/leaderboard/RB3v3/" leaderboard_data = await self.fetch_leaderboard_data(url) if not leaderboard_data: return diff --git a/config.py b/config.py index 0479f04..b385237 100644 --- a/config.py +++ b/config.py @@ -15,10 +15,10 @@ logger.fatal('DISCORD_APPLICATION_ID not found') raise RuntimeError('DISCORD_APPLICATION_ID not found') -SRC_API_TOKEN = os.getenv('SRC_API_TOKEN') -if not SRC_API_TOKEN: - logger.fatal('SRC_API_TOKEN not found') - raise RuntimeError('SRC_API_TOKEN not found') +API_KEY = os.getenv('API_KEY') +if not API_KEY: + logger.fatal('API_KEY not found') + raise RuntimeError('API_KEY not found') GUILD_ID = int(os.getenv('GUILD_ID')) if not GUILD_ID: @@ -72,6 +72,14 @@ logger.fatal('RANKED_ADMIN_USERNAME not found') raise RuntimeError('RANKED_ADMIN_USERNAME not found') +ORCHESTRATOR_BASE_URL = os.getenv('ORCHESTRATOR_BASE_URL', 'http://127.0.0.1:3000') +ORCHESTRATOR_TOKEN = os.getenv('ORCHESTRATOR_TOKEN', '') +ORCHESTRATOR_MODERATION_TOKEN = os.getenv('ORCHESTRATOR_MODERATION_TOKEN', ORCHESTRATOR_TOKEN) +ORCHESTRATOR_ADMIN_TOKEN = os.getenv('ORCHESTRATOR_ADMIN_TOKEN', ORCHESTRATOR_TOKEN) +ORCHESTRATOR_RELAY_CHAT_TO_DISCORD = os.getenv('ORCHESTRATOR_RELAY_CHAT_TO_DISCORD', 'false').lower() in ('1', 'true', 'yes', 'on') + +SECONDWEBSITE_BASE_URL = os.getenv('SECONDWEBSITE_BASE_URL', os.getenv('SECOND_WEBSITE_BASE_URL', 'https://secondrobotics.org')).rstrip('/') + server_games = { "Test": "-1", diff --git a/gateway_intents.py b/gateway_intents.py new file mode 100644 index 0000000..53c57fa --- /dev/null +++ b/gateway_intents.py @@ -0,0 +1,6 @@ +import discord + + +def build_intents(): + """Slash commands, member/role caching, and voice movement only.""" + return discord.Intents(guilds=True, members=True, voice_states=True) diff --git a/main.py b/main.py index 2f1be0f..25849c2 100644 --- a/main.py +++ b/main.py @@ -7,18 +7,17 @@ from dotenv import load_dotenv from discord.utils import get from config import * +from gateway_intents import build_intents logger = logging.getLogger('discord') load_dotenv() -intents = discord.Intents.all() -intents.message_content = True class RankedBot(commands.Bot): def __init__(self): super().__init__( command_prefix="!!!", - intents=discord.Intents.all(), + intents=build_intents(), application_id=DISCORD_APPLICATION_ID) self.ranked_cog = None @@ -27,13 +26,7 @@ async def setup_hook(self): await self.load_extension("cogs.server") await self.load_extension("cogs.general") await self.load_extension("cogs.userManagement") # Load the new cog - - # Load gamehangout cog with error handling - try: - await self.load_extension("cogs.gamehangout") - logger.info("Successfully loaded gamehangout cog") - except Exception as e: - logger.error(f"Failed to load gamehangout cog: {e}") + await self.load_extension("cogs.casual") await self.tree.sync(guild=discord.Object(id=GUILD_ID)) diff --git a/orchestrator_client.py b/orchestrator_client.py new file mode 100644 index 0000000..bd62de7 --- /dev/null +++ b/orchestrator_client.py @@ -0,0 +1,216 @@ +import aiohttp +import asyncio +from dataclasses import dataclass +from typing import Any, Dict, Optional +from urllib.parse import urlencode + + +class OrchestratorAPIError(RuntimeError): + def __init__(self, status: int, code: str, message: str, details: Optional[dict] = None): + super().__init__(message) + self.status = status + self.code = code + self.details = details or {} + + +@dataclass +class OrchestratorTokens: + default: str + moderation: Optional[str] = None + admin: Optional[str] = None + + +def discord_actor(user) -> Dict[str, str]: + return { + "type": "discord_user", + "discordUserId": str(getattr(user, "id", "")), + "displayName": getattr(user, "display_name", None) or getattr(user, "name", "Discord User"), + } + + +SERVICE_ACTOR = {"type": "service", "displayName": "ranked-bot"} + + +class OrchestratorClient: + def __init__( + self, + base_url: str, + tokens: OrchestratorTokens, + session: Optional[aiohttp.ClientSession] = None, + timeout_seconds: int = 15, + ): + self.base_url = base_url.rstrip("/") + self.tokens = tokens + self._session = session + self._owns_session = session is None + self._timeout = aiohttp.ClientTimeout(total=timeout_seconds) + + async def close(self): + if self._owns_session and self._session and not self._session.closed: + await self._session.close() + + def _get_session(self) -> aiohttp.ClientSession: + if self._session is None or self._session.closed: + self._session = aiohttp.ClientSession(timeout=self._timeout) + self._owns_session = True + return self._session + + def _token_for_scope(self, scope: str) -> str: + if scope == "moderation": + return self.tokens.moderation or self.tokens.default + if scope == "admin": + return self.tokens.admin or self.tokens.default + return self.tokens.default + + async def _request(self, *args, **kwargs): + try: + return await self._request_unchecked(*args, **kwargs) + except (aiohttp.ClientError, asyncio.TimeoutError, TimeoutError, ValueError) as exc: + raise OrchestratorAPIError(0, 'SERVICE_UNAVAILABLE', 'The service could not be reached or returned an invalid response.') from exc + + async def _request_unchecked( + self, + method: str, + path: str, + *, + json: Optional[dict] = None, + query: Optional[dict] = None, + scope: str = "default", + timeout: Optional[aiohttp.ClientTimeout] = None, + ) -> Any: + token = self._token_for_scope(scope) + if not token: + raise OrchestratorAPIError( + 0, + "MISSING_TOKEN", + "ORCHESTRATOR_TOKEN is not configured.", + ) + + url = f"{self.base_url}{path}" + if query: + url = f"{url}?{urlencode({k: v for k, v in query.items() if v is not None})}" + + headers = {"Authorization": f"Bearer {token}"} + request_options = {"timeout": timeout} if timeout is not None else {} + async with self._get_session().request(method, url, json=json, headers=headers, **request_options) as response: + if response.status == 204: + return None + + content_type = response.headers.get("Content-Type", "") + payload = await response.json(content_type=None) if "json" in content_type else await response.text() + + if response.status >= 400: + err = payload.get("error", {}) if isinstance(payload, dict) else {} + raise OrchestratorAPIError( + response.status, + err.get("code", f"HTTP_{response.status}"), + err.get("message", str(payload)), + err.get("details", {}), + ) + return payload + + async def launch_server(self, payload: dict) -> dict: + return await self._request("POST", "/v1/servers", json=payload) + + async def list_servers(self, **filters) -> list[dict]: + payload = await self._request("GET", "/v1/servers", query=filters) + return payload.get("sessions", []) + + async def get_session(self, session_id: str) -> dict: + return await self._request("GET", f"/v1/servers/{session_id}") + + async def get_session_by_port(self, port: int, *, moderation: bool = False) -> dict: + return await self._request( + "GET", + f"/v1/servers/by-port/{port}", + scope="moderation" if moderation else "default", + ) + + async def stop_session(self, session_id: str, *, reason: str, actor: Optional[dict] = None) -> dict: + return await self._request( + "POST", + f"/v1/servers/{session_id}/stop", + json={"reason": reason, "actor": actor or SERVICE_ACTOR}, + ) + + async def stop_session_by_port(self, port: int, *, reason: str, actor: Optional[dict] = None) -> dict: + return await self._request( + "POST", + f"/v1/servers/by-port/{port}/stop", + json={"reason": reason, "actor": actor or SERVICE_ACTOR}, + ) + + async def restart_session(self, session_id: str, *, reason: str, actor: Optional[dict] = None) -> dict: + return await self._request( + "POST", + f"/v1/servers/{session_id}/restart", + json={"reason": reason, "actor": actor or SERVICE_ACTOR}, + ) + + async def kill_session(self, session_id: str, *, reason: str, actor: Optional[dict] = None) -> dict: + return await self._request( + "POST", + f"/v1/servers/{session_id}/kill", + json={"reason": reason, "actor": actor or SERVICE_ACTOR}, + scope="admin", + ) + + async def get_players(self, session_id: str, *, moderation: bool = False) -> list[dict]: + payload = await self._request( + "GET", + f"/v1/servers/{session_id}/players", + scope="moderation" if moderation else "default", + ) + return payload.get("players", []) + + async def get_chat(self, session_id: str, *, limit: int = 100, moderation: bool = False) -> list[dict]: + payload = await self._request( + "GET", + f"/v1/servers/{session_id}/chat", + query={"limit": limit}, + scope="moderation" if moderation else "default", + ) + return payload.get("messages", []) + + async def get_logs(self, session_id: str, *, lines: int = 100, download: bool = False) -> dict: + return await self._request( + "GET", + f"/v1/servers/{session_id}/logs", + query={"lines": lines, "download": str(download).lower()}, + scope="admin", + ) + + async def get_latest_score(self, session_id: str) -> Optional[dict]: + payload = await self._request("GET", f"/v1/servers/{session_id}/scores/latest") + return payload.get("score") + + async def admin_overview(self) -> dict: + return await self._request("GET", "/v1/admin/overview", scope="admin") + + async def update_xrc_binary(self, *, reason: str, actor: Optional[dict] = None) -> dict: + return await self._request( + "POST", + "/v1/admin/xrc-binary/update", + json={"reason": reason, "actor": actor or SERVICE_ACTOR}, + scope="admin", + ) + + async def get_events( + self, + *, + after_event_id: Optional[str] = None, + types: Optional[list[str]] = None, + wait_ms: int = 25000, + ) -> list[dict]: + payload = await self._request( + "GET", + "/v1/events", + # Leave time for the full server wait plus network/response overhead. + timeout=aiohttp.ClientTimeout(total=max(self._timeout.total or 0, wait_ms / 1000 + 10)), + query={ + "afterEventId": after_event_id, + "types": ",".join(types) if types else None, + "waitMs": wait_ms, + }, + ) + return payload.get("events", []) diff --git a/requirements.in b/requirements.in index 315007a..fb0000e 100644 --- a/requirements.in +++ b/requirements.in @@ -1,19 +1,9 @@ # Direct dependencies for xRC Ranked Bot. -# Regenerate requirements.txt with: -# python3.10 -m piptools compile --resolver=backtracking requirements.in -aiohttp==3.10.11 +# Regenerate with Python 3.10: make lock +# Local process management and legacy spreadsheet/plotting dependencies were +# removed with the orchestrator migration. +aiohttp==3.14.4 autopep8==1.6.0 discord.py==2.2.2 -google-auth==2.9.1 -google-auth-oauthlib==0.5.2 -gspread==5.4.0 -gspread-dataframe==3.3.0 -matplotlib==3.5.2 -numpy==1.23.1 -oauth2client==4.1.3 -pandas==1.4.3 -Pillow==10.3.0 -python-dotenv==0.20.0 -requests==2.32.4 -schedule==1.1.0 -psutil==7.2.2 +python-dotenv==1.2.2 +requests==2.33.0 diff --git a/requirements.txt b/requirements.txt index 597029b..4b99027 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,9 +4,9 @@ # # pip-compile --output-file=requirements.txt requirements.in # -aiohappyeyeballs==2.6.1 +aiohappyeyeballs==2.7.1 # via aiohttp -aiohttp==3.10.11 +aiohttp==3.14.4 # via # -r requirements.in # discord-py @@ -18,122 +18,42 @@ attrs==26.1.0 # via aiohttp autopep8==1.6.0 # via -r requirements.in -cachetools==5.5.2 - # via google-auth -certifi==2026.2.25 +certifi==2026.10.23 # via requests -charset-normalizer==3.4.7 +charset-normalizer==3.5.2 # via requests -cycler==0.12.1 - # via matplotlib discord-py==2.2.2 # via -r requirements.in -fonttools==4.62.1 - # via matplotlib frozenlist==1.8.0 # via # aiohttp # aiosignal -google-auth==2.9.1 - # via - # -r requirements.in - # google-auth-oauthlib - # gspread -google-auth-oauthlib==0.5.2 - # via - # -r requirements.in - # gspread -gspread==5.4.0 - # via - # -r requirements.in - # gspread-dataframe -gspread-dataframe==3.3.0 - # via -r requirements.in -httplib2==0.31.2 - # via oauth2client -idna==3.11 +idna==3.20 # via # requests # yarl -kiwisolver==1.5.0 - # via matplotlib -matplotlib==3.5.2 - # via -r requirements.in -multidict==6.7.1 +multidict==6.9.1 # via # aiohttp # yarl -numpy==1.23.1 - # via - # -r requirements.in - # matplotlib - # pandas -oauth2client==4.1.3 - # via -r requirements.in -oauthlib==3.3.1 - # via requests-oauthlib -packaging==26.1 - # via matplotlib -pandas==1.4.3 - # via - # -r requirements.in - # gspread-dataframe -pillow==10.3.0 +propcache==0.5.4 # via - # -r requirements.in - # matplotlib -propcache==0.4.1 - # via yarl -psutil==7.2.2 - # via -r requirements.in -pyasn1==0.6.3 - # via - # oauth2client - # pyasn1-modules - # rsa -pyasn1-modules==0.4.2 - # via - # google-auth - # oauth2client -pycodestyle==2.14.0 + # aiohttp + # yarl +pycodestyle==2.15.0 # via autopep8 -pyparsing==3.3.2 - # via - # httplib2 - # matplotlib -python-dateutil==2.9.0.post0 - # via - # matplotlib - # pandas -python-dotenv==0.20.0 +python-dotenv==1.2.2 # via -r requirements.in -pytz==2026.1.post1 - # via pandas -requests==2.32.4 - # via - # -r requirements.in - # requests-oauthlib -requests-oauthlib==2.0.0 - # via google-auth-oauthlib -rsa==4.9.1 - # via - # google-auth - # oauth2client -schedule==1.1.0 +requests==2.33.0 # via -r requirements.in -six==1.17.0 - # via - # google-auth - # gspread-dataframe - # oauth2client - # python-dateutil toml==0.10.2 # via autopep8 -typing-extensions==4.15.0 +typing-extensions==4.16.0 # via + # aiohttp # aiosignal # multidict urllib3==2.8.0 # via requests -yarl==1.23.0 +yarl==1.25.1 # via aiohttp diff --git a/server_utils.py b/server_utils.py index 8dc820e..7e3b5c9 100644 --- a/server_utils.py +++ b/server_utils.py @@ -1,89 +1,13 @@ -# server_utils.py +"""Compatibility wrappers for the orchestrator migration. -import os -import subprocess -from datetime import datetime -from io import TextIOWrapper -from typing import Dict +Server process lifecycle is owned by the xRC Server Orchestrator. New bot code +should use ``OrchestratorClient`` or the ``ServerActions`` cog directly. +""" -# Constants -SERVER_PATH = "./server/xRC Simulator.x86_64" -SERVER_LOGS_DIR = "./server_logs/" -PORTS = [11115, 11116, 11117, 11118, 11119, 11120] -servers_active: Dict[int, subprocess.Popen] = {} -log_files: Dict[int, TextIOWrapper] = {} -last_active: Dict[int, datetime] = {} +def start_server_process(*args, **kwargs): + raise RuntimeError("Local xRC process launch has been removed. Use the orchestrator API.") -# Function to start a server process -def start_server_process(game: str, comment: str, password: str = "", admin: str = "Admin", - restart_mode: int = -1, frame_rate: int = 60, update_time: int = 10, - tournament_mode: bool = True, start_when_ready: bool = True, - register: bool = True, spectators: int = 4, min_players: int = -1, - restart_all: bool = True): - if not os.path.exists(SERVER_PATH): - return "⚠ xRC Sim server not found, use `/update` to update", -1 - if len(servers_active) >= len(PORTS): - return "⚠ The maximum number of servers are already running", -1 - - port = -1 - for p in PORTS: - if p not in servers_active: - port = p - break - - if port == -1: - return "⚠ Could not find a port to run the server on", -1 - - # Game settings and default values would be fetched or set here - game_settings = "" - if restart_mode == -1: - restart_mode = 1 - if min_players == -1: - min_players = 4 - - # Open log file in append mode - f = open(f"{SERVER_LOGS_DIR}{port}.log", "a") - log_files[port] = f - f.write(f"Server started at {datetime.now()}") - - command = [ - SERVER_PATH, "-batchmode", "-nographics", - f"RouterPort={port}", f"Port={port}", f"Game={game}", - f"GameOption={restart_mode}", f"FrameRate={frame_rate}", - f"Tmode={'On' if tournament_mode else 'Off'}", - f"Register={'On' if register else 'Off'}", - f"Spectators={spectators}", f"UpdateTime={update_time}", - "MaxData=1000000", - f"StartWhenReady={'On' if start_when_ready else 'Off'}", - f"Comment={comment}", f"Password={password}", - f"Admin={admin}", f"GameSettings={game_settings}", - f"MinPlayers={min_players}", - f"RestartAll={'On' if restart_all else 'Off'}", - "NetStats=On", "Profiling=On" - ] - - servers_active[port] = subprocess.Popen( - command, - stdout=f, stderr=f, shell=False - ) - - last_active[port] = datetime.now() - - return f"✅ Launched server '{comment}' on port {port}", port - -# Function to stop a server process -def stop_server_process(port: int): - if port not in servers_active: - return f"⚠ Server on port {port} not found" - - log_files[port].write(f"Server shut down at {datetime.now()}") - - servers_active[port].terminate() - log_files[port].close() - del servers_active[port] - del last_active[port] - del log_files[port] - - return f"✅ Server on port {port} shut down" +def stop_server_process(*args, **kwargs): + raise RuntimeError("Local xRC process stop has been removed. Use the orchestrator API.") diff --git a/test_regex_log.py b/test_regex_log.py index 633a593..06f9690 100644 --- a/test_regex_log.py +++ b/test_regex_log.py @@ -1,13 +1,23 @@ import re +import unittest -# Define the regex pattern for lines like '6/3/2025 2:06:07 AM: whatdidido: gg.' -pattern = re.compile(r'^\d{1,2}/\d{1,2}/\d{4} \d{1,2}:\d{2}:\d{2} [AP]M: (\w+): (.+)\.$') -input_file = '11115.log' -output_file = 'chat_messages.log' +CHAT_LINE_RE = re.compile( + r"^\d{1,2}/\d{1,2}/\d{4} \d{1,2}:\d{2}:\d{2} [AP]M: (\w+): (.+)\.$" +) -with open(input_file, 'r', encoding='utf-8') as infile, open(output_file, 'w', encoding='utf-8') as outfile: - for line in infile: - if pattern.match(line) and 'KeyNotFoundException' not in line: - print(line.strip()) - outfile.write(line) \ No newline at end of file + +class ChatLogRegexTests(unittest.TestCase): + def test_matches_xrc_chat_line(self): + match = CHAT_LINE_RE.match("6/3/2025 2:06:07 AM: whatdidido: gg.") + + self.assertIsNotNone(match) + self.assertEqual(match.group(1), "whatdidido") + self.assertEqual(match.group(2), "gg") + + def test_rejects_non_chat_log_line(self): + self.assertIsNone(CHAT_LINE_RE.match("Player Nick joined on position Red 1 from IP=127.0.0.1.")) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/support.py b/tests/support.py index c96e9ed..21b4b95 100644 --- a/tests/support.py +++ b/tests/support.py @@ -8,6 +8,8 @@ "DISCORD_BOT_TOKEN": "test-token", "DISCORD_APPLICATION_ID": "1", "SRC_API_TOKEN": "test-token", + "API_KEY": "test-key", + "ORCHESTRATOR_TOKEN": "test-orchestrator", "GUILD_ID": "1", "QUEUE_STATUS_CHANNEL_ID": "2", "QUEUE_CHANNEL_ID": "3", diff --git a/tests/test_event_polling.py b/tests/test_event_polling.py new file mode 100644 index 0000000..ce32c6b --- /dev/null +++ b/tests/test_event_polling.py @@ -0,0 +1,39 @@ +import asyncio +import unittest + +import aiohttp +from aiohttp import web + +from orchestrator_client import OrchestratorClient, OrchestratorTokens, OrchestratorAPIError + + +class EventPollingTests(unittest.IsolatedAsyncioTestCase): + async def test_idle_poll_outlives_normal_request_timeout(self): + async def events(request): + await asyncio.sleep(0.08) + return web.json_response({"events": []}) + + app = web.Application() + app.router.add_get("/v1/events", events) + runner = web.AppRunner(app) + await runner.setup() + site = web.TCPSite(runner, "127.0.0.1", 0) + await site.start() + port = runner.addresses[0][1] + client = OrchestratorClient(f"http://127.0.0.1:{port}", OrchestratorTokens("test"), timeout_seconds=0.02) + try: + self.assertEqual(await client.get_events(wait_ms=80), []) + finally: + await client.close() + await runner.cleanup() + + async def test_python310_timeout_is_reported_as_service_unavailable(self): + class TimedOutSession: + closed = False + def request(self, *args, **kwargs): + raise asyncio.TimeoutError() + + client = OrchestratorClient("http://unused", OrchestratorTokens("test"), session=TimedOutSession()) + with self.assertRaises(OrchestratorAPIError) as error: + await client.list_servers() + self.assertEqual(error.exception.code, "SERVICE_UNAVAILABLE") diff --git a/tests/test_game_selection.py b/tests/test_game_selection.py index 994271d..9717491 100644 --- a/tests/test_game_selection.py +++ b/tests/test_game_selection.py @@ -13,7 +13,7 @@ from config import EVENT_STAFF_ID, server_games from game_selection import game_autocomplete, resolve_game_id from cogs.server import ServerActions - from cogs.gamehangout import GameHangout + from cogs.casual import CasualServers def make_interaction(): @@ -86,40 +86,20 @@ async def test_launch_normalizes_full_name_and_selected_id(self): for value in (" bIoBuZz ", "24"): with self.subTest(value=value): cog = ServerActions.__new__(ServerActions) - cog.start_server_process = Mock(return_value=("test result", -1)) + cog.start_server_process = AsyncMock(return_value=("test result", -1, None, None)) interaction = make_interaction() await ServerActions.launch_server.callback(cog, interaction, value, "test") self.assertEqual(cog.start_server_process.call_args.args[0], "24") - async def test_hangout_rejects_unknown_game_before_creating_resources(self): - cog = GameHangout(Mock()) - interaction = make_interaction() - with patch("cogs.gamehangout.HangoutSession") as session_class: - await GameHangout.hangout_create.callback(cog, interaction, "bad game") - session_class.assert_not_called() - interaction.response.defer.assert_not_awaited() - interaction.response.send_message.assert_awaited_once() - self.assertTrue(interaction.response.send_message.call_args.kwargs["ephemeral"]) - async def test_launched_server_watch_uses_selected_game_name(self): cog = ServerActions.__new__(ServerActions) - cog.start_server_process = Mock(return_value=("server started", 11115)) + cog.start_server_process = AsyncMock(return_value=("server started", 11115, "session", {})) cog._create_watch_message = AsyncMock() interaction = make_interaction() await ServerActions.launch_server.callback(cog, interaction, "24", "test") await asyncio.sleep(0) cog._create_watch_message.assert_awaited_once_with(11115, "BioBuzz") - async def test_hangout_normalizes_full_name_and_selected_id(self): - for value in (" bIoBuZz ", "24"): - with self.subTest(value=value): - cog = GameHangout(Mock()) - interaction = make_interaction() - with patch("cogs.gamehangout.HangoutSession") as session_class: - session_class.return_value.create_hangout_resources = AsyncMock(return_value=True) - await GameHangout.hangout_create.callback(cog, interaction, value) - self.assertEqual(session_class.call_args.args[1], "BioBuzz") - self.assertIn(interaction.user.id, cog.active_hangouts) if __name__ == "__main__": diff --git a/tests/test_gateway_intents.py b/tests/test_gateway_intents.py new file mode 100644 index 0000000..84fb3d0 --- /dev/null +++ b/tests/test_gateway_intents.py @@ -0,0 +1,13 @@ +import unittest +from gateway_intents import build_intents + + +class GatewayIntentTests(unittest.TestCase): + def test_ranked_bot_requests_only_necessary_gateway_events(self): + intents = build_intents() + self.assertTrue(intents.guilds) + self.assertTrue(intents.members) + self.assertTrue(intents.voice_states) + self.assertFalse(intents.presences) + self.assertFalse(intents.message_content) + self.assertFalse(intents.messages) diff --git a/tests/test_server_orchestration.py b/tests/test_server_orchestration.py new file mode 100644 index 0000000..8343189 --- /dev/null +++ b/tests/test_server_orchestration.py @@ -0,0 +1,431 @@ +import os +import unittest +from types import SimpleNamespace +from unittest.mock import AsyncMock, Mock + +os.environ.setdefault("DISCORD_BOT_TOKEN", "test") +os.environ.setdefault("DISCORD_APPLICATION_ID", "1") +os.environ.setdefault("API_KEY", "shared-api-key") +os.environ.setdefault("GUILD_ID", "1") +os.environ.setdefault("QUEUE_STATUS_CHANNEL_ID", "1") +os.environ.setdefault("QUEUE_CHANNEL_ID", "1") +os.environ.setdefault("RULES_CHANNEL_ID", "1") +os.environ.setdefault("CATEGORY_ID", "1") +os.environ.setdefault("EVENT_STAFF_ID", "1") +os.environ.setdefault("TRIAL_STAFF_ID", "1") +os.environ.setdefault("LOBBY_VC_ID", "1") +os.environ.setdefault("BOTS_ROLE_ID", "1") +os.environ.setdefault("RANKED_ADMIN_USERNAME", "RankedAdmin") +os.environ.setdefault("ORCHESTRATOR_TOKEN", "orch-token") + +from orchestrator_client import OrchestratorAPIError, OrchestratorClient, OrchestratorTokens +from website_client import WebsiteClient +from cogs.server import ServerActions, build_status_embed, _opr_rows +from cogs.casual import CasualServers + + +class FakeResponse: + def __init__(self, status=200, payload=None): + self.status = status + self.payload = payload or {} + self.headers = {"Content-Type": "application/json"} + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc, tb): + return False + + async def json(self, content_type=None): + return self.payload + + async def text(self): + return str(self.payload) + + +class FakeSession: + def __init__(self, response): + self.responses = list(response) if isinstance(response, list) else [response] + self.requests = [] + self.closed = False + + def _next_response(self): + if len(self.responses) > 1: + return self.responses.pop(0) + return self.responses[0] + + def request(self, method, url, **kwargs): + self.requests.append((method, url, kwargs)) + return self._next_response() + + def post(self, url, **kwargs): + self.requests.append(("POST", url, kwargs)) + return self._next_response() + + +class FakeOrchestrator: + def __init__(self): + self.launch_payloads = [] + self.stop_calls = [] + self.sessions = [ + {"id": "sess-1", "port": 11115, "state": "running", "kind": "casual", "ownerDiscordUserId": "42"} + ] + + async def launch_server(self, payload): + self.launch_payloads.append(payload) + return {"id": "sess-1", "port": 11115, "state": "running", "gameCode": payload["gameCode"]} + + async def stop_session(self, session_id, *, reason, actor=None): + self.stop_calls.append((session_id, reason, actor)) + return {"id": session_id, "port": 11115} + + async def stop_session_by_port(self, port, *, reason, actor=None): + self.stop_calls.append((port, reason, actor)) + return {"id": "sess-1", "port": port} + + async def list_servers(self, **filters): + sessions = self.sessions + if filters.get("ownerDiscordUserId"): + sessions = [s for s in sessions if s.get("ownerDiscordUserId") == filters["ownerDiscordUserId"]] + if filters.get("kind"): + sessions = [s for s in sessions if s.get("kind") == filters["kind"]] + return sessions + + async def get_session(self, session_id): + return { + "id": session_id, + "port": 11115, + "state": "running", + "kind": "casual", + "gameCode": "20", + "players": [], + "score": {"timer": "1:23", "redScore": 10, "blueScore": 8}, + } + + +class FakeWebsite: + def __init__(self, active=True, active_session=None, games=None): + self.active = active + self.active_session = active_session + self.games = games or [{"gameCode": "20", "name": "Push Back", "shortCode": "PB", "casualEnabled": True}] + self.started = [] + self.stopped = [] + + async def close(self): + pass + + async def get_entitlement(self, discord_user_id): + self.entitlement_user_id = discord_user_id + return {"active": self.active, "active_session": self.active_session} + + async def get_casual_games(self): + return self.games + + async def start_casual_server(self, **kwargs): + self.started.append(kwargs) + return { + "id": "web-1", + "status": "launching", + "game": kwargs["game"], + "game_code": kwargs["game_code"], + "comment": kwargs["comment"], + "host": "play.secondrobotics.org", + "port": 11115, + "password": kwargs["password"] or "generated", + "allocated_minutes": kwargs["requested_minutes"], + } + + async def stop_casual_server(self, website_session_id, *, reason): + self.stopped.append((website_session_id, reason)) + return {"id": website_session_id, "status": "stopping", "stop_reason": reason} + + +class FakeResponseProxy: + def __init__(self): + self.deferred = False + self.messages = [] + + async def defer(self, **kwargs): + self.deferred = True + + async def send_message(self, *args, **kwargs): + self.messages.append((args, kwargs)) + + +class FakeFollowup: + def __init__(self): + self.messages = [] + + async def send(self, *args, **kwargs): + self.messages.append((args, kwargs)) + + +class FakeUser: + id = 42 + name = "Subscriber" + display_name = "Subscriber" + + +class FakeInteraction: + def __init__(self): + self.id = 300 + self.user = FakeUser() + self.guild_id = 100 + self.channel_id = 200 + self.response = FakeResponseProxy() + self.followup = FakeFollowup() + + +class FakeBot: + def __init__(self, server_actions=None): + self.server_actions = server_actions + + def get_cog(self, name): + if name == "ServerActions": + return self.server_actions + return None + + +class OrchestratorClientTests(unittest.IsolatedAsyncioTestCase): + async def test_launch_server_uses_bearer_token_and_payload(self): + session = FakeSession(FakeResponse(201, {"id": "session-1", "port": 11115})) + client = OrchestratorClient("http://orchestrator", OrchestratorTokens("token-a"), session=session) + + result = await client.launch_server({"kind": "ranked", "gameCode": "20"}) + + self.assertEqual(result["id"], "session-1") + method, url, kwargs = session.requests[0] + self.assertEqual(method, "POST") + self.assertEqual(url, "http://orchestrator/v1/servers") + self.assertEqual(kwargs["headers"]["Authorization"], "Bearer token-a") + self.assertEqual(kwargs["json"]["kind"], "ranked") + + async def test_moderation_reads_use_moderation_token(self): + session = FakeSession(FakeResponse(200, {"players": []})) + client = OrchestratorClient( + "http://orchestrator", + OrchestratorTokens(default="default-token", moderation="mod-token"), + session=session, + ) + + await client.get_players("session-1", moderation=True) + + _, _, kwargs = session.requests[0] + self.assertEqual(kwargs["headers"]["Authorization"], "Bearer mod-token") + + async def test_admin_write_uses_admin_token(self): + session = FakeSession(FakeResponse(200, {"id": "session-1", "port": 11115})) + client = OrchestratorClient( + "http://orchestrator", + OrchestratorTokens(default="default-token", admin="admin-token"), + session=session, + ) + + await client.kill_session("session-1", reason="hung") + + method, url, kwargs = session.requests[0] + self.assertEqual(method, "POST") + self.assertEqual(url, "http://orchestrator/v1/servers/session-1/kill") + self.assertEqual(kwargs["headers"]["Authorization"], "Bearer admin-token") + + async def test_http_error_raises_orchestrator_error_with_code(self): + response = FakeResponse(409, {"error": {"code": "MATCH_ALREADY_RUNNING", "message": "Match exists."}}) + session = FakeSession(response) + client = OrchestratorClient("http://orchestrator", OrchestratorTokens("token-a"), session=session) + + with self.assertRaises(OrchestratorAPIError) as cm: + await client.launch_server({"kind": "ranked", "gameCode": "20"}) + + self.assertEqual(cm.exception.status, 409) + self.assertEqual(cm.exception.code, "MATCH_ALREADY_RUNNING") + + +class WebsiteClientTests(unittest.IsolatedAsyncioTestCase): + async def test_start_casual_server_posts_to_secondwebsite_proxy(self): + session = FakeSession(FakeResponse(200, {"success": True, "session": {"id": "web-1", "port": 11115}})) + client = WebsiteClient("https://example.test", "site-token", session=session) + + result = await client.start_casual_server( + owner_discord_id=42, + game_code="20", + game="Push Back", + requested_minutes=30, + comment="CasualPB", + password="", + guild_id=100, + channel_id=200, + interaction_id=300, + ) + + self.assertEqual(result["id"], "web-1") + method, url, kwargs = session.requests[0] + self.assertEqual(method, "POST") + self.assertEqual(url, "https://example.test/api/subscriptions/server-sessions/start/") + self.assertEqual(kwargs["headers"]["X-API-KEY"], "site-token") + self.assertEqual(kwargs["json"]["owner_discord_id"], "42") + self.assertEqual(kwargs["json"]["launch_source"], "discord_bot") + self.assertEqual(kwargs["json"]["launch_context"]["discord_interaction_id"], "300") + + async def test_entitlement_failure_raises_website_error(self): + session = FakeSession(FakeResponse(200, {"success": False, "message": "User is not linked."})) + client = WebsiteClient("https://example.test", "site-token", session=session) + + with self.assertRaises(Exception) as cm: + await client.get_entitlement(42) + + self.assertIn("User is not linked.", str(cm.exception)) + + async def test_stop_casual_server_posts_to_secondwebsite_proxy(self): + session = FakeSession(FakeResponse(200, {"success": True, "session": {"id": "web-1", "status": "stopping"}})) + client = WebsiteClient("https://example.test", "site-token", session=session) + + result = await client.stop_casual_server("web-1") + + self.assertEqual(result["status"], "stopping") + method, url, kwargs = session.requests[0] + self.assertEqual(method, "POST") + self.assertEqual(url, "https://example.test/api/subscriptions/server-sessions/web-1/stop/") + self.assertEqual(kwargs["headers"]["X-API-KEY"], "site-token") + + +class ServerCommandPathTests(unittest.IsolatedAsyncioTestCase): + async def test_ranked_launch_payload_is_orchestrator_ranked_session(self): + fake_orchestrator = FakeOrchestrator() + actions = ServerActions(FakeBot(), orchestrator=fake_orchestrator) + + _, port, session_id, _ = await actions.start_server_process( + "20", + "RankedPB", + "123", + admin="RankedAdmin", + kind="ranked", + match_id="match-1", + ranked_game_mode="Push Back 2v2", + expected_discord_user_ids=["1", "2", "3", "4"], + ) + + self.assertEqual(port, 11115) + self.assertEqual(session_id, "sess-1") + payload = fake_orchestrator.launch_payloads[0] + self.assertEqual(payload["kind"], "ranked") + self.assertEqual(payload["matchId"], "match-1") + self.assertEqual(payload["launchOptions"]["tournamentMode"], True) + self.assertEqual(payload["launchOptions"]["minPlayers"], 4) + + async def test_admin_stop_uses_session_when_available(self): + fake_orchestrator = FakeOrchestrator() + actions = ServerActions(FakeBot(), orchestrator=fake_orchestrator) + + result = await actions.stop_server_process(11115, session_id="sess-1", reason="done") + + self.assertIn("shut down", result) + self.assertEqual(fake_orchestrator.stop_calls[0][0], "sess-1") + self.assertEqual(fake_orchestrator.stop_calls[0][1], "done") + + def test_status_embed_uses_orchestrator_score_and_players(self): + embed = build_status_embed({ + "port": 11115, + "gameCode": "20", + "gameName": "Push Back", + "players": [ + {"playerName": "RedOne", "position": "Red 1", "ipAddress": "10.0.0.1"}, + {"playerName": "BlueOne", "position": "Blue 1", "ipAddress": "10.0.0.2"}, + ], + "score": {"timer": "0:42", "redScore": 15, "blueScore": 12}, + }) + + self.assertEqual(embed.title, "Server Status for Port 11115") + values = [field.value for field in embed.fields] + self.assertIn("0:42", values) + self.assertIn("RedOne - Red 1", values) + self.assertIn("BlueOne - Blue 1", values) + + def test_orchestrator_split_opr_score_shape_is_supported(self): + rows = _opr_rows({ + "redOpr": [{"playerName": "RedOne", "value": 42}], + "blueOpr": [{"playerName": "BlueOne", "value": 37}], + }) + + self.assertEqual(rows, [("RedOne", 42), ("BlueOne", 37)]) + + async def test_casual_start_uses_secondwebsite_proxy_not_orchestrator(self): + fake_orchestrator = FakeOrchestrator() + actions = ServerActions(FakeBot(), orchestrator=fake_orchestrator) + bot = FakeBot(server_actions=actions) + website = FakeWebsite() + cog = CasualServers(bot, website=website) + interaction = FakeInteraction() + + await CasualServers.casual_start.callback(cog, interaction, "20", 30, "", "") + + self.assertTrue(interaction.response.deferred) + self.assertEqual(fake_orchestrator.launch_payloads, []) + self.assertEqual(len(website.started), 1) + payload = website.started[0] + self.assertEqual(payload["owner_discord_id"], 42) + self.assertEqual(payload["game_code"], "20") + self.assertEqual(payload["requested_minutes"], 30) + self.assertTrue(interaction.followup.messages) + + async def test_casual_start_does_not_launch_when_secondwebsite_denies_entitlement(self): + fake_orchestrator = FakeOrchestrator() + actions = ServerActions(FakeBot(), orchestrator=fake_orchestrator) + bot = FakeBot(server_actions=actions) + website = FakeWebsite(active=False) + cog = CasualServers(bot, website=website) + interaction = FakeInteraction() + + await CasualServers.casual_start.callback(cog, interaction, "20", 30, "", "") + + self.assertEqual(fake_orchestrator.launch_payloads, []) + self.assertEqual(website.started, []) + self.assertIn("does not see an active", interaction.followup.messages[0][0][0]) + + async def test_casual_stop_uses_secondwebsite_proxy_not_orchestrator(self): + fake_orchestrator = FakeOrchestrator() + actions = ServerActions(FakeBot(), orchestrator=fake_orchestrator) + bot = FakeBot(server_actions=actions) + website = FakeWebsite(active_session={"id": "web-1", "status": "running", "comment": "CasualPB"}) + cog = CasualServers(bot, website=website) + interaction = FakeInteraction() + + await CasualServers.casual_stop.callback(cog, interaction) + + self.assertTrue(interaction.response.deferred) + self.assertEqual(fake_orchestrator.stop_calls, []) + self.assertEqual(website.stopped[0], ("web-1", "discord_bot_stop")) + embed = interaction.followup.messages[0][1]["embed"] + self.assertEqual(embed.title, "Casual Server Stopping") + + +if __name__ == "__main__": + unittest.main() + + +class RecoveryTests(unittest.IsolatedAsyncioTestCase): + async def test_casual_status_refreshes_stale_cached_session(self): + website = SimpleNamespace(get_entitlement=AsyncMock(return_value={"active_session": None})) + cog = CasualServers(Mock(), website=website) + cog.sessions_by_owner[42] = {"id": "old", "status": "running"} + self.assertIsNone(await cog._get_active_website_session(42)) + website.get_entitlement.assert_awaited_once_with(42) + + async def test_reachable_orchestrator_without_old_ranked_session_cleans_discord(self): + ranked = SimpleNamespace(find_match_by_session_id=Mock(return_value=object()), + handle_orchestrator_inactivity_expired=AsyncMock()) + cog = ServerActions.__new__(ServerActions) + cog.bot = SimpleNamespace(get_cog=lambda name: ranked) + cog.orchestrator = SimpleNamespace(list_servers=AsyncMock(return_value=[])) + cog.server_sessions_by_port = {11115: "old-ranked"} + await cog._reconcile_ranked_sessions() + ranked.handle_orchestrator_inactivity_expired.assert_awaited_once_with({"sessionId": "old-ranked"}) + + async def test_orchestrator_outage_does_not_clear_ranked_match(self): + ranked = SimpleNamespace(handle_orchestrator_inactivity_expired=AsyncMock()) + cog = ServerActions.__new__(ServerActions) + cog.bot = SimpleNamespace(get_cog=lambda name: ranked) + cog.orchestrator = SimpleNamespace(list_servers=AsyncMock(side_effect=OrchestratorAPIError(0, "offline", "offline"))) + cog.server_sessions_by_port = {11115: "old-ranked"} + with self.assertRaises(OrchestratorAPIError): + await cog._reconcile_ranked_sessions() + ranked.handle_orchestrator_inactivity_expired.assert_not_awaited() diff --git a/tests/test_staging_urls.py b/tests/test_staging_urls.py new file mode 100644 index 0000000..6eb45aa --- /dev/null +++ b/tests/test_staging_urls.py @@ -0,0 +1,14 @@ +import ast +from pathlib import Path +import unittest + + +class StagingIsolationTests(unittest.TestCase): + def test_ranked_api_calls_do_not_hardcode_the_production_website(self): + root = Path(__file__).resolve().parents[1] + for relative in ['cogs/ranked.py', 'cogs/general.py', 'cogs/userManagement.py']: + tree = ast.parse((root / relative).read_text()) + for node in ast.walk(tree): + if isinstance(node, ast.Constant) and isinstance(node.value, str): + for origin in ['https://secondrobotics.org/api/', 'https://www.secondrobotics.org/api/']: + self.assertNotIn(origin, node.value, relative) diff --git a/website_client.py b/website_client.py new file mode 100644 index 0000000..ea5663b --- /dev/null +++ b/website_client.py @@ -0,0 +1,111 @@ +import aiohttp +from typing import Any, Optional, Union + + +class WebsiteAPIError(RuntimeError): + def __init__(self, status: int, code: str, message: str): + super().__init__(message) + self.status = status + self.code = code + + +class WebsiteClient: + def __init__( + self, + base_url: str, + api_key: str, + session: Optional[aiohttp.ClientSession] = None, + timeout_seconds: int = 15, + ): + self.base_url = base_url.rstrip("/") + self.api_key = api_key + self._session = session + self._owns_session = session is None + self._timeout = aiohttp.ClientTimeout(total=timeout_seconds) + + async def close(self): + if self._owns_session and self._session and not self._session.closed: + await self._session.close() + + def _get_session(self) -> aiohttp.ClientSession: + if self._session is None or self._session.closed: + self._session = aiohttp.ClientSession(timeout=self._timeout) + self._owns_session = True + return self._session + + async def _request(self, *args, **kwargs): + try: + return await self._request_unchecked(*args, **kwargs) + except (aiohttp.ClientError, TimeoutError, ValueError) as exc: + raise WebsiteAPIError(0, 'SERVICE_UNAVAILABLE', 'The service could not be reached or returned an invalid response.') from exc + + async def _request_unchecked(self, method: str, path: str, *, json: Optional[dict] = None) -> dict[str, Any]: + if not self.api_key: + raise WebsiteAPIError(0, "MISSING_TOKEN", "API_KEY is not configured.") + + headers = {"X-API-KEY": self.api_key} + url = f"{self.base_url}/{path.strip('/')}/" + async with self._get_session().request(method, url, json=json, headers=headers) as response: + data = await response.json(content_type=None) + if response.status >= 400: + raise WebsiteAPIError( + response.status, + data.get("code") or data.get("error", "HTTP_ERROR"), + data.get("message") or data.get("detail", "SecondWebsite request failed."), + ) + if data.get("success") is False: + raise WebsiteAPIError( + response.status, + data.get("code") or "WEBSITE_REJECTED", + data.get("message") or "SecondWebsite rejected the request.", + ) + return data + + async def get_casual_games(self) -> list[dict]: + data = await self._request("GET", "/api/subscriptions/casual-games/") + return data.get("games", []) + + async def get_entitlement(self, discord_user_id: Union[int, str]) -> dict: + data = await self._request("GET", f"/api/subscriptions/users/{discord_user_id}/entitlement/") + return data.get("entitlement", {}) + + async def start_casual_server( + self, + *, + owner_discord_id: Union[int, str], + game_code: str, + game: Optional[str], + requested_minutes: int, + comment: str, + password: str, + guild_id: Optional[int], + channel_id: Optional[int], + interaction_id: Optional[int], + ) -> dict: + data = await self._request( + "POST", + "/api/subscriptions/server-sessions/start/", + json={ + "owner_discord_id": str(owner_discord_id), + "game_code": str(game_code), + "game": game, + "requested_minutes": requested_minutes, + "comment": comment[:120], + "password": password, + "launch_source": "discord_bot", + "launch_context": { + "discord_guild_id": str(guild_id) if guild_id else None, + "discord_channel_id": str(channel_id) if channel_id else None, + "discord_interaction_id": str(interaction_id) if interaction_id else None, + }, + }, + ) + return data.get("session", {}) + + async def stop_casual_server(self, website_session_id: str, *, reason: str = "discord_bot_stop") -> dict: + data = await self._request( + "POST", + f"/api/subscriptions/server-sessions/{website_session_id}/stop/", + json={"reason": reason}, + ) + return data.get("session", {})