Refactor share storage to Redis-backed service

Author: alvin000009238

.env.example

@@ -2,4 +2,6 @@ TUNNEL_TOKEN=your_tunnel_token_here
 SECRET_KEY=your_random_secret_string_here
 
 TURNSTILE_SITE_KEY=your_turnstile_site_key_here
-TURNSTILE_SECRET_KEY=your_turnstile_secret_key_here
+TURNSTILE_SECRET_KEY=your_turnstile_secret_key_here
+REDIS_URL=redis://redis:6379/0
+SHARE_TTL_SECONDS=7200

app/__init__.py

@@ -0,0 +1,31 @@
+import json
+import secrets
+import string
+from typing import Any, Dict, Optional
+
+from app.services.share_store import ShareStore
+
+SHARE_ID_CHARS = string.ascii_letters + string.digits + "-_.~"
+SHARE_ID_LENGTH = 15
+
+
+class ShareService:
+    def __init__(self, store: ShareStore, ttl_seconds: int):
+        self.store = store
+        self.ttl_seconds = ttl_seconds
+
+    def create_share(self, data: Dict[str, Any]) -> str:
+        share_id = ''.join(secrets.choice(SHARE_ID_CHARS) for _ in range(SHARE_ID_LENGTH))
+        payload = json.dumps(data, ensure_ascii=False)
+        self.store.save_share(share_id, payload, self.ttl_seconds)
+        return share_id
+
+    def get_share(self, share_id: str) -> Optional[Dict[str, Any]]:
+        payload = self.store.get_share(share_id)
+        if payload is None:
+            return None
+        return json.loads(payload)
+
+
+def is_valid_share_id(share_id: str) -> bool:
+    return all(c in SHARE_ID_CHARS for c in share_id)

app/services/__init__.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class ShareStore(ABC):
+    @abstractmethod
+    def save_share(self, share_id: str, payload: str, ttl: int) -> None:
+        """Persist a serialized share payload with TTL in seconds."""
+
+    @abstractmethod
+    def get_share(self, share_id: str) -> Optional[str]:
+        """Get serialized share payload, or None if missing/expired."""

app/services/share_service.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from redis import Redis
+
+from app.services.share_store import ShareStore
+
+
+class RedisShareStore(ShareStore):
+    def __init__(self, redis_client: Redis):
+        self.redis_client = redis_client
+
+    @staticmethod
+    def _key(share_id: str) -> str:
+        return f"share:{share_id}"
+
+    def save_share(self, share_id: str, payload: str, ttl: int) -> None:
+        self.redis_client.set(self._key(share_id), payload, ex=ttl)
+
+    def get_share(self, share_id: str) -> Optional[str]:
+        value = self.redis_client.get(self._key(share_id))
+        if value is None:
+            return None
+        if isinstance(value, bytes):
+            return value.decode("utf-8")
+        return value

app/services/share_store.py

@@ -1,14 +1,16 @@
 services:
   app:
     image: ghcr.io/${GHCR_IMAGE:-alvin000009238/school_grades}:latest
-    volumes:
-      - ./shared_grades:/app/shared_grades
+    depends_on:
+      - redis
     environment:
       - PYTHONUNBUFFERED=1
       - SECRET_KEY=${SECRET_KEY}
       - TURNSTILE_SITE_KEY=${TURNSTILE_SITE_KEY}
       - TURNSTILE_SECRET_KEY=${TURNSTILE_SECRET_KEY}
       - TZ=Asia/Taipei
+      - REDIS_URL=${REDIS_URL:-redis://redis:6379/0}
+      - SHARE_TTL_SECONDS=${SHARE_TTL_SECONDS:-7200}
 
     deploy:
       restart_policy:
@@ -32,3 +34,10 @@ services:
     deploy:
       restart_policy:
         condition: any
+
+  redis:
+    image: redis:7-alpine
+    command: redis-server --appendonly yes
+    deploy:
+      restart_policy:
+        condition: any

app/services/share_store_redis.py

@@ -4,3 +4,4 @@ beautifulsoup4
 gunicorn
 requests
 python-dotenv
+redis

docker-compose.yml

@@ -6,14 +6,13 @@
 import requests as http_requests
 import logging
 from logging.handlers import RotatingFileHandler
+from redis import Redis
 from fetcher import GradeFetcher
-import time
-import threading
-import secrets
-import string
-SHARED_FOLDER = 'shared_grades'
-CLEANUP_INTERVAL = 600  # 10 minutes
-FILE_LIFETIME = 7200    # 2 hours
+from app.services.share_service import ShareService, is_valid_share_id
+from app.services.share_store_redis import RedisShareStore
+
+SHARE_TTL_SECONDS = int(os.environ.get('SHARE_TTL_SECONDS', '7200'))
+REDIS_URL = os.environ.get('REDIS_URL', 'redis://redis:6379/0')
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -82,35 +81,8 @@ def verify_turnstile(token, remote_ip, context=''):
     return True, None
 
 
-if not os.path.exists(SHARED_FOLDER):
-    os.makedirs(SHARED_FOLDER)
-
-def cleanup_thread():
-    """Background thread to clean up old shared files."""
-    while True:
-        try:
-            now = time.time()
-            for filename in os.listdir(SHARED_FOLDER):
-                file_path = os.path.join(SHARED_FOLDER, filename)
-                if os.path.isfile(file_path):
-                    if now - os.path.getmtime(file_path) > FILE_LIFETIME:
-                        try:
-                            os.remove(file_path)
-                            logger.info(f"Deleted expired file: {filename}")
-                        except Exception as e:
-                            logger.error(f"Error deleting file {filename}: {e}")
-        except Exception as e:
-            logger.error(f"Error in cleanup thread: {e}")
-        time.sleep(CLEANUP_INTERVAL)
-
-# Start cleanup thread
-# In debug mode, Flask's reloader spawns two processes. We only start the thread
-# in the child (WERKZEUG_RUN_MAIN='true') to avoid running it twice.
-# In production (gunicorn), WERKZEUG_RUN_MAIN is not set, so it always starts.
-_is_reloader_parent = app.debug and os.environ.get('WERKZEUG_RUN_MAIN') != 'true'
-if not _is_reloader_parent:
-    threading.Thread(target=cleanup_thread, daemon=True).start()
-    logger.info("Cleanup thread started")
+redis_client = Redis.from_url(REDIS_URL)
+share_service = ShareService(store=RedisShareStore(redis_client), ttl_seconds=SHARE_TTL_SECONDS)
 
 @app.route('/')
 def index():
@@ -276,15 +248,7 @@ def create_share_link():
         if not ok:
             return err
 
-        # Generate 15-char random URL-safe ID with special chars
-        # Using A-Z, a-z, 0-9, -, _, ., ~
-        chars = string.ascii_letters + string.digits + "-_.~"
-        share_id = ''.join(secrets.choice(chars) for _ in range(15))
-        
-        file_path = os.path.join(SHARED_FOLDER, f"{share_id}.json")
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(data, f, ensure_ascii=False)
+        share_id = share_service.create_share(data)
 
         return jsonify({'success': True, 'id': share_id})
     except Exception as e:
@@ -294,17 +258,13 @@ def create_share_link():
 @app.route('/api/share/<share_id>', methods=['GET'])
 def get_shared_grades(share_id):
     try:
-        # Basic validation for ID (alphanumeric + special chars)
-        if not all(c in string.ascii_letters + string.digits + "-_.~" for c in share_id):
+        if not is_valid_share_id(share_id):
              return jsonify({'error': 'Invalid ID format'}), 400
 
-        file_path = os.path.join(SHARED_FOLDER, f"{share_id}.json")
-        if not os.path.exists(file_path):
+        data = share_service.get_share(share_id)
+        if data is None:
             return jsonify({'error': 'Link expired or not found'}), 404
 
-        with open(file_path, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-            
         return jsonify({'success': True, 'data': data})
     except Exception as e:
         logger.error(f"Error reading share: {e}")