Update server9-bf.py

server9-bf.py

@@ -50,11 +50,9 @@ kaggle_metadata = {
     "licenses": [{"name": "CC0-1.0"}]
 }
 
-# 全局状态变量
 last_uploaded_size = -1
 lock = threading.Lock()
 
-# FRP 配置文件列表
 configs = [
     ("""
     [common]
@@ -150,7 +148,6 @@ configs = [
 # 2. 核心通用工具函数
 # ==========================================
 def run_cmd(command, ignore_errors=False, quiet=False):
-    """统一的命令执行工具，替代 os.system"""
     try:
         stdout = subprocess.DEVNULL if quiet else None
         stderr = subprocess.DEVNULL if quiet else None
@@ -160,7 +157,6 @@ def run_cmd(command, ignore_errors=False, quiet=False):
             logging.error(f"命令执行失败: {command}\n错误码: {e.returncode}")
 
 def requests_retry_session(retries=3, backoff_factor=0.3, status_forcelist=(500, 502, 504), session=None):
-    """带重试机制的请求会话"""
     session = session or requests.Session()
     retry = Retry(total=retries, backoff_factor=backoff_factor, status_forcelist=status_forcelist)
     adapter = HTTPAdapter(max_retries=retry)
@@ -187,35 +183,27 @@ def init_environment():
     run_cmd("rm -r /sync.sh", ignore_errors=True, quiet=True)
     run_cmd("wget -q -O /sync.sh https://huggingface.co/datasets/Qilan2/st-server/resolve/main/sync.sh")
     run_cmd("export LC_ALL=zh_CN.UTF-8")
-    
     run_cmd("mkdir -p /content/frp")
     run_cmd("wget -q https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
     run_cmd("chmod +x /content/frp/frpc")
-    
-    if not is_installed('nodejs'):
-        install_package('nodejs')
-    if not is_installed('npm'):
-        install_package('npm')
-        
+    if not is_installed('nodejs'): install_package('nodejs')
+    if not is_installed('npm'): install_package('npm')
     run_cmd("pip uninstall requests urllib3 -y", quiet=True)
     run_cmd("pip install requests urllib3 ruamel.yaml pexpect pytz", quiet=True)
     run_cmd("apt-get install -y sshpass p7zip-full pigz pv", quiet=True)
     logging.info('-----------更新软件包列表结束-------------')
 
-def f(install_ssh_config=True):
+def setup_cloudflared(install_ssh_config=True):
     if install_ssh_config:
         run_cmd("sudo mkdir -p --mode=0755 /usr/share/keyrings")
         run_cmd("curl -fsSL https://pkg.cloudflare.com/cloudflare-public-v2.gpg | sudo tee /usr/share/keyrings/cloudflare-public-v2.gpg >/dev/null")
         run_cmd("echo 'deb [signed-by=/usr/share/keyrings/cloudflare-public-v2.gpg] https://pkg.cloudflare.com/cloudflared any main' | sudo tee /etc/apt/sources.list.d/cloudflared.list")
         run_cmd("sudo apt-get update && sudo apt-get install cloudflared -y", quiet=True)
-        
         ssh_dir = os.path.expanduser("~/.ssh")
         os.makedirs(ssh_dir, exist_ok=True)
         ssh_config_content = f"Host {cf_ssh}\n    ProxyCommand cloudflared access ssh --hostname %h\n    StrictHostKeyChecking no\n"
-        
         config_path = os.path.join(ssh_dir, "config")
-        with open(config_path, "w") as f:
-            f.write(ssh_config_content)
+        with open(config_path, "w") as f: f.write(ssh_config_content)
         os.chmod(config_path, 0o600)
     else:  
         run_cmd(f"sudo cloudflared service install {cf_token}", quiet=True)
@@ -225,7 +213,6 @@ def setup_ssh():
     run_cmd("apt update && apt install openssh-server vim -y", quiet=True)
     run_cmd("sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config")
     run_cmd("sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config")
-    
     run_cmd("echo 'root:qilan' | sudo chpasswd")
     run_cmd("echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config")
     run_cmd("service ssh restart", quiet=True)
@@ -250,218 +237,154 @@ def copy_public_key_to_remote(host, port, user, password):
 # 4. 接力信息修改模块 (IP与接力时间)
 # ==========================================
 def get_current_ip():
-    """获取当前公共 IP 地址"""
-    try:
-        response = requests.get("https://ipinfo.io/ip", timeout=5)
-        return response.text.strip()
-    except:
-        return "Unknown IP"
+    try: return requests.get("https://ipinfo.io/ip", timeout=5).text.strip()
+    except: return "Unknown IP"
 
 def get_geo_info(ip_address):
-    """根据 IP 地址获取地理位置信息"""
-    url = "https://api.qjqq.cn/api/Local"
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
-    }
     try:
-        response = requests.get(url, headers=headers, timeout=5)
-        if response.status_code == 200:
-            geo_info = response.json()
-            if geo_info.get('code') == 200:
-                data = geo_info['data']
-                return {'ip': data['ip'], 'country': data['country'], 'isp': data['isp']}
-    except Exception as e:
-        logging.error(f"获取地理位置失败: {e}")
+        response = requests.get("https://api.qjqq.cn/api/Local", headers={"User-Agent": "Mozilla/5.0"}, timeout=5)
+        if response.status_code == 200 and response.json().get('code') == 200:
+            data = response.json()['data']
+            return {'ip': data['ip'], 'country': data['country'], 'isp': data['isp']}
+    except: pass
     return None
 
 def get_next_relay_time():
-    """获取下一次接力时间（系统启动时间+12小时，转换为中国时区）"""
     try:
         boot_time = datetime.fromtimestamp(psutil.boot_time())
-        utc = pytz.UTC
-        boot_time = utc.localize(boot_time)
         china_tz = pytz.timezone('Asia/Shanghai')
-        boot_time_china = boot_time.astimezone(china_tz)
-        next_time = boot_time_china + timedelta(hours=12)
+        next_time = pytz.UTC.localize(boot_time).astimezone(china_tz) + timedelta(hours=12)
         return next_time.strftime("%Y-%m-%d %H:%M:%S")
-    except Exception as e:
-        logging.error(f"计算接力时间失败: {e}")
-        return "未知时间"
+    except: return "未知时间"
 
 def replace_info_in_file(file_path):
-    """修改 ST 登录界面的 IP 和接力时间信息"""
     try:
-        if not os.path.exists(file_path):
-            logging.warning(f"找不到文件进行替换: {file_path}")
-            return
-            
-        ip_address = get_current_ip()
-        geo_info = get_geo_info(ip_address)
-        next_relay_time = get_next_relay_time()
-        
-        if geo_info is not None:
-            with open(file_path, 'r', encoding='utf-8') as file:
-                content = file.read()
-            
-            time_pattern = r'接力时间\[.*?\]'
-            time_replacement = f'接力时间[{next_relay_time}]'
-            content = re.sub(time_pattern, time_replacement, content)
-            
-            ip_pattern = r'IP\[.*?\]\s*国家\s*\[.*?\]\s*IPS\[.*?\]'
-            ip_replacement = f'IP[{ip_address}] 国家 [{geo_info["country"]}] IPS[{geo_info["isp"]}]'
-            content = re.sub(ip_pattern, ip_replacement, content)
-            
-            with open(file_path, 'w', encoding='utf-8') as file:
-                file.write(content)
-            
-            logging.info(f"成功更新前端页面信息: 接力时间[{next_relay_time}], IP[{ip_address}]")
-    except Exception as e:
-        logging.error(f"替换前端信息时发生错误: {e}")
+        if not os.path.exists(file_path): return
+        ip_address, geo_info, next_relay_time = get_current_ip(), get_geo_info(get_current_ip()), get_next_relay_time()
+        if geo_info:
+            with open(file_path, 'r', encoding='utf-8') as f: content = f.read()
+            content = re.sub(r'接力时间\[.*?\]', f'接力时间[{next_relay_time}]', content)
+            content = re.sub(r'IP\[.*?\]\s*国家\s*\[.*?\]\s*IPS\[.*?\]', f'IP[{ip_address}] 国家 [{geo_info["country"]}] IPS[{geo_info["isp"]}]', content)
+            with open(file_path, 'w', encoding='utf-8') as f: f.write(content)
+            logging.info(f"前端页面更新成功: 接力时间[{next_relay_time}], IP[{ip_address}]")
+    except Exception as e: logging.error(f"替换前端信息发生错误: {e}")
 
 # ==========================================
 # 5. 双机接力 rsync 数据同步核心
 # ==========================================
 def sync_data_via_rsync():
-    """检测本地和远程接口，并进行 rsync 数据同步 (双机接力核心)"""
-    logging.info("------ 开始执行双机接力同步检测 (原 check_api1) ------")
-    
-    # 第一步：等待本地 ST 服务完全启动
+    """首次初始化阻断式同步"""
+    logging.info("------ 开始执行首次双机接力同步检测 ------")
     retry_n = 0
     while True:
-        retry_n += 1
-        if not os.path.exists(data_folder):
-            logging.error(f"{data_folder} 不存在，结束接力检测。")
-            return
+        if not os.path.exists(data_folder): return
         try:
-            response = requests.get("http://127.0.0.1:8000/v1", timeout=10)
-            if response.status_code == 403:
+            if requests.get("http://127.0.0.1:8000/v1", timeout=10).status_code == 403:
                 logging.info("SillyTavern 本地接口已启动！")
                 break
-        except requests.exceptions.RequestException:
-            pass
-        
-        if retry_n % 12 == 0: 
-            logging.info("等待本地 SillyTavern 启动中...")
+        except requests.exceptions.RequestException: pass
+        if (retry_n := retry_n + 1) % 12 == 0: logging.info("等待本地 ST 启动中...")
         time.sleep(5)
     
-    # 第二步：检测旧机器（远程）接口 token，触发 rsync 数据拉取
-    logging.info('ST本地已就绪，开始探测前置机器(旧机器)以触发同步...')
     fail_count = 0
     while fail_count <= 5:
-        if not os.path.exists(data_folder):
-            break
-            
-        url = f"{cf_jg}/csrf-token"
+        if not os.path.exists(data_folder): break
         try:
-            response = requests_retry_session().get(url, timeout=15)
-            response.raise_for_status()
-            response_json = response.json()
-            
-            if "token" in response_json:
-                logging.info(f"成功探测到前置机器的 Token: {response_json}")
-                logging.info("开始执行 rsync 从旧机器接力拉取最新数据...")
-                try:
-                    subprocess.run(
-                        f"sshpass -p 'qilan' rsync -avz --timeout=600 -e 'ssh -p 22 -o StrictHostKeyChecking=no' root@{cf_ssh}:{data_folder}/ {data_folder}/",
-                        shell=True, check=True
-                    )
-                    logging.info("数据接力拉取完美收官！当前机器已获取最新状态。")
-                    break # 同步成功后安全退出循环
-                except subprocess.CalledProcessError as e:
-                    fail_count += 1
-                    logging.error(f"Rsync 失败，正在重试 ({fail_count}/5)...")
-                    generate_ssh_key() 
+            response = requests_retry_session().get(f"{cf_jg}/csrf-token", timeout=15)
+            if response.status_code == 200 and "token" in response.json():
+                logging.info("成功探测到旧机器，执行首次全面接力拉取...")
+                # 注意这里加了 -u 参数，保护本地可能存在的新数据不被覆盖
+                subprocess.run(
+                    f"sshpass -p 'qilan' rsync -avzu --timeout=600 -e 'ssh -p 22 -o StrictHostKeyChecking=no' root@{cf_ssh}:{data_folder}/ {data_folder}/",
+                    shell=True, check=True
+                )
+                logging.info("首次拉取成功，旧机器数据已接管。")
+                break
+            else: fail_count += 1
+        except Exception as e:
+            fail_count += 1
+            if fail_count > 5: logging.warning("未检测到前置机器，可能已宕机，将使用本地数据。")
+        time.sleep(5)
+
+def continuous_sync_task():
+    """后台常驻：重叠期间每5分钟持续增量拉取旧机器数据"""
+    logging.info("------ 后台持续增量同步守护线程已启动 ------")
+    fail_count = 0
+    while fail_count < 5:
+        time.sleep(300) # 每5分钟探测拉取一次
+        try:
+            response = requests_retry_session().get(f"{cf_jg}/csrf-token", timeout=15)
+            if response.status_code == 200 and "token" in response.json():
+                logging.info("【接力中】探测到旧机器仍在运行，执行后台增量同步...")
+                # 核心：使用 -u (--update) 保证新机器上你产生的新聊天记录不会被旧机器覆盖！
+                subprocess.run(
+                    f"sshpass -p 'qilan' rsync -avzu --timeout=600 -e 'ssh -p 22 -o StrictHostKeyChecking=no' root@{cf_ssh}:{data_folder}/ {data_folder}/",
+                    shell=True, check=True, stdout=subprocess.DEVNULL
+                )
+                fail_count = 0 # 只要成功一次，就重置失败计数
             else:
-                logging.warning(f"接口未返回 token: {response_json}")
                 fail_count += 1
-                
         except Exception as e:
             fail_count += 1
-            logging.error(f"前置机器探测异常 ({fail_count}/5): {e}")
-            if fail_count > 5:
-                logging.warning("前置机器可能已宕机，接力同步取消，将使用当前本地数据继续。")
-        
-        time.sleep(5)
-    logging.info("------ 双机接力环节执行完毕 ------")
+            logging.info(f"探测旧机器异常，可能已关机。失败次数: {fail_count}/5")
+            
+    logging.info("------ 旧机器已彻底离线，后台接力同步任务圆满结束 ------")
 
 # ==========================================
 # 6. 后台备份、FRP 与进程守护
 # ==========================================
-def get_folder_size(folder):
-    try:
-        result = subprocess.run(['du', '-sb', folder], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        if result.returncode == 0:
-            return int(result.stdout.split()[0])
-    except:
-        return 0
-
 def compress_folder():
     global last_uploaded_size
     run_cmd('rm -rf /a/', ignore_errors=True, quiet=True) 
     os.makedirs('/a', exist_ok=True)
-    
     with lock:
-        current_folder_size = get_folder_size(data_folder)
-        if current_folder_size < (800 * 1024 ** 2):
-            return
+        try:
+            size_out = subprocess.run(['du', '-sb', data_folder], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            current_folder_size = int(size_out.stdout.split()[0]) if size_out.returncode == 0 else 0
+        except: return
+        
+        if current_folder_size < (800 * 1024 ** 2): return
 
         if last_uploaded_size == -1 or current_folder_size != last_uploaded_size:
             logging.info('开始压缩打包数据用于备份...')
             run_cmd(f'tar -cvf - {data_folder} | pigz -p 2 -1 > {zip_file_path}', quiet=True)
+            run_cmd(f'mv {zip_file_path} /a/sillytavern.ctk', ignore_errors=True)
+            if not os.path.exists("/a/sillytavern.ctk"): return
             
-            file_path = "/a/sillytavern.ctk"
-            run_cmd(f'mv {zip_file_path} {file_path}', ignore_errors=True)
-            if not os.path.exists(file_path):
-                 return
-                 
-            file_size = os.path.getsize(file_path)
-            if file_size < (800 * 1024 ** 2):
-                return
+            file_size = os.path.getsize("/a/sillytavern.ctk")
+            if file_size < (800 * 1024 ** 2): return
 
             logging.info("准备将压缩包上传至 Kaggle...")
-            with open(metadata_file_path, 'w') as json_fid:
-                json.dump(kaggle_metadata, json_fid)
-
+            with open(metadata_file_path, 'w') as f: json.dump(kaggle_metadata, f)
             run_cmd('kaggle datasets version -m "Auto Backup Update" -p /a')
             last_uploaded_size = file_size
 
 def repeat_task():
     logging.info('------后台定时打包备份线程已启动-------------')
     while True:
-        time.sleep(18000) # 每 5 小时备份一次
+        time.sleep(18000)
         compress_folder()
 
 def kill_frpc_processes():
-    try:
-        subprocess.run(['pkill', '-f', 'frpc'], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    except subprocess.CalledProcessError:
-        pass
+    try: subprocess.run(['pkill', '-f', 'frpc'], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except subprocess.CalledProcessError: pass
 
 def frp(configs, backstage):
     logging.info('-----------启动 FRP 内网穿透-------------')
     for config_data, config_file_path in configs:
-        with open(config_file_path, 'w') as config_file:
-            config_file.write(config_data)
-        frpc_cmd = ['/content/frp/frpc', '-c', config_file_path]
-        
-        if backstage:
-            subprocess.Popen(frpc_cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        else:
-            run_cmd(f'/content/frp/frpc -c {config_file_path}', quiet=True)
+        with open(config_file_path, 'w') as config_file: config_file.write(config_data)
+        if backstage: subprocess.Popen(['/content/frp/frpc', '-c', config_file_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        else: run_cmd(f'/content/frp/frpc -c {config_file_path}', quiet=True)
 
 def Run_SillyTavern():
-    """启动 Node 服务"""
     os.chdir(data_folder)
-    try:
-        run_cmd(f'yes | sh {data_folder}/start.sh', quiet=True)
-    except Exception as e:
-        logging.error(f"SillyTavern 启动失败: {e}")
+    try: run_cmd(f'yes | sh {data_folder}/start.sh', quiet=True)
+    except Exception as e: logging.error(f"SillyTavern 启动失败: {e}")
 
 def monitor_port():
     while True:
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            result = sock.connect_ex(('localhost', 8000))
-            if result != 0:
+            if sock.connect_ex(('localhost', 8000)) != 0:
                 config = configparser.ConfigParser()
                 config.read('/config.ini')
                 if config.getboolean('general', 'monitor_port_enabled', fallback=False):
@@ -474,20 +397,15 @@ def monitor_port():
 def setup_sillytavern():
     logging.info('-----------SillyTavern 基础数据部署开始-------------')
     os.makedirs(os.path.expanduser("~/.kaggle"), exist_ok=True)
-    with open('/root/.kaggle/kaggle.json', 'w') as json_file:
-        json.dump(ini_content, json_file, indent=4)
+    with open('/root/.kaggle/kaggle.json', 'w') as json_file: json.dump(ini_content, json_file, indent=4)
     run_cmd("chmod 600 ~/.kaggle/kaggle.json")
-
     run_cmd(f"rm -rf /a /sillytavern /*.zi* {data_folder}", ignore_errors=True, quiet=True)
     os.makedirs(data_folder, exist_ok=True)
     os.chdir('/')
     
-    download_n = 0
-    while download_n <= 6:
+    for _ in range(7):
         run_cmd(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /")
-        if os.path.exists(f'/{huggingface_Data_name}.zip'):
-            break
-        download_n += 1
+        if os.path.exists(f'/{huggingface_Data_name}.zip'): break
         time.sleep(5)
         
     if not os.path.exists(f'/{huggingface_Data_name}.zip'):
@@ -503,65 +421,61 @@ def setup_sillytavern():
     run_cmd("rm -f ip.py", quiet=True)
     run_cmd("wget -q -O /root/SillyTavern/ip.py https://huggingface.co/datasets/Qilan2/st-server/raw/main/ip.py")
     run_cmd("python /root/SillyTavern/ip.py", ignore_errors=True, quiet=True)
-    
     os.chdir(data_folder)
     run_cmd("nvm install node && nvm use node && npm install -y", quiet=True)
     run_cmd(f'yes | sh {data_folder}/start.sh', quiet=True)
-    
     threading.Thread(target=Run_SillyTavern, daemon=True).start()
 
 if __name__ == '__main__':
     # 1. 基础环境预热
     init_environment()
     kill_frpc_processes()
-    f(True)
+    setup_cloudflared(True)
     setup_ssh()
-    
     generate_ssh_key()
     copy_public_key_to_remote(cf_ssh, 22, "root", "qilan")
     
-    # 2. 在后台线程启动 ST 解压与下载任务
+    # 2. 启动 ST 解压与下载
     threading.Thread(target=setup_sillytavern, daemon=True).start()
     
     # 3. 智能等待基础数据就绪
-    logging.info("正在等待数据下载和解压，这可能需要几分钟，请耐心等待...")
+    logging.info("正在等待数据下载和解压，请耐心等待...")
     wait_seconds = 0
     while not os.path.exists(f'{data_folder}/start.sh'):
         time.sleep(5)
-        wait_seconds += 5
-        if wait_seconds > 1800:
+        if (wait_seconds := wait_seconds + 5) > 1800:
             logging.error("下载/解压超时（超过30分钟）！")
             break
             
     if os.path.exists(f'{data_folder}/start.sh'):
         logging.info("SillyTavern 基础文件已就绪！")
         
-        # 4. 执行核心双机接力逻辑 (同步旧数据覆盖本地)
+        # 4. 执行首次强制阻断同步
         sync_data_via_rsync()
+        
+        # 5. 开启后台持续增量同步线程！(每5分钟一次，防覆盖保护，直到旧机器关机)
+        threading.Thread(target=continuous_sync_task, daemon=True).start()
 
-        # 5. 替换登录页面显示接力时间与当前机器IP
+        # 6. 替换登录页面显示接力时间与当前机器IP
         replace_info_in_file(f'{data_folder}/public/login.html')
 
-    # 6. 配置环境收尾工作
+    # 7. 配置监控环境收尾
     config = configparser.ConfigParser()
     config.add_section('general')
     config.set('general', 'monitor_port_enabled', 'True')
-    with open('/config.ini', 'w') as configfile:
-        config.write(configfile)
-        
+    with open('/config.ini', 'w') as configfile: config.write(configfile)
     run_cmd("rm -rf /qilan-st9.zip /sillytavern.tar.gz", ignore_errors=True, quiet=True)
     
-    # 7. 启动常驻守护服务 (备份、FRP、穿透隧道、状态监控)
+    # 8. 启动常驻守护服务
     if os.path.exists(f'{data_folder}/start.sh'):
         backup_thread = threading.Thread(target=repeat_task, daemon=True)
         backup_thread.start()
         
         logging.info("前置任务全部完结！启动端口监控和网络穿透通道...")
         frp(configs, True)
-        f(False)
+        setup_cloudflared(False)
         threading.Thread(target=monitor_port, daemon=True).start()
         
-        # 存活守护循环
         while True:
             if not backup_thread.is_alive():
                 backup_thread = threading.Thread(target=repeat_task, daemon=True)