Update app.py

app.py

@@ -13,14 +13,111 @@ DATA_STORAGE_REPO = "CIV3283/Data_Storage"
 DATA_BRANCH_NAME = "data_branch"
 LOCAL_DATA_DIR = "temp_data_storage"
 MIN_IDLE_MINUTES = 10  # Minimum idle time required for space assignment
-ALLOCATION_RECORD_FILE = "allocation_records.csv"  # New file for tracking allocations
 ALLOCATION_LOCK_DURATION = 5  # Lock duration in minutes
 
-# 缓存配置
-ACTIVITY_CACHE_FILE = "space_activity_cache.json"
+# 缓存配置 - 全部改为内存存储
 CACHE_UPDATE_INTERVAL = 600  # 10分钟 = 600秒
 DATA_SYNC_INTERVAL = 600    # 数据同步间隔，10分钟 = 600秒
 CACHE_LOCK = threading.Lock()
+ALLOCATION_LOCK = threading.Lock()
+
+# 全局内存存储
+class MemoryAllocationStore:
+    """内存中的分配记录存储"""
+    def __init__(self):
+        self._allocations = {}  # {space_name: {'student_id': str, 'allocated_time': datetime, 'expires_at': datetime}}
+        self._lock = threading.Lock()
+        self._cleanup_interval = 60  # 每分钟清理一次过期记录
+        
+        # 启动后台清理线程
+        self._start_cleanup_thread()
+    
+    def _start_cleanup_thread(self):
+        """启动后台清理过期分配记录的线程"""
+        def cleanup_worker():
+            while True:
+                time.sleep(self._cleanup_interval)
+                self._cleanup_expired_allocations()
+        
+        cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True)
+        cleanup_thread.start()
+        print("[MemoryAllocationStore] Background cleanup thread started")
+    
+    def _cleanup_expired_allocations(self):
+        """清理过期的分配记录"""
+        with self._lock:
+            current_time = datetime.now()
+            expired_spaces = []
+            
+            for space_name, alloc_info in self._allocations.items():
+                if alloc_info['expires_at'] <= current_time:
+                    expired_spaces.append(space_name)
+            
+            for space_name in expired_spaces:
+                del self._allocations[space_name]
+                if expired_spaces:  # 只在有过期记录时打印
+                    print(f"[MemoryAllocationStore] Cleaned up expired allocation: {space_name}")
+    
+    def add_allocation(self, space_name, student_id):
+        """添加新的分配记录"""
+        with self._lock:
+            current_time = datetime.now()
+            expires_at = current_time + timedelta(minutes=ALLOCATION_LOCK_DURATION)
+            
+            self._allocations[space_name] = {
+                'student_id': student_id,
+                'allocated_time': current_time,
+                'expires_at': expires_at
+            }
+            
+            print(f"[MemoryAllocationStore] Added allocation: {space_name} -> {student_id} (expires at {expires_at.strftime('%H:%M:%S')})")
+    
+    def get_active_allocations(self):
+        """获取所有有效的分配记录"""
+        with self._lock:
+            current_time = datetime.now()
+            active_allocations = {}
+            
+            for space_name, alloc_info in self._allocations.items():
+                if alloc_info['expires_at'] > current_time:
+                    active_allocations[space_name] = alloc_info.copy()
+            
+            return active_allocations
+    
+    def is_allocated(self, space_name):
+        """检查指定空间是否被分配"""
+        with self._lock:
+            if space_name not in self._allocations:
+                return False, None
+            
+            alloc_info = self._allocations[space_name]
+            current_time = datetime.now()
+            
+            if alloc_info['expires_at'] > current_time:
+                return True, alloc_info['student_id']
+            else:
+                # 过期了，删除记录
+                del self._allocations[space_name]
+                return False, None
+    
+    def get_status_summary(self):
+        """获取分配状态摘要"""
+        with self._lock:
+            current_time = datetime.now()
+            active_count = 0
+            summary = []
+            
+            for space_name, alloc_info in self._allocations.items():
+                if alloc_info['expires_at'] > current_time:
+                    active_count += 1
+                    remaining_minutes = (alloc_info['expires_at'] - current_time).total_seconds() / 60
+                    summary.append(f"{space_name} -> {alloc_info['student_id']} ({remaining_minutes:.1f}min left)")
+            
+            return {
+                'active_count': active_count,
+                'total_stored': len(self._allocations),
+                'summary': summary
+            }
 
 # 全局数据管理器
 class DataManager:
@@ -153,9 +250,9 @@ class DataManager:
             print("[DataManager] Background sync thread stopping...")
 
 class SpaceActivityCache:
+    """内存中的空间活动缓存"""
     def __init__(self, data_manager):
         self.data_manager = data_manager
-        self.cache_file_path = os.path.join(LOCAL_DATA_DIR, ACTIVITY_CACHE_FILE)
         self._cache_data = {}
         self._last_update = None
         self._update_thread = None
@@ -233,9 +330,6 @@ class SpaceActivityCache:
             with CACHE_LOCK:
                 self._cache_data = new_cache_data
                 self._last_update = datetime.now()
-                
-                # 保存到文件
-                self._save_cache_to_file()
             
             elapsed_time = time.time() - start_time
             print(f"[SpaceActivityCache] Cache updated in {elapsed_time:.2f}s, {len(available_spaces)} spaces processed")
@@ -296,37 +390,12 @@ class SpaceActivityCache:
             print(f"[SpaceActivityCache] Error reading {csv_file_path}: {e}")
             return datetime.min, "read_error"
     
-    def _save_cache_to_file(self):
-        """保存缓存到文件"""
-        try:
-            with open(self.cache_file_path, 'w', encoding='utf-8') as f:
-                json.dump(self._cache_data, f, indent=2, ensure_ascii=False)
-            print(f"[SpaceActivityCache] Cache saved to {self.cache_file_path}")
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error saving cache to file: {e}")
-    
-    def _load_cache_from_file(self):
-        """从文件加载缓存"""
-        try:
-            if os.path.exists(self.cache_file_path):
-                with open(self.cache_file_path, 'r', encoding='utf-8') as f:
-                    data = json.load(f)
-                    print(f"[SpaceActivityCache] Cache loaded from file")
-                    return data
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error loading cache from file: {e}")
-        return {}
-    
     def get_space_activity(self, space_name):
         """获取指定空间的活动信息"""
         with CACHE_LOCK:
             if not self._cache_data or 'spaces' not in self._cache_data:
-                # 缓存为空，尝试从文件加载
-                self._cache_data = self._load_cache_from_file()
-                if not self._cache_data:
-                    # 文件也没有，立即更新一次
-                    print("[SpaceActivityCache] No cache available, updating immediately...")
-                    self._update_cache()
+                print("[SpaceActivityCache] No cache available, updating immediately...")
+                self._update_cache()
             
             spaces_data = self._cache_data.get('spaces', {})
             space_info = spaces_data.get(space_name, {})
@@ -351,10 +420,8 @@ class SpaceActivityCache:
         """获取所有空间的活动信息"""
         with CACHE_LOCK:
             if not self._cache_data or 'spaces' not in self._cache_data:
-                self._cache_data = self._load_cache_from_file()
-                if not self._cache_data:
-                    print("[SpaceActivityCache] No cache available, updating immediately...")
-                    self._update_cache()
+                print("[SpaceActivityCache] No cache available, updating immediately...")
+                self._update_cache()
             
             result = {}
             spaces_data = self._cache_data.get('spaces', {})
@@ -439,7 +506,8 @@ class LocalAllocationTracker:
             
             for space_name in expired_spaces:
                 del self._recent_allocations[space_name]
-                print(f"[LocalAllocationTracker] Cleaned up expired allocation: {space_name}")
+                if expired_spaces:  # 只在有过期记录时打印
+                    print(f"[LocalAllocationTracker] Cleaned up expired allocation: {space_name}")
     
     def is_recently_allocated_locally(self, space_name):
         """检查空间是否在本地被最近分配过"""
@@ -483,6 +551,7 @@ class LocalAllocationTracker:
 data_manager = DataManager()
 activity_cache = None
 local_tracker = LocalAllocationTracker()
+memory_allocation_store = MemoryAllocationStore()
 
 def init_system():
     """初始化整个系统 - 只在启动时调用一次"""
@@ -500,7 +569,7 @@ def init_system():
     print("[init_system] System initialization completed")
 
 def analyze_space_activity_cached():
-    """使用缓存的空间活动分析 - 不再需要传入参数"""
+    """使用缓存的空间活动分析 - 完全使用内存数据"""
     global activity_cache
     
     if activity_cache is None:
@@ -508,7 +577,6 @@ def analyze_space_activity_cached():
     
     # 从数据管理器获取可用空间列表（不触发数据同步）
     available_spaces = data_manager.get_available_spaces()
-    repo_dir = data_manager.get_repo_dir()
     
     space_activity = []
     current_time = datetime.now()
@@ -520,10 +588,11 @@ def analyze_space_activity_cached():
     # 获取所有空间的缓存活动数据
     all_spaces_activity = activity_cache.get_all_spaces_activity()
     
-    # Read allocation records to filter out recently allocated spaces
-    active_allocations = read_allocation_records(repo_dir)
+    # 从内存获取分配记录 - 不再读取文件
+    active_allocations = memory_allocation_store.get_active_allocations()
     
     print(f"[analyze_space_activity_cached] Analyzing {len(available_spaces)} spaces using cached data...")
+    print(f"[analyze_space_activity_cached] Memory allocations: {len(active_allocations)} active")
     
     for space_name in available_spaces:
         # 从缓存获取活动信息
@@ -547,12 +616,12 @@ def analyze_space_activity_cached():
             status = f"Idle for {idle_minutes:.1f} minutes (cached)"
             last_activity_str = last_activity.strftime('%Y-%m-%d %H:%M:%S')
         
-        # Check if space is recently allocated (remote)
-        is_recently_allocated_remote = space_name in active_allocations
-        if is_recently_allocated_remote:
+        # 检查内存中的分配记录
+        is_recently_allocated_memory = space_name in active_allocations
+        if is_recently_allocated_memory:
             alloc_info = active_allocations[space_name]
             minutes_until_free = (alloc_info['expires_at'] - current_time).total_seconds() / 60
-            status += f" (Recently allocated remotely, free in {minutes_until_free:.1f} min)"
+            status += f" (Allocated in memory to {alloc_info['student_id']}, free in {minutes_until_free:.1f} min)"
         
         # Check if space is recently allocated (local)
         is_recently_allocated_local, local_student = local_tracker.is_recently_allocated_locally(space_name)
@@ -565,7 +634,7 @@ def analyze_space_activity_cached():
             'last_activity_str': last_activity_str,
             'idle_minutes': idle_minutes,
             'status': status,
-            'is_recently_allocated_remote': is_recently_allocated_remote,
+            'is_recently_allocated_memory': is_recently_allocated_memory,
             'is_recently_allocated_local': is_recently_allocated_local,
             'cached_status': cached_status
         })
@@ -577,152 +646,18 @@ def analyze_space_activity_cached():
     
     return space_activity
 
-def read_allocation_records(repo_dir):
-    """Read and parse allocation records, returning only non-expired allocations"""
-    allocation_file = os.path.join(repo_dir, ALLOCATION_RECORD_FILE)
-    current_time = datetime.now()
-    active_allocations = {}
-    
-    try:
-        if not os.path.exists(allocation_file):
-            print(f"[read_allocation_records] Allocation file not found, returning empty")
-            return active_allocations
-        
-        # Use the same CSV reading approach as query logs
-        with open(allocation_file, 'r', encoding='utf-8') as f:
-            csv_reader = csv.reader(f)
-            
-            # Skip header row
-            try:
-                header = next(csv_reader)
-                print(f"[read_allocation_records] CSV header: {header}")
-            except StopIteration:
-                print(f"[read_allocation_records] Empty allocation file")
-                return active_allocations
-            
-            # Read all data rows
-            rows = []
-            try:
-                for row in csv_reader:
-                    if row and len(row) >= 4:  # Skip empty rows and ensure minimum columns
-                        rows.append(row)
-            except Exception as csv_error:
-                print(f"[read_allocation_records] CSV parsing error: {csv_error}")
-                return active_allocations
-        
-        if not rows:
-            print(f"[read_allocation_records] No allocation data rows")
-            return active_allocations
-        
-        # Process each allocation record
-        for row in rows:
-            try:
-                space_name = row[0].strip()
-                student_id = row[1].strip()
-                allocated_time_str = row[2].strip()
-                expires_at_str = row[3].strip()
-                
-                allocated_time = datetime.strptime(allocated_time_str, '%Y-%m-%d %H:%M:%S')
-                expires_at = datetime.strptime(expires_at_str, '%Y-%m-%d %H:%M:%S')
-                
-                # Only keep non-expired allocations
-                if expires_at > current_time:
-                    active_allocations[space_name] = {
-                        'student_id': student_id,
-                        'allocated_time': allocated_time,
-                        'expires_at': expires_at
-                    }
-                    print(f"[read_allocation_records] Active allocation: {space_name} -> {student_id}")
-                else:
-                    print(f"[read_allocation_records] Expired allocation: {space_name} (expired at {expires_at})")
-                    
-            except (ValueError, IndexError) as ve:
-                print(f"[read_allocation_records] Error parsing allocation row {row}: {ve}")
-                continue
-                
-    except Exception as e:
-        print(f"[read_allocation_records] Error reading allocation records: {e}")
-        return {}
-    
-    print(f"[read_allocation_records] Found {len(active_allocations)} active allocations")
-    return active_allocations
-
-def write_allocation_record(space_name, student_id, repo_dir):
-    """Write a new allocation record to the file"""
-    allocation_file = os.path.join(repo_dir, ALLOCATION_RECORD_FILE)
-    current_time = datetime.now()
-    expires_at = current_time + timedelta(minutes=ALLOCATION_LOCK_DURATION)
-    
-    try:
-        # Read existing records to filter out expired ones
-        existing_records = []
-        current_time_check = datetime.now()
-        
-        if os.path.exists(allocation_file):
-            with open(allocation_file, 'r', encoding='utf-8') as f:
-                csv_reader = csv.reader(f)
-                try:
-                    header = next(csv_reader)  # Skip header
-                    for row in csv_reader:
-                        if len(row) >= 4:  # Ensure row has all required columns
-                            try:
-                                row_expires_at = datetime.strptime(row[3], '%Y-%m-%d %H:%M:%S')
-                                # Only keep non-expired records
-                                if row_expires_at > current_time_check:
-                                    existing_records.append(row)
-                            except ValueError:
-                                continue
-                except StopIteration:
-                    pass  # Empty file or no header
-        
-        # Append new allocation record
-        with open(allocation_file, 'w', newline='', encoding='utf-8') as f:
-            writer = csv.writer(f)
-            # Write header
-            writer.writerow(['space_name', 'student_id', 'allocated_time', 'expires_at'])
-            # Write existing non-expired records
-            writer.writerows(existing_records)
-            # Write new allocation
-            new_record = [
-                space_name,
-                student_id,
-                current_time.strftime('%Y-%m-%d %H:%M:%S'),
-                expires_at.strftime('%Y-%m-%d %H:%M:%S')
-            ]
-            writer.writerow(new_record)
-        
-        print(f"[write_allocation_record] Recorded allocation: {space_name} -> {student_id} (expires at {expires_at})")
-        return True
-        
-    except Exception as e:
-        print(f"[write_allocation_record] Error writing allocation record: {e}")
-        return False
-
-def simple_push_allocation_record(repo, space_name, student_id):
-    """Simple push allocation record using Repository API"""
-    try:
-        # Use Repository's push_to_hub method instead of git commands
-        commit_message = f"Allocate {space_name} to student {student_id}"
-        
-        # Push the allocation file to hub
-        repo.push_to_hub(
-            commit_message=commit_message,
-            blocking=True,  # Wait for completion
-            auto_lfs_prune=True
-        )
-        
-        print(f"[simple_push_allocation_record] Successfully pushed allocation record")
-        return True
-        
-    except Exception as e:
-        print(f"[simple_push_allocation_record] Error pushing allocation record: {e}")
-        print(f"[simple_push_allocation_record] Allocation recorded locally, sync will happen eventually")
-        return False
-
 def create_status_display(space_activity):
     """Create formatted status display for all spaces with proper line breaks"""
     status_display = "📊 **Current Space Status (sorted by availability):**<br><br>"
     
+    # 显示内存分配记录摘要
+    memory_summary = memory_allocation_store.get_status_summary()
+    if memory_summary['active_count'] > 0:
+        status_display += f"🧠 **Memory Allocations ({memory_summary['active_count']} active):**<br>"
+        for alloc in memory_summary['summary']:
+            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
+        status_display += "<br>"
+    
     # 显示本地分配记录摘要
     local_summary = local_tracker.get_recent_allocations_summary()
     if local_summary:
@@ -739,16 +674,16 @@ def create_status_display(space_activity):
     return status_display
 
 def select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id):
-    """使用缓存的增强防撞空间选择函数"""
+    """使用缓存的增强防撞空间选择函数 - 完全使用内存存储"""
     
     print(f"[select_space_with_enhanced_collision_avoidance_cached] Starting selection for student: {student_id}")
     
     # 第一步：过滤掉不符合基本条件的空间
     basic_available_spaces = []
     for space in space_activity:
-        # 检查基本条件
+        # 检查基本条件 - 使用内存分配记录
         if (space['idle_minutes'] >= MIN_IDLE_MINUTES and 
-            not space['is_recently_allocated_remote'] and 
+            not space['is_recently_allocated_memory'] and 
             not space['is_recently_allocated_local']):
             basic_available_spaces.append(space)
     
@@ -757,14 +692,14 @@ def select_space_with_enhanced_collision_avoidance_cached(space_activity, studen
     if not basic_available_spaces:
         # 生成详细的错误信息
         idle_spaces = [s for s in space_activity if s['idle_minutes'] >= MIN_IDLE_MINUTES]
-        remote_allocated = [s for s in space_activity if s['is_recently_allocated_remote']]
+        memory_allocated = [s for s in space_activity if s['is_recently_allocated_memory']]
         local_allocated = [s for s in space_activity if s['is_recently_allocated_local']]
         
         error_parts = []
         if not idle_spaces:
             error_parts.append(f"all spaces used within {MIN_IDLE_MINUTES} minutes")
-        if remote_allocated:
-            error_parts.append(f"{len(remote_allocated)} spaces remotely allocated")
+        if memory_allocated:
+            error_parts.append(f"{len(memory_allocated)} spaces allocated in memory")
         if local_allocated:
             error_parts.append(f"{len(local_allocated)} spaces locally allocated")
         
@@ -805,21 +740,13 @@ def select_space_with_enhanced_collision_avoidance_cached(space_activity, studen
             print(f"[select_space_with_enhanced_collision_avoidance_cached] No alternatives available")
             raise gr.Error(error_msg, duration=8)
     
-    # 第四步：立即记录本地分配（在写入文件之前）
+    # 第四步：立即记录本地分配（在写入内存之前）
     local_tracker.record_local_allocation(space_name, student_id)
-    print(f"[select_space_with_enhanced_collision_avoidance_cached] Local allocation recorded BEFORE file write")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Local allocation recorded BEFORE memory write")
     
-    # 第五步：记录到文件和远程
-    repo = data_manager.get_repo()
-    repo_dir = data_manager.get_repo_dir()
-    
-    write_success = write_allocation_record(space_name, student_id, repo_dir)
-    if write_success:
-        push_success = simple_push_allocation_record(repo, space_name, student_id)
-        if not push_success:
-            print(f"[select_space_with_enhanced_collision_avoidance_cached] Warning: Allocation recorded locally but not synced to remote")
-    else:
-        print(f"[select_space_with_enhanced_collision_avoidance_cached] Warning: Failed to record allocation to file")
+    # 第五步：记录到内存存储 - 不再写入文件或推送到远程
+    memory_allocation_store.add_allocation(space_name, student_id)
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Allocation recorded in memory only")
     
     # 第六步：生成结果（使用带缓存信息的状态显示）
     status_display = create_status_display_with_cache_info(space_activity)
@@ -876,7 +803,7 @@ def redirect_to_space(redirect_url, selected_space, status_display):
 {status_display}
             </div>
             <p style="margin-bottom: 0; color: #666; font-size: 14px; margin-top: 15px;">
-                <strong>Enhanced Selection Algorithm:</strong> Spaces idle for ≥{MIN_IDLE_MINUTES} minutes, not remotely allocated, and not locally allocated are eligible. The system includes real-time collision avoidance to prevent multiple students from being assigned to the same space.
+                <strong>Enhanced Selection Algorithm:</strong> Spaces idle for ≥{MIN_IDLE_MINUTES} minutes, not allocated in memory, and not locally allocated are eligible. The system uses pure memory storage for real-time collision avoidance.
             </p>
         </div>
         
@@ -891,7 +818,7 @@ def redirect_to_space(redirect_url, selected_space, status_display):
     return gr.HTML(redirect_html)
 
 def load_balance_user_cached(student_id):
-    """使用缓存的负载均衡函数 - 不再初始化数据连接"""
+    """使用缓存的负载均衡函数 - 完全使用内存存储"""
     print(f"[load_balance_user_cached] Starting cached load balancing for student ID: {student_id}")
     
     # 检查系统是否已初始化
@@ -934,6 +861,14 @@ def create_status_display_with_cache_info(space_activity):
         status_display += f"🔄 **Cache Status:** {cache_status}<br>"
         status_display += f"📋 **Cached Spaces:** {cache_info['spaces_count']}<br><br>"
     
+    # 显示内存分配记录摘要
+    memory_summary = memory_allocation_store.get_status_summary()
+    if memory_summary['active_count'] > 0:
+        status_display += f"🧠 **Memory Allocations ({memory_summary['active_count']} active):**<br>"
+        for alloc in memory_summary['summary']:
+            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
+        status_display += "<br>"
+    
     # 显示本地分配记录摘要
     local_summary = local_tracker.get_recent_allocations_summary()
     if local_summary:
@@ -1024,6 +959,20 @@ def force_data_sync():
     except Exception as e:
         return {"error": str(e)}
 
+def get_memory_allocation_status():
+    """获取内存分配状态"""
+    return memory_allocation_store.get_status_summary()
+
+def clear_memory_allocations():
+    """清除所有内存分配记录（管理功能）"""
+    try:
+        with memory_allocation_store._lock:
+            cleared_count = len(memory_allocation_store._allocations)
+            memory_allocation_store._allocations.clear()
+        return {"status": f"Cleared {cleared_count} memory allocations"}
+    except Exception as e:
+        return {"error": str(e)}
+
 # 添加可选的管理界面（用于调试）
 def create_admin_interface():
     """创建管理界面（可选）- 增强版本"""
@@ -1046,6 +995,14 @@ def create_admin_interface():
             data_info_display = gr.JSON(label="Data Manager Information")
             data_status_message = gr.Markdown("")
         
+        with gr.Tab("Memory Allocation"):
+            with gr.Row():
+                memory_status_btn = gr.Button("🧠 Check Memory Allocations", variant="secondary")
+                clear_memory_btn = gr.Button("🗑️ Clear All Memory Allocations", variant="stop")
+            
+            memory_info_display = gr.JSON(label="Memory Allocation Information")
+            memory_status_message = gr.Markdown("")
+        
         def check_cache_status():
             try:
                 status = get_cache_status()
@@ -1106,6 +1063,33 @@ def create_admin_interface():
             except Exception as e:
                 return {"error": str(e)}, f"❌ Error syncing data: {str(e)}"
         
+        def check_memory_status():
+            try:
+                status = get_memory_allocation_status()
+                active_count = status['active_count']
+                total_stored = status['total_stored']
+                
+                if active_count > 0:
+                    message = f"🧠 {active_count} active allocations ({total_stored} total in memory)"
+                else:
+                    message = "✅ No active memory allocations"
+                
+                return status, message
+            except Exception as e:
+                return {"error": str(e)}, f"❌ Error checking memory allocations: {str(e)}"
+        
+        def clear_memory():
+            try:
+                result = clear_memory_allocations()
+                if 'error' in result:
+                    return result, "❌ Failed to clear memory allocations"
+                else:
+                    # 获取更新后的状态
+                    status = get_memory_allocation_status()
+                    return status, f"✅ {result['status']}"
+            except Exception as e:
+                return {"error": str(e)}, f"❌ Error clearing memory: {str(e)}"
+        
         # Cache tab event handlers
         cache_status_btn.click(
             fn=check_cache_status,
@@ -1127,6 +1111,17 @@ def create_admin_interface():
             fn=force_sync,
             outputs=[data_info_display, data_status_message]
         )
+        
+        # Memory tab event handlers
+        memory_status_btn.click(
+            fn=check_memory_status,
+            outputs=[memory_info_display, memory_status_message]
+        )
+        
+        clear_memory_btn.click(
+            fn=clear_memory,
+            outputs=[memory_info_display, memory_status_message]
+        )
     
     return admin_interface
 
@@ -1154,6 +1149,7 @@ if __name__ == "__main__":
         print("🚀 Initializing CIV3283 Load Distributor System...")
         init_system()
         print("✅ System initialization completed successfully")
+        print("🧠 Using pure memory storage for allocations (no file I/O during user access)")
         
         # 检查是否需要管理界面
         enable_admin = "--admin" in sys.argv or os.environ.get("ENABLE_ADMIN", "false").lower() == "true"