Update app.py

app.py

@@ -19,47 +19,154 @@ 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()
 
-# 修改 SpaceActivityCache 类的相关方法
+# 全局数据管理器
+class DataManager:
+    def __init__(self):
+        self.repo = None
+        self.available_spaces = []
+        self.last_data_sync = None
+        self._sync_lock = threading.Lock()
+        self._sync_thread = None
+        self._stop_event = threading.Event()
+        self.initialized = False
+    
+    def initialize(self):
+        """初始化数据管理器 - 只在启动时调用一次"""
+        if self.initialized:
+            return True
+        
+        try:
+            print("[DataManager] Initializing data manager...")
+            
+            # 初始化仓库连接
+            self.repo = Repository(
+                local_dir=LOCAL_DATA_DIR,
+                clone_from=DATA_STORAGE_REPO,
+                revision=DATA_BRANCH_NAME,
+                repo_type="space",
+                use_auth_token=os.environ.get("HF_HUB_TOKEN")
+            )
+            
+            # 配置git用户
+            self.repo.git_config_username_and_email("git_user", f"load_distributor")
+            self.repo.git_config_username_and_email("git_email", f"loaddistributor@takeiteasy.space")
+            
+            # 初始数据同步
+            self._sync_data()
+            
+            # 启动后台同步线程
+            self._start_background_sync()
+            
+            self.initialized = True
+            print("[DataManager] Data manager initialized successfully")
+            return True
+            
+        except Exception as e:
+            print(f"[DataManager] Initialization failed: {e}")
+            return False
+    
+    def _start_background_sync(self):
+        """启动后台数据同步线程"""
+        if self._sync_thread and self._sync_thread.is_alive():
+            return
+        
+        self._stop_event.clear()
+        self._sync_thread = threading.Thread(target=self._background_sync_worker, daemon=True)
+        self._sync_thread.start()
+        print("[DataManager] Background sync thread started")
+    
+    def _background_sync_worker(self):
+        """后台同步工作线程"""
+        while not self._stop_event.is_set():
+            try:
+                # 等待指定间隔或停止信号
+                if self._stop_event.wait(timeout=DATA_SYNC_INTERVAL):
+                    break
+                
+                print("[DataManager] Starting scheduled data sync...")
+                self._sync_data()
+                print("[DataManager] Scheduled data sync completed")
+                
+            except Exception as e:
+                print(f"[DataManager] Error in background sync: {e}")
+                if not self._stop_event.wait(timeout=60):  # 1分钟后重试
+                    continue
+    
+    def _sync_data(self):
+        """同步数据 - 拉取最新数据并更新可用空间列表"""
+        with self._sync_lock:
+            try:
+                start_time = time.time()
+                print("[DataManager] Syncing data from remote repository...")
+                
+                # 拉取最新数据
+                self.repo.git_pull(rebase=True)
+                
+                # 更新可用空间列表
+                self.available_spaces = self._get_available_spaces()
+                self.last_data_sync = datetime.now()
+                
+                elapsed_time = time.time() - start_time
+                print(f"[DataManager] Data sync completed in {elapsed_time:.2f}s, found {len(self.available_spaces)} spaces")
+                
+            except Exception as e:
+                print(f"[DataManager] Error syncing data: {e}")
+    
+    def _get_available_spaces(self):
+        """获取可用空间列表"""
+        available_spaces = set()
+        try:
+            for filename in os.listdir(LOCAL_DATA_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"[DataManager] Error getting available spaces: {e}")
+            return []
+    
+    def get_available_spaces(self):
+        """获取可用空间列表 - 不触发数据同步"""
+        if not self.initialized:
+            raise Exception("DataManager not initialized")
+        return self.available_spaces.copy()
+    
+    def get_repo(self):
+        """获取仓库对象"""
+        if not self.initialized:
+            raise Exception("DataManager not initialized")
+        return self.repo
+    
+    def get_repo_dir(self):
+        """获取仓库本地目录"""
+        if not self.initialized:
+            raise Exception("DataManager not initialized")
+        return LOCAL_DATA_DIR
+    
+    def stop(self):
+        """停止后台同步"""
+        if self._sync_thread:
+            self._stop_event.set()
+            print("[DataManager] Background sync thread stopping...")
 
 class SpaceActivityCache:
-    def __init__(self, repo_dir):
-        self.repo_dir = repo_dir
-        self.cache_file_path = os.path.join(repo_dir, ACTIVITY_CACHE_FILE)
+    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
         self._stop_event = threading.Event()
-        self._is_initialized = False
         
-        # 启动时先尝试从文件加载缓存，而不是立即更新
-        self._load_cache_from_file_on_init()
+        # 启动时立即更新一次缓存
+        self._update_cache()
         
         # 启动后台更新线程
         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():
@@ -70,19 +177,14 @@ class SpaceActivityCache:
         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:
                 # 等待指定间隔或停止信号
@@ -95,25 +197,136 @@ class SpaceActivityCache:
                 
             except Exception as e:
                 print(f"[SpaceActivityCache] Error in background update: {e}")
-                if not self._stop_event.wait(timeout=60):
+                if not self._stop_event.wait(timeout=60):  # 1分钟后重试
                     continue
     
-    def get_space_activity(self, space_name):
-        """获取指定空间的活动信息 - 不触发立即更新"""
-        with CACHE_LOCK:
-            # 如果缓存为空但已经有缓存文件，尝试加载
-            if not self._cache_data and os.path.exists(self.cache_file_path):
+    def _update_cache(self):
+        """更新缓存数据"""
+        try:
+            print("[SpaceActivityCache] Updating activity cache...")
+            start_time = time.time()
+            
+            # 从数据管理器获取可用空间（不触发数据同步）
+            available_spaces = self.data_manager.get_available_spaces()
+            repo_dir = self.data_manager.get_repo_dir()
+            
+            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(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_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:
-                    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}")
+                    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 or 'spaces' not in self._cache_data:
-                print(f"[SpaceActivityCache] No cache data available for {space_name}, returning defaults")
-                return datetime.min, "no_cache_available"
+                # 缓存为空，尝试从文件加载
+                self._cache_data = self._load_cache_from_file()
+                if not self._cache_data:
+                    # 文件也没有，立即更新一次
+                    print("[SpaceActivityCache] No cache available, updating immediately...")
+                    self._update_cache()
             
             spaces_data = self._cache_data.get('spaces', {})
             space_info = spaces_data.get(space_name, {})
@@ -135,25 +348,17 @@ class SpaceActivityCache:
             return last_activity, status
     
     def get_all_spaces_activity(self):
-        """获取所有空间的活动信息 - 不触发立即更新"""
+        """获取所有空间的活动信息"""
         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_all_spaces_activity")
-                except Exception as e:
-                    print(f"[SpaceActivityCache] Error loading cache in get_all_spaces_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()
             
             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:
@@ -183,7 +388,7 @@ class SpaceActivityCache:
                         'last_updated': last_updated,
                         'age_minutes': age_minutes,
                         'spaces_count': len(self._cache_data.get('spaces', {})),
-                        'is_fresh': age_minutes < (CACHE_UPDATE_INTERVAL / 60) * 1.5  # 允许1.5倍的间隔
+                        'is_fresh': age_minutes < (CACHE_UPDATE_INTERVAL / 60) * 1.5
                     }
                 except:
                     pass
@@ -200,107 +405,6 @@ class SpaceActivityCache:
         print("[SpaceActivityCache] Force updating cache...")
         self._update_cache()
 
-# 全局缓存实例
-activity_cache = None
-
-def init_activity_cache(repo_dir):
-    """初始化活动缓存"""
-    global activity_cache
-    if activity_cache is None:
-        activity_cache = SpaceActivityCache(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
-    
-    # 确保缓存已初始化
-    if activity_cache is None:
-        activity_cache = init_activity_cache(repo_dir)
-    
-    space_activity = []
-    current_time = datetime.now()
-    
-    # 获取缓存信息
-    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']})")
-    
-    # 获取所有空间的缓存活动数据
-    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)
-    
-    print(f"[analyze_space_activity_cached] Analyzing {len(available_spaces)} spaces using cached data...")
-    
-    for space_name in available_spaces:
-        # 从缓存获取活动信息
-        cached_info = all_spaces_activity.get(space_name)
-        
-        if cached_info:
-            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 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
-            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:
-            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)"
-        
-        # Check if space is recently allocated (local)
-        is_recently_allocated_local, local_student = local_tracker.is_recently_allocated_locally(space_name)
-        if is_recently_allocated_local:
-            status += f" (Recently allocated locally to {local_student})"
-        
-        space_activity.append({
-            'space_name': space_name,
-            'last_activity': last_activity,
-            'last_activity_str': last_activity_str,
-            'idle_minutes': idle_minutes,
-            'status': status,
-            'is_recently_allocated_remote': is_recently_allocated_remote,
-            'is_recently_allocated_local': is_recently_allocated_local,
-            'cached_status': cached_status
-        })
-        
-        print(f"[analyze_space_activity_cached] {space_name}: {status}")
-    
-    # Sort by idle time (most idle first)
-    space_activity.sort(key=lambda x: x['idle_minutes'], reverse=True)
-    
-    return space_activity
-
-
-
 # 新增：本地防撞车机制
 class LocalAllocationTracker:
     def __init__(self):
@@ -376,117 +480,102 @@ class LocalAllocationTracker:
             return summary
 
 # 全局实例
+data_manager = DataManager()
+activity_cache = None
 local_tracker = LocalAllocationTracker()
 
-# Environment variables
-HF_HUB_TOKEN = os.environ.get("HF_HUB_TOKEN", None)
-if HF_HUB_TOKEN is None:
-    raise ValueError("Set HF_HUB_TOKEN in Space Settings -> Secrets")
-
-def init_data_storage_connection():
-    """Initialize connection to centralized data storage repository"""
-    try:
-        repo = Repository(
-            local_dir=LOCAL_DATA_DIR,
-            clone_from=DATA_STORAGE_REPO,
-            revision=DATA_BRANCH_NAME,
-            repo_type="space",
-            use_auth_token=HF_HUB_TOKEN
-        )
-        # Configure git user
-        repo.git_config_username_and_email("git_user", f"load_distributor")
-        repo.git_config_username_and_email("git_email", f"loaddistributor@takeiteasy.space")
-        
-        print(f"[init_data_storage_connection] Pulling latest data from {DATA_STORAGE_REPO}...")
-        repo.git_pull(rebase=True)
-        
-        print(f"[init_data_storage_connection] Successfully connected to data storage")
-        print(f"[init_data_storage_connection] Local directory: {LOCAL_DATA_DIR}")
-        print(f"[init_data_storage_connection] Branch: {DATA_BRANCH_NAME}")
-        
-        return repo
-        
-    except Exception as e:
-        print(f"[init_data_storage_connection] Error: {e}")
-        return None
+def init_system():
+    """初始化整个系统 - 只在启动时调用一次"""
+    global activity_cache
+    
+    print("[init_system] Initializing load distributor system...")
+    
+    # 初始化数据管理器
+    if not data_manager.initialize():
+        raise Exception("Failed to initialize data manager")
+    
+    # 初始化活动缓存
+    activity_cache = SpaceActivityCache(data_manager)
+    
+    print("[init_system] System initialization completed")
 
-def get_available_spaces(repo_dir):
-    """Dynamically get space list from CIV3283/Data_Storage"""
-    available_spaces = set()
+def analyze_space_activity_cached():
+    """使用缓存的空间活动分析 - 不再需要传入参数"""
+    global activity_cache
     
-    try:
-        # Scan all *_query_log.csv files
-        for filename in os.listdir(repo_dir):
-            if filename.endswith('_query_log.csv') and '_Student_' in filename:
-                # Extract space name from filename: CIV3283_Student_01_query_log.csv → CIV3283_Student_01
-                space_name = filename.replace('_query_log.csv', '')
-                available_spaces.add(space_name)
+    if activity_cache is None:
+        raise Exception("Activity cache not initialized")
+    
+    # 从数据管理器获取可用空间列表（不触发数据同步）
+    available_spaces = data_manager.get_available_spaces()
+    repo_dir = data_manager.get_repo_dir()
+    
+    space_activity = []
+    current_time = datetime.now()
+    
+    # 获取缓存信息
+    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']})")
+    
+    # 获取所有空间的缓存活动数据
+    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)
+    
+    print(f"[analyze_space_activity_cached] Analyzing {len(available_spaces)} spaces using cached data...")
+    
+    for space_name in available_spaces:
+        # 从缓存获取活动信息
+        cached_info = all_spaces_activity.get(space_name)
         
-        spaces_list = sorted(list(available_spaces))
-        print(f"[get_available_spaces] Found {len(spaces_list)} student spaces: {spaces_list}")
-        return spaces_list
+        if cached_info:
+            last_activity = cached_info['last_activity']
+            cached_status = cached_info['status']
+        else:
+            # 缓存中没有这个空间，可能是新空间
+            last_activity = datetime.min
+            cached_status = "not_in_cache"
         
-    except Exception as e:
-        print(f"[get_available_spaces] Error: {e}")
-        return []
-
-def get_last_activity_time(csv_file_path):
-    """Get the timestamp of the last activity from query log file using proper CSV parsing"""
-    try:
-        if not os.path.exists(csv_file_path):
-            print(f"[get_last_activity_time] File not found: {csv_file_path}")
-            return datetime.min  # Never used
+        # 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"
+            last_activity_str = "Never"
+        else:
+            idle_minutes = (current_time - last_activity).total_seconds() / 60
+            status = f"Idle for {idle_minutes:.1f} minutes (cached)"
+            last_activity_str = last_activity.strftime('%Y-%m-%d %H:%M:%S')
         
-        # Use proper CSV reader to handle multiline cells
-        with open(csv_file_path, 'r', encoding='utf-8') as f:
-            csv_reader = csv.reader(f)
-            
-            # Skip header row
-            try:
-                header = next(csv_reader)
-                print(f"[get_last_activity_time] CSV header: {header}")
-            except StopIteration:
-                print(f"[get_last_activity_time] Empty file: {csv_file_path}")
-                return datetime.min
-            
-            # Read all data rows
-            rows = []
-            try:
-                for row in csv_reader:
-                    if row:  # Skip empty rows
-                        rows.append(row)
-            except Exception as csv_error:
-                print(f"[get_last_activity_time] CSV parsing error: {csv_error}")
-                return datetime.min
+        # Check if space is recently allocated (remote)
+        is_recently_allocated_remote = space_name in active_allocations
+        if is_recently_allocated_remote:
+            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)"
         
-        if not rows:
-            print(f"[get_last_activity_time] No data rows in file: {csv_file_path}")
-            return datetime.min  # No data
+        # Check if space is recently allocated (local)
+        is_recently_allocated_local, local_student = local_tracker.is_recently_allocated_locally(space_name)
+        if is_recently_allocated_local:
+            status += f" (Recently allocated locally to {local_student})"
         
-        # Get the last row (most recent entry)
-        last_row = rows[-1]
-        print(f"[get_last_activity_time] Last row has {len(last_row)} columns")
-        print(f"[get_last_activity_time] Last row preview: {[col[:50] + '...' if len(col) > 50 else col for col in last_row[:3]]}")
+        space_activity.append({
+            'space_name': space_name,
+            'last_activity': last_activity,
+            'last_activity_str': last_activity_str,
+            'idle_minutes': idle_minutes,
+            'status': status,
+            'is_recently_allocated_remote': is_recently_allocated_remote,
+            'is_recently_allocated_local': is_recently_allocated_local,
+            'cached_status': cached_status
+        })
         
-        # Parse timestamp from the 3rd column (index 2)
-        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')
-                print(f"[get_last_activity_time] Parsed timestamp: {parsed_time}")
-                return parsed_time
-            except ValueError as ve:
-                print(f"[get_last_activity_time] Date parsing error for '{timestamp_str}': {ve}")
-                return datetime.min
-        else:
-            print(f"[get_last_activity_time] Invalid row format - expected ≥3 columns, got {len(last_row)}")
-            return datetime.min
-            
-    except Exception as e:
-        print(f"[get_last_activity_time] Error reading {csv_file_path}: {e}")
-        import traceback
-        print(f"[get_last_activity_time] Traceback: {traceback.format_exc()}")
-        return datetime.min
+        print(f"[analyze_space_activity_cached] {space_name}: {status}")
+    
+    # Sort by idle time (most idle first)
+    space_activity.sort(key=lambda x: x['idle_minutes'], reverse=True)
+    
+    return space_activity
 
 def read_allocation_records(repo_dir):
     """Read and parse allocation records, returning only non-expired allocations"""
@@ -630,30 +719,10 @@ def simple_push_allocation_record(repo, space_name, student_id):
         print(f"[simple_push_allocation_record] Allocation recorded locally, sync will happen eventually")
         return False
 
-
-
-# 修改状态显示函数，处理无缓存数据的情况
-def create_status_display_with_cache_info(space_activity):
-    """创建包含缓存信息的状态显示 - 改进版本"""
-    global activity_cache
-    
-    # 获取缓存状态
-    cache_info = activity_cache.get_cache_info() if activity_cache else None
-    
+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>"
     
-    # 显示缓存信息
-    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:
@@ -665,18 +734,11 @@ def create_status_display_with_cache_info(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>"
-        
-        # 显示缓存状态
-        if 'cached_status' in space:
-            status_display += f"&nbsp;&nbsp;&nbsp;• Cache: {space['cached_status']}<br>"
-        
-        status_display += "<br>"
+        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br><br>"
     
     return status_display
 
-# 修改select_space函数以使用新的状态显示
-def select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id, repo):
+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}")
@@ -748,7 +810,10 @@ def select_space_with_enhanced_collision_avoidance_cached(space_activity, studen
     print(f"[select_space_with_enhanced_collision_avoidance_cached] Local allocation recorded BEFORE file write")
     
     # 第五步：记录到文件和远程
-    write_success = write_allocation_record(space_name, student_id, repo.local_dir)
+    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:
@@ -764,21 +829,6 @@ def select_space_with_enhanced_collision_avoidance_cached(space_activity, studen
     
     return redirect_to_space(redirect_url, selected_space, status_display)
 
-def get_cache_status():
-    """获取缓存状态（用于调试或管理）"""
-    global activity_cache
-    if activity_cache:
-        return activity_cache.get_cache_info()
-    return {"error": "Cache not initialized"}
-
-def force_cache_update():
-    """强制更新缓存（用于调试或管理）"""
-    global activity_cache
-    if activity_cache:
-        activity_cache.force_update()
-        return {"status": "Cache updated"}
-    return {"error": "Cache not initialized"}
-
 def redirect_to_space(redirect_url, selected_space, status_display):
     """Display redirect information with manual click option"""
     
@@ -841,28 +891,18 @@ 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}")
     
-    # Initialize connection to data storage
-    repo = init_data_storage_connection()
-    if not repo:
-        raise gr.Error("🚫 Unable to connect to the data storage system. Please try again later.", duration=8)
-    
-    # 初始化活动缓存
-    init_activity_cache(LOCAL_DATA_DIR)
-    
-    # Get available spaces dynamically
-    available_spaces = get_available_spaces(LOCAL_DATA_DIR)
+    # 检查系统是否已初始化
+    if not data_manager.initialized:
+        raise gr.Error("🚫 System not properly initialized. Please contact administrator.", duration=8)
     
-    if not available_spaces:
-        raise gr.Error("🚫 No student learning assistant spaces found in the system. Please contact your instructor.", duration=8)
-    
-    # 使用缓存版本的分析函数
-    space_activity = analyze_space_activity_cached(available_spaces, LOCAL_DATA_DIR)
+    # 使用缓存版本的分析函数（不触发数据同步）
+    space_activity = analyze_space_activity_cached()
     
     # Select space with enhanced collision avoidance
-    return select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id, repo)
+    return select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id)
 
 def get_url_params(request: gr.Request):
     """Extract URL parameters from request"""
@@ -951,18 +991,60 @@ def handle_user_access_cached(request: gr.Request):
         """
         return title, gr.HTML(error_html)
 
+# 管理功能
+def get_cache_status():
+    """获取缓存状态（用于调试或管理）"""
+    global activity_cache
+    if activity_cache:
+        return activity_cache.get_cache_info()
+    return {"error": "Cache not initialized"}
+
+def force_cache_update():
+    """强制更新缓存（用于调试或管理）"""
+    global activity_cache
+    if activity_cache:
+        activity_cache.force_update()
+        return {"status": "Cache updated"}
+    return {"error": "Cache not initialized"}
+
+def get_data_manager_status():
+    """获取数据管理器状态"""
+    return {
+        "initialized": data_manager.initialized,
+        "last_sync": data_manager.last_data_sync.isoformat() if data_manager.last_data_sync else None,
+        "spaces_count": len(data_manager.available_spaces),
+        "repo_connected": data_manager.repo is not None
+    }
+
+def force_data_sync():
+    """强制数据同步"""
+    try:
+        data_manager._sync_data()
+        return {"status": "Data sync completed"}
+    except Exception as e:
+        return {"error": str(e)}
+
 # 添加可选的管理界面（用于调试）
 def create_admin_interface():
-    """创建管理界面（可选）- 简化版本"""
+    """创建管理界面（可选）- 增强版本"""
     with gr.Blocks(title="CIV3283 Load Distributor - Admin") as admin_interface:
         gr.Markdown("# 🔧 CIV3283 Load Distributor - Admin Panel")
         
-        with gr.Row():
-            cache_status_btn = gr.Button("📊 Check Cache Status", variant="secondary")
-            force_update_btn = gr.Button("🔄 Force Cache Update", variant="primary")
-        
-        cache_info_display = gr.JSON(label="Cache Information")
-        status_message = gr.Markdown("")
+        with gr.Tab("Cache Management"):
+            with gr.Row():
+                cache_status_btn = gr.Button("📊 Check Cache Status", variant="secondary")
+                force_cache_update_btn = gr.Button("🔄 Force Cache Update", variant="primary")
+            
+            cache_info_display = gr.JSON(label="Cache Information")
+            cache_status_message = gr.Markdown("")
+            
+        with gr.Tab("Data Management"):
+            with gr.Row():
+                data_status_btn = gr.Button("📊 Check Data Manager Status", variant="secondary")
+                force_data_sync_btn = gr.Button("🔄 Force Data Sync", variant="primary")
+            
+            data_info_display = gr.JSON(label="Data Manager Information")
+            data_status_message = gr.Markdown("")
         
         def check_cache_status():
             try:
@@ -995,14 +1077,55 @@ def create_admin_interface():
             except Exception as e:
                 return {"error": str(e)}, f"❌ Error updating cache: {str(e)}"
         
+        def check_data_status():
+            try:
+                status = get_data_manager_status()
+                if status['initialized']:
+                    last_sync = status['last_sync']
+                    if last_sync:
+                        sync_time = datetime.fromisoformat(last_sync)
+                        age_minutes = (datetime.now() - sync_time).total_seconds() / 60
+                        message = f"✅ Data manager active (last sync: {age_minutes:.1f} min ago, {status['spaces_count']} spaces)"
+                    else:
+                        message = "⚠️ Data manager initialized but no sync recorded"
+                else:
+                    message = "❌ Data manager not initialized"
+                return status, message
+            except Exception as e:
+                return {"error": str(e)}, f"❌ Error checking data manager: {str(e)}"
+        
+        def force_sync():
+            try:
+                result = force_data_sync()
+                if 'error' in result:
+                    return result, "❌ Failed to sync data"
+                else:
+                    # 获取更新后的状态
+                    status = get_data_manager_status()
+                    return status, "✅ Data sync completed successfully"
+            except Exception as e:
+                return {"error": str(e)}, f"❌ Error syncing data: {str(e)}"
+        
+        # Cache tab event handlers
         cache_status_btn.click(
             fn=check_cache_status,
-            outputs=[cache_info_display, status_message]
+            outputs=[cache_info_display, cache_status_message]
         )
         
-        force_update_btn.click(
+        force_cache_update_btn.click(
             fn=force_update,
-            outputs=[cache_info_display, status_message]
+            outputs=[cache_info_display, cache_status_message]
+        )
+        
+        # Data tab event handlers
+        data_status_btn.click(
+            fn=check_data_status,
+            outputs=[data_info_display, data_status_message]
+        )
+        
+        force_data_sync_btn.click(
+            fn=force_sync,
+            outputs=[data_info_display, data_status_message]
         )
     
     return admin_interface
@@ -1026,24 +1149,36 @@ def create_main_interface():
 if __name__ == "__main__":
     import sys
     
-    # 检查是否需要管理界面
-    enable_admin = "--admin" in sys.argv or os.environ.get("ENABLE_ADMIN", "false").lower() == "true"
-    
-    if enable_admin:
-        print("🔧 Starting with admin interface enabled")
-        # 创建带管理界面的组合界面
-        main_interface = create_main_interface()
-        admin_interface = create_admin_interface()
+    try:
+        # 系统初始化 - 只在启动时执行一次
+        print("🚀 Initializing CIV3283 Load Distributor System...")
+        init_system()
+        print("✅ System initialization completed successfully")
         
-        # 使用TabbedInterface组合两个界面
-        combined_interface = gr.TabbedInterface(
-            [main_interface, admin_interface],
-            ["🎯 Load Distributor", "🔧 Admin Panel"],
-            title="CIV3283 Load Distributor System"
-        )
-        combined_interface.launch()
-    else:
-        print("🎯 Starting main interface only")
-        # 只启动主界面
-        main_interface = create_main_interface()
-        main_interface.launch()
+        # 检查是否需要管理界面
+        enable_admin = "--admin" in sys.argv or os.environ.get("ENABLE_ADMIN", "false").lower() == "true"
+        
+        if enable_admin:
+            print("🔧 Starting with admin interface enabled")
+            # 创建带管理界面的组合界面
+            main_interface = create_main_interface()
+            admin_interface = create_admin_interface()
+            
+            # 使用TabbedInterface组合两个界面
+            combined_interface = gr.TabbedInterface(
+                [main_interface, admin_interface],
+                ["🎯 Load Distributor", "🔧 Admin Panel"],
+                title="CIV3283 Load Distributor System"
+            )
+            combined_interface.launch()
+        else:
+            print("🎯 Starting main interface only")
+            # 只启动主界面
+            main_interface = create_main_interface()
+            main_interface.launch()
+            
+    except Exception as e:
+        print(f"❌ System initialization failed: {e}")
+        import traceback
+        print(f"Traceback: {traceback.format_exc()}")
+        raise