Update app.py

app.py

@@ -21,6 +21,8 @@ ACTIVITY_CACHE_FILE = "space_activity_cache.json"
 CACHE_UPDATE_INTERVAL = 600  # 10分钟 = 600秒
 CACHE_LOCK = threading.Lock()
 
+# 修改 SpaceActivityCache 类的相关方法
+
 class SpaceActivityCache:
     def __init__(self, repo_dir):
         self.repo_dir = repo_dir
@@ -29,187 +31,89 @@ class SpaceActivityCache:
         self._last_update = None
         self._update_thread = None
         self._stop_event = threading.Event()
+        self._is_initialized = False
         
-        # 启动时立即更新一次缓存
-        self._update_cache()
+        # 启动时先尝试从文件加载缓存，而不是立即更新
+        self._load_cache_from_file_on_init()
         
         # 启动后台更新线程
         self.start_background_updates()
     
+    def _load_cache_from_file_on_init(self):
+        """初始化时从文件加载缓存"""
+        try:
+            if os.path.exists(self.cache_file_path):
+                with open(self.cache_file_path, 'r', encoding='utf-8') as f:
+                    self._cache_data = json.load(f)
+                    if 'last_updated' in self._cache_data:
+                        self._last_update = datetime.fromisoformat(self._cache_data['last_updated'])
+                        self._is_initialized = True
+                        print(f"[SpaceActivityCache] Cache loaded from file on init: {len(self._cache_data.get('spaces', {}))} spaces")
+                    else:
+                        print("[SpaceActivityCache] Invalid cache file format")
+            else:
+                print("[SpaceActivityCache] No cache file found on init")
+        except Exception as e:
+            print(f"[SpaceActivityCache] Error loading cache on init: {e}")
+        
+        # 如果没有有效缓存，标记为需要初始更新
+        if not self._is_initialized:
+            print("[SpaceActivityCache] No valid cache found, will update on first background cycle")
+    
     def start_background_updates(self):
         """启动后台缓存更新线程"""
         if self._update_thread and self._update_thread.is_alive():
-            return  # 已经在运行
+            return
         
         self._stop_event.clear()
         self._update_thread = threading.Thread(target=self._background_update_worker, daemon=True)
         self._update_thread.start()
         print("[SpaceActivityCache] Background update thread started")
     
-    def stop_background_updates(self):
-        """停止后台更新线程"""
-        if self._update_thread:
-            self._stop_event.set()
-            print("[SpaceActivityCache] Background update thread stopping...")
-    
     def _background_update_worker(self):
-        """后台更新工作线程"""
+        """后台更新工作线程 - 修改启动逻辑"""
+        # 如果没有初始化，等待30秒后进行第一次更新
+        if not self._is_initialized:
+            print("[SpaceActivityCache] Waiting 30 seconds before first cache update...")
+            if self._stop_event.wait(timeout=30):
+                return  # 收到停止信号
+            
+            print("[SpaceActivityCache] Performing initial cache update...")
+            self._update_cache()
+            self._is_initialized = True
+        
+        # 正常的定期更新循环
         while not self._stop_event.is_set():
             try:
                 # 等待指定间隔或停止信号
                 if self._stop_event.wait(timeout=CACHE_UPDATE_INTERVAL):
-                    break  # 收到停止信号
+                    break
                 
-                # 执行缓存更新
                 print("[SpaceActivityCache] Starting scheduled cache update...")
                 self._update_cache()
                 print("[SpaceActivityCache] Scheduled cache update completed")
                 
             except Exception as e:
                 print(f"[SpaceActivityCache] Error in background update: {e}")
-                # 发生错误时等待较短时间后重试
-                if not self._stop_event.wait(timeout=60):  # 1分钟后重试
+                if not self._stop_event.wait(timeout=60):
                     continue
     
-    def _update_cache(self):
-        """更新缓存数据"""
-        try:
-            print("[SpaceActivityCache] Updating activity cache...")
-            start_time = time.time()
-            
-            # 获取所有可用空间
-            available_spaces = self._get_available_spaces()
-            
-            new_cache_data = {
-                'last_updated': datetime.now().isoformat(),
-                'update_interval_seconds': CACHE_UPDATE_INTERVAL,
-                'spaces': {}
-            }
-            
-            # 为每个空间读取最后活动时间
-            for space_name in available_spaces:
-                csv_file = os.path.join(self.repo_dir, f"{space_name}_query_log.csv")
-                last_activity, status = self._get_last_activity_from_file(csv_file)
-                
-                new_cache_data['spaces'][space_name] = {
-                    'last_activity': last_activity.isoformat() if last_activity != datetime.min else None,
-                    'status': status,
-                    'cache_update_time': datetime.now().isoformat()
-                }
-                
-                print(f"[SpaceActivityCache] {space_name}: {status}")
-            
-            # 线程安全地更新缓存
-            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")
-            
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error updating cache: {e}")
-            import traceback
-            print(f"[SpaceActivityCache] Traceback: {traceback.format_exc()}")
-    
-    def _get_available_spaces(self):
-        """获取可用空间列表"""
-        available_spaces = set()
-        try:
-            for filename in os.listdir(self.repo_dir):
-                if filename.endswith('_query_log.csv') and '_Student_' in filename:
-                    space_name = filename.replace('_query_log.csv', '')
-                    available_spaces.add(space_name)
-            return sorted(list(available_spaces))
-        except Exception as e:
-            print(f"[SpaceActivityCache] Error getting available spaces: {e}")
-            return []
-    
-    def _get_last_activity_from_file(self, csv_file_path):
-        """从文件读取最后活动时间（使用原来的方法）"""
-        try:
-            if not os.path.exists(csv_file_path):
-                return datetime.min, "file_not_found"
-            
-            # 检查文件大小
-            file_size = os.path.getsize(csv_file_path)
-            if file_size <= 100:
-                return datetime.min, "empty_or_header_only"
-            
-            # 使用CSV reader读取最后一行
-            with open(csv_file_path, 'r', encoding='utf-8') as f:
-                csv_reader = csv.reader(f)
-                
-                # 跳过header
-                try:
-                    header = next(csv_reader)
-                except StopIteration:
-                    return datetime.min, "empty_file"
-                
-                # 读取所有行，获取最后一行
-                rows = []
-                try:
-                    for row in csv_reader:
-                        if row:  # 跳过空行
-                            rows.append(row)
-                except Exception as csv_error:
-                    print(f"[SpaceActivityCache] CSV parsing error for {csv_file_path}: {csv_error}")
-                    return datetime.min, "csv_parse_error"
-            
-            if not rows:
-                return datetime.min, "no_data_rows"
-            
-            # 解析最后一行的时间戳
-            last_row = rows[-1]
-            if len(last_row) >= 3:
-                timestamp_str = last_row[2].strip()  # timestamp column
-                try:
-                    parsed_time = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
-                    return parsed_time, f"active_last_at_{parsed_time.strftime('%Y-%m-%d_%H:%M:%S')}"
-                except ValueError as ve:
-                    print(f"[SpaceActivityCache] Date parsing error for '{timestamp_str}': {ve}")
-                    return datetime.min, "date_parse_error"
-            else:
-                return datetime.min, "invalid_row_format"
-                
-        except Exception as e:
-            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 and os.path.exists(self.cache_file_path):
+                try:
+                    with open(self.cache_file_path, 'r', encoding='utf-8') as f:
+                        self._cache_data = json.load(f)
+                        print("[SpaceActivityCache] Cache loaded from file in get_space_activity")
+                except Exception as e:
+                    print(f"[SpaceActivityCache] Error loading cache in get_space_activity: {e}")
+            
+            # 如果仍然没有缓存数据，返回默认值而不是触发更新
             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(f"[SpaceActivityCache] No cache data available for {space_name}, returning defaults")
+                return datetime.min, "no_cache_available"
             
             spaces_data = self._cache_data.get('spaces', {})
             space_info = spaces_data.get(space_name, {})
@@ -231,17 +135,25 @@ class SpaceActivityCache:
             return last_activity, status
     
     def get_all_spaces_activity(self):
-        """获取所有空间的活动信息"""
+        """获取所有空间的活动信息 - 不触发立即更新"""
         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()
+            # 如果缓存为空但已经有缓存文件，尝试加载
+            if not self._cache_data and os.path.exists(self.cache_file_path):
+                try:
+                    with open(self.cache_file_path, 'r', encoding='utf-8') as f:
+                        self._cache_data = json.load(f)
+                        print("[SpaceActivityCache] Cache loaded from file in get_all_spaces_activity")
+                except Exception as e:
+                    print(f"[SpaceActivityCache] Error loading cache in get_all_spaces_activity: {e}")
             
             result = {}
             spaces_data = self._cache_data.get('spaces', {})
             
+            # 如果没有缓存数据，返回空字典而不是触发更新
+            if not spaces_data:
+                print("[SpaceActivityCache] No cached spaces data available, returning empty dict")
+                return result
+            
             for space_name, space_info in spaces_data.items():
                 last_activity_str = space_info.get('last_activity')
                 if last_activity_str:
@@ -299,8 +211,9 @@ def init_activity_cache(repo_dir):
         print("[init_activity_cache] Activity cache initialized")
     return activity_cache
 
+# 修改 analyze_space_activity_cached 函数
 def analyze_space_activity_cached(available_spaces, repo_dir):
-    """使用缓存的空间活动分析"""
+    """使用缓存的空间活动分析 - 改进版本"""
     global activity_cache
     
     # 确保缓存已初始化
@@ -314,14 +227,18 @@ def analyze_space_activity_cached(available_spaces, repo_dir):
     cache_info = activity_cache.get_cache_info()
     print(f"[analyze_space_activity_cached] Using cache (age: {cache_info['age_minutes']:.1f} min, fresh: {cache_info['is_fresh']})")
     
-    # 如果缓存太旧，可以选择强制更新（可选）
-    if not cache_info['is_fresh']:
-        print("[analyze_space_activity_cached] Cache is stale, but using it anyway for speed")
-        # 可以选择在后台触发更新：activity_cache.force_update()
-    
     # 获取所有空间的缓存活动数据
     all_spaces_activity = activity_cache.get_all_spaces_activity()
     
+    # 如果缓存完全为空，为所有空间提供默认值
+    if not all_spaces_activity:
+        print("[analyze_space_activity_cached] No cached data available, using default values for all spaces")
+        for space_name in available_spaces:
+            all_spaces_activity[space_name] = {
+                'last_activity': datetime.min,
+                'status': 'no_cache_data'
+            }
+    
     # Read allocation records to filter out recently allocated spaces
     active_allocations = read_allocation_records(repo_dir)
     
@@ -335,14 +252,17 @@ def analyze_space_activity_cached(available_spaces, repo_dir):
             last_activity = cached_info['last_activity']
             cached_status = cached_info['status']
         else:
-            # 缓存中没有这个空间，可能是新空间
+            # 缓存中没有这个空间，使用默认值
             last_activity = datetime.min
             cached_status = "not_in_cache"
         
         # Calculate idle time in minutes
-        if last_activity == datetime.min or 'empty' in cached_status or 'not_found' in cached_status:
-            idle_minutes = float('inf')  # Never used
-            status = "Never used"
+        if last_activity == datetime.min or 'empty' in cached_status or 'not_found' in cached_status or 'no_cache' in cached_status:
+            idle_minutes = float('inf')  # Never used or no data
+            if 'no_cache' in cached_status:
+                status = "No cache data available"
+            else:
+                status = "Never used"
             last_activity_str = "Never"
         else:
             idle_minutes = (current_time - last_activity).total_seconds() / 60
@@ -386,8 +306,8 @@ class LocalAllocationTracker:
     def __init__(self):
         self._recent_allocations = {}  # {space_name: {'student_id': str, 'timestamp': datetime}}
         self._lock = threading.Lock()
-        self._cleanup_interval = 60  # 清理间隔（秒）
-        self._allocation_ttl = 30   # 本地分配记录的生存时间（秒）
+        self._cleanup_interval = 600  # 清理间隔（秒）
+        self._allocation_ttl = 60   # 本地分配记录的生存时间（秒）
         
         # 启动后台清理线程
         self._start_cleanup_thread()
@@ -712,10 +632,28 @@ def simple_push_allocation_record(repo, space_name, student_id):
 
 
 
-def create_status_display(space_activity):
-    """Create formatted status display for all spaces with proper line breaks"""
+# 修改状态显示函数，处理无缓存数据的情况
+def create_status_display_with_cache_info(space_activity):
+    """创建包含缓存信息的状态显示 - 改进版本"""
+    global activity_cache
+    
+    # 获取缓存状态
+    cache_info = activity_cache.get_cache_info() if activity_cache else None
+    
     status_display = "📊 **Current Space Status (sorted by availability):**<br><br>"
     
+    # 显示缓存信息
+    if cache_info:
+        if cache_info['is_fresh']:
+            cache_status = f"✅ Fresh (updated {cache_info['age_minutes']:.1f} min ago)"
+        elif cache_info['last_updated']:
+            cache_status = f"⚠️ Stale (updated {cache_info['age_minutes']:.1f} min ago)"
+        else:
+            cache_status = f"🔄 No cache data (background update in progress)"
+        
+        status_display += f"🔄 **Cache Status:** {cache_status}<br>"
+        status_display += f"📋 **Cached Spaces:** {cache_info['spaces_count']}<br><br>"
+    
     # 显示本地分配记录摘要
     local_summary = local_tracker.get_recent_allocations_summary()
     if local_summary:
@@ -727,7 +665,13 @@ def create_status_display(space_activity):
     for i, space in enumerate(space_activity, 1):
         status_display += f"{i}. **{space['space_name']}**<br>"
         status_display += f"&nbsp;&nbsp;&nbsp;• Status: {space['status']}<br>"
-        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br><br>"
+        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br>"
+        
+        # 显示缓存状态
+        if 'cached_status' in space:
+            status_display += f"&nbsp;&nbsp;&nbsp;• Cache: {space['cached_status']}<br>"
+        
+        status_display += "<br>"
     
     return status_display