Feat: Mountain Madness 2026 Good/Evil counters (#133)

Author: jbriones1

src/constants.py

@@ -1,10 +1,12 @@
 import os
+from zoneinfo import ZoneInfo
 
 # TODO(future): replace new.sfucsss.org with sfucsss.org during migration
 # TODO(far-future): branch-specific root IP addresses (e.g., devbranch.sfucsss.org)
 ENV_LOCAL = os.environ.get("LOCAL")
 IS_PROD = True if not ENV_LOCAL or ENV_LOCAL.lower() != "true" else False
 GITHUB_ORG_NAME = "CSSS-Test-Organization" if not IS_PROD else "CSSS"
+TZ_INFO = ZoneInfo("America/Vancouver")
 
 W3_GUILD_ID = "1260652618875797504"
 CSSS_GUILD_ID = "228761314644852736"

src/main.py

@@ -10,6 +10,7 @@
 import candidates.urls
 import database
 import elections.urls
+import mountain_madness._2026.urls
 import nominees.urls
 import officers.urls
 import permission.urls
@@ -33,7 +34,12 @@
 # if on production, disable viewing the docs
 else:
     print("Running production environment")
-    origins = ["https://sfucsss.org", "https://test.sfucsss.org", "https://admin.sfucsss.org"]
+    origins = [
+        "https://sfucsss.org",
+        "https://test.sfucsss.org",
+        "https://admin.sfucsss.org",
+        "https://madness.sfucsss.org",
+    ]
     app = FastAPI(
         lifespan=database.lifespan,
         title="CSSS Site Backend",
@@ -53,6 +59,7 @@
 app.include_router(nominees.urls.router)
 app.include_router(officers.urls.router)
 app.include_router(permission.urls.router)
+app.include_router(mountain_madness._2026.urls.router)
 
 
 @app.get("/")

src/mountain_madness/_2026/README.md

@@ -0,0 +1,7 @@
+# A counter created for Mountain Madness 2026
+
+* The file it writes to is `/var/www/mountain_madness/2026/counter.json`
+* It contains the four following endpoints (root is `/api/mm2026`)
+    * GET `/counters`: Returns the counter values
+    * POST `/good`: Increments the Good counter
+    * POST `/evil`: Increments the Evil counter

src/mountain_madness/_2026/__init__.py

@@ -0,0 +1,6 @@
+from .counter import CounterFile
+from .models import CounterResponse
+
+mm_counter = CounterFile("/var/www/mountain_madness/2026/counter.json", save_interval=300, save_threshold=10)
+mm_counter.increment("good", 0)  # initialize the counter with default values if it doesn't exist
+mm_counter.increment("evil", 0)  # initialize the counter with default values if it doesn't exist

src/mountain_madness/_2026/counter.py

@@ -0,0 +1,114 @@
+import atexit
+import datetime
+import fcntl
+import json
+import threading
+import time
+from pathlib import Path
+
+from constants import TZ_INFO
+
+
+class CounterFile:
+    def __init__(self, filepath: str, save_interval: int, save_threshold: int):
+        """
+        Counter that saves to a file.
+
+        Args:
+            filepath: The absolute file path to save the counter to.
+            save_interval: How often to save to the file, in seconds
+            save_threshold: How often to save to the file, in number of changes
+        """
+        self.__counters: dict[str, int] = {}
+
+        self.filepath = Path(filepath)
+        self.save_interval = save_interval
+        self.save_threshold = save_threshold
+        self.lock = threading.Lock()
+        self.create_time = datetime.datetime.now(TZ_INFO)
+        self.last_save_time = self.create_time
+        self.changes_since_last_save = 0
+
+        self._is_auto_save_enabled = save_interval > 0
+
+        # If the program shuts down, turn save one last time
+        atexit.register(self.__save_to_file)
+
+        self.start()
+
+    def start(self):
+        self.filepath.parent.mkdir(parents=True, exist_ok=True)
+        save_data = {
+            "counters": self.__counters,
+            "last_save_time": self.last_save_time.isoformat(),
+        }
+        # Create file if it doesn't exist
+        if not self.filepath.exists():
+            self.filepath.write_text(json.dumps(save_data, indent=2))
+            self.__save_to_file()
+        else:
+            # Otherwise check the file and load from it
+            try:
+                with Path.open(self.filepath) as f:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_SH)
+                    try:
+                        data = json.load(f)
+                        self.__counters = data.get("counters", {})
+                    finally:
+                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            except (OSError, json.JSONDecodeError):
+                self.__counters = {}
+        if self._is_auto_save_enabled:
+            self.daemon_thread = threading.Thread(target=self.__save_daemon, daemon=True)
+            self.daemon_thread.start()
+
+    def increment(self, key: str, amount: int = 1):
+        with self.lock:
+            self.__counters[key] = self.__counters.get(key, 0) + amount
+            self.changes_since_last_save += 1
+
+        if self.changes_since_last_save >= self.save_threshold:
+            self.__save_to_file()
+
+    def get_all_counters(self) -> dict[str, int]:
+        with self.lock:
+            return self.__counters.copy()
+
+    def __save_daemon(self):
+        while self._is_auto_save_enabled:
+            time.sleep(self.save_interval)
+            if self.changes_since_last_save:
+                self.__save_to_file()
+
+    def __save_to_file(self):
+        with self.lock:
+            if not self.changes_since_last_save:
+                return
+            last_save_time = datetime.datetime.now(TZ_INFO)
+            save_data = {"counters": self.__counters.copy(), "last_save_time": last_save_time.isoformat()}
+
+        # Save to temp file and then move it
+        temp_file = self.filepath.with_suffix(".tmp")
+        try:
+            with Path.open(temp_file, "w") as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                try:
+                    json.dump(save_data, f, indent=2)
+                    f.flush()
+                finally:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+                temp_file.replace(self.filepath)
+        except OSError:
+            print("Error saving counter file")
+            return
+
+        with self.lock:
+            self.changes_since_last_save = 0
+            self.last_save_time = last_save_time
+
+    def shutdown(self):
+        self._is_auto_save_enabled = False
+        if hasattr(self, "daemon_thread") and self.daemon_thread.is_alive():
+            self.daemon_thread.join(timeout=5)
+        self.__save_to_file()

src/mountain_madness/_2026/models.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class CounterResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    good: int
+    evil: int

src/mountain_madness/_2026/setup.sh

@@ -0,0 +1 @@
+sudo mkdir -p /var/lib/mountain_madness/2026

src/mountain_madness/_2026/urls.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter
+
+from mountain_madness._2026 import CounterResponse, mm_counter
+
+router = APIRouter(
+    prefix="/mm",
+    tags=["Mountain Madness"],
+)
+
+
+@router.get(
+    "/counters",
+    description="Get both counters",
+    response_description="Get both counters",
+    response_model=CounterResponse,
+    operation_id="mm_get_counters",
+)
+async def get_all_counters():
+    return CounterResponse(**mm_counter.get_all_counters())
+
+
+@router.post(
+    "/good",
+    description="Increment the good counter",
+    response_description="Increment the good counter",
+    response_model=CounterResponse,
+    operation_id="mm_good_increment",
+)
+async def increment_good():
+    mm_counter.increment("good")
+    return CounterResponse(**mm_counter.get_all_counters())
+
+
+@router.post(
+    "/evil",
+    description="Increment the evil counter",
+    response_description="Increment the evil counter",
+    response_model=CounterResponse,
+    operation_id="mm_evil_increment",
+)
+async def increment_evil():
+    mm_counter.increment("evil")
+    return CounterResponse(**mm_counter.get_all_counters())