Update server3.py

server3.py

@@ -1,43 +1,38 @@
-ini_content = {"username":"xovale7506","key":"502e30bafc004c02aa668a279df23f3e"}
-frp_url = '8.219.240.86'
-ssh_port = '7074'
-st_url = f'http://{frp_url}:7073'
-config_data = f"""
-[common]
-server_addr = {frp_url}
-server_port = 7000
-
-[safgha22]
-type = tcp
-local_ip = 127.0.0.1
-local_port = 8000
-remote_port = 7073
-[safabf22]
-type = tcp
-local_ip = 127.0.0.1
-local_port = 22
-remote_port = {ssh_port}
-[saffg22]
-type = tcp
-local_ip = 127.0.0.1
-local_port = 3000
-remote_port = 7075
-"""
-config_data2 = """
-[common]
-server_addr = 120.26.228.135
-server_port = 7000
-
-[safghac22]
-type = tcp
-local_ip = 127.0.0.1
-local_port = 8000
-remote_port = 7073
-"""
-
+ini_content = {"username":"lixuhs875","key":"642ac670e3e0f7a237b53919592582c5"}
+frp_url = '119.8.118.149'
+ssh_port = '7072'
+ssh_url = '47.74.57.131'
+st_url = f'http://{frp_url}:7070'
+huggingface_name = 'lixuhs875'
+huggingface_Data_name = 'qilan-st1'
+configs = [
+    ("""
+    [common]
+    server_addr = 47.237.156.222
+    server_port = 7000
+
+    [sasfgha]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 8000
+    remote_port = 7080
+    
+    [sawfab2f]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 22
+    remote_port = 7082
+    
+    [saffghg]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 8000
+    remote_port = 7081
+    """, '/content/frp/frpc.ini')
+]
 kaggle_metadata = {
     "title": "Your Dataset Title",
-    "id": "xovale7506/sillytavern-data",
+    "id": f"{huggingface_name}/{huggingface_Data_name}",
     "licenses": [{"name": "CC0-1.0"}]
 }
 st_status = True
@@ -55,27 +50,51 @@ import pexpect
 import glob  # 导入 glob 模块
 from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
-
 os.system("rm -r /sync.sh")
 os.system("wget -O /sync.sh https://huggingface.co/datasets/Qilan2/st-server/resolve/main/sync.sh")
-
 os.system("export LC_ALL=zh_CN.UTF-8")
+os.system("mkdir -p /content/frp")
+os.system("wget /content/frp/frpc https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
+os.system("chmod +x /content/frp/frpc")
 # 更新软件包列表
+def is_installed(package):
+    """Check if a package is installed."""
+    try:
+        # Check if the package is installed using dpkg (for apt packages)
+        subprocess.run(['dpkg', '-s', package], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return True
+    except Exception as e:
+        return False
+
+def install_package(package):
+    """Install a package using apt."""
+    print(f"Installing {package}...")
+    os.system(f"sudo apt install {package} -y")
 def update():
     print('-----------更新软件包列表开始-------------')
-    os.system("sudo apt update")
+    # os.system("sudo apt update")
     # 安装 Node.js 和 npm
-    os.system("sudo apt install nodejs npm -y")
-    # 全局安装 forever
-    os.system("sudo npm install -g forever")
+    # os.system("sudo apt install nodejs npm -y")
+    # # 全局安装 forever
+    # os.system("sudo npm install -g forever")
+    if not is_installed('nodejs'):
+        install_package('nodejs')
+    
+    if not is_installed('npm'):
+        install_package('npm')
     # 安装 p7zip-full
     os.system("sudo apt install p7zip-full -y")
     os.system("pip install -U kaggle")
-    os.system("apt-get install inotify-tools")
-    os.system("pip install ruamel.yaml")
+    # os.system("apt-get install inotify-tools")
+    os.system("pip install ruamel.yaml") # install ruamel.yaml to solve the import issue
     os.system("pip install pexpect")
+    os.system("pip install pytz")
+    os.system('apt-get install pigz')
+    os.system('apt-get install pv')
     print('-----------更新软件包列表结束-------------')
 update()
+
+
 from ruamel.yaml import YAML
 clear_output(wait=True)  # 清除输出
 
@@ -153,8 +172,10 @@ import time
 
 # 创建一个锁
 lock = threading.Lock()
-data_folder = '/sillytavern/*'
-zip_file_path = '/a/sillytavern.zip'
+# data_folder = '/sillytavern/*'
+# zip_file_path = '/a/sillytavern.zip'
+data_folder = '/root/SillyTavern'  # 要压缩的目录
+zip_file_path = '/a/sillytavern.tar.gz'  # 输出的 tar.gz 文件路径
 metadata_file_path = '/a/dataset-metadata.json'
 last_uploaded_size = -1
 
@@ -162,14 +183,12 @@ def update_last_uploaded_size(size):
     global last_uploaded_size
     last_uploaded_size = size
 
-
-
 def compress_folder():
     global last_uploaded_size  # 声明使用全局变量
 
     # 清理并创建目录 /a
     if os.path.exists('/a'):
-        subprocess.run(['rm', '-r', '/a'])
+        subprocess.run(['rm', '-r', '/a/'])
 
     os.makedirs('/a', exist_ok=True)
 
@@ -179,26 +198,40 @@ def compress_folder():
             return
         
         print('开始压缩数据')
-        result = subprocess.run(['7z', 'a', '-tzip', '-mx=1','-mmt=2', zip_file_path, data_folder])
+        #result = subprocess.run(['7z', 'a', '-tzip', '-mx=1','-mmt=2', zip_file_path, data_folder])
         # 7z a -tzip -mx=1 -mmt=2 /a/sillytavern.zip /sillytavern/*
+        # tar -cvf - /sillytavern | pigz -p 6 -1 > /a/sillytavern.tar.gz
+        try:
+            result = subprocess.run(
+            f'tar -cvf - {data_folder} | pigz -p 2 -1 > {zip_file_path} 2> /dev/null',
+            shell=True,
+            check=True,
+            stdout=subprocess.DEVNULL,  # 将标准输出重定向到 /dev/null
+            stderr=subprocess.DEVNULL   # 将标准错误也重定向到 /dev/null
+            )
+        except subprocess.CalledProcessError as e:
+            print(f"Command failed with return code {e.returncode}")
+
         print('重命名压缩后的文件')
-        file_path = '/a/sillytavern.zip1'
+        file_path = "/a/sillytavern.ctk"
+        print(zip_file_path)
+        
         subprocess.run(['mv', zip_file_path,file_path])
         if result.returncode != 0:
             print("压缩失败，请检查7z命令是否正确")
             return
-        
+
         print(f"Data compressed into {file_path}")
         
         file_size = os.path.getsize(file_path)  # 获取压缩包的大小
         print('文件大小:', file_size, '上次文件大小：', last_uploaded_size,file_size * 1024 ** 2)
         
         # 判断是否大于800MB (800MB = 800 * 1024 * 1024 字节)
-        if file_size < (800 * 1024 ** 2):  
+        if file_size < (400 * 1024 ** 2):  
             print("文件小于800MB，不进行上传。")
             return
         
-        if last_uploaded_size == -1 or file_size > last_uploaded_size:
+        if last_uploaded_size == -1 or file_size != last_uploaded_size:
             # 判断是否为首次运行或上次上传大小为0
             if last_uploaded_size == -1:
                 print("首次运行，正在执行上传...")
@@ -206,8 +239,8 @@ def compress_folder():
 
                 with open(metadata_file_path, 'w') as json_fid:
                     json.dump(kaggle_metadata, json_fid)
-
-                subprocess.run(['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'])
+                os.system("kaggle datasets version -m 'new version message' -p /a")
+                #subprocess.run(['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'])
                 # kaggle datasets version -m 'new version message' -p /a
                 last_uploaded_size = file_size
             
@@ -229,7 +262,7 @@ def repeat_task():
     print('------打包线程启动-------------')
     while True:
         print('等待打包')
-        time.sleep(600)
+        time.sleep(1200)
         compress_folder()
     print('------打包线程结束-------------')
 # repeat_task()
@@ -271,11 +304,26 @@ def copy_public_key_to_remote(host, port, user, password):
 
 # 生成 SSH 密钥对
 generate_ssh_key()
-
-# 复制公钥到远程服务器
-copy_public_key_to_remote(frp_url, ssh_port, "root", "qilan")
+os.system('chmod 600 ~/.ssh/id_rsa')
+# # 复制公钥到远程服务器
+copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
  
-
+def write_rsyncd_conf(path, port=7071):
+    rsyncd_conf_content = f"""
+port = {port}
+[qilan]
+    path = {path}
+    comment = My rsync module
+    read only = no
+    list = yes
+"""
+    with open('/etc/rsyncd.conf', 'w') as f:
+        f.write(rsyncd_conf_content.strip())
+    print(f"Successfully wrote to /etc/rsyncd.conf for module .")
+    
+write_rsyncd_conf(data_folder)
+os.system("sudo rsync --daemon")
+os.system("ps aux | grep rsync")
 
 def requests_retry_session(retries=3, backoff_factor=0.3, status_forcelist=(500, 502, 504), session=None):
     """创建一个带重试机制的请求会话"""
@@ -286,102 +334,111 @@ def requests_retry_session(retries=3, backoff_factor=0.3, status_forcelist=(500,
     session.mount('https://', adapter)
     return session
 
+import os
+import time
+import requests
+import subprocess
+import logging
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+
 def check_api1():
     # 第一次检查 SillyTavern 是否启动
-    thread_started = False  # 在函数内初始化标志变量
-    n=0
+    thread_started = False
+    n = 0
     while True:
-        n = n + 1
-        if st_status == False and n > 50:
-            print("/sillytavern 文件不存在，结束检测")
+        n += 1
+        if not os.path.exists(data_folder):
+            logging.error(f"/sillytavern/ 文件不存在，结束检测")
             break
         try:
             url = "http://127.0.0.1:8000/v1"
             response = requests.get(url, timeout=30)
 
-            # 检查响应状态码
             if response.status_code == 403:
-                print("SillyTavern已经启动")
-                break  # 接口正常，退出循环
+                logging.info("SillyTavern已经启动")
+                break
             
-            # 如果不是 403，打印其他信息
-            print("SillyTavern未启动，状态码:", response.status_code)
+            logging.info("SillyTavern未启动，状态码:", response.status_code, n)
 
         except requests.exceptions.RequestException as e:
-            print(f"SillyTavern未启动3: {e}")  # 打印具体错误信息
+            logging.error(f"SillyTavern未启动3: {e}, 尝试次数: {n}")
         
-        time.sleep(5)  # 等待5秒后重试
+        time.sleep(5)
     
-    print('开始检测接口状态')
+    logging.info('开始检测接口状态')
     Service_status = False
-    # 第二次检查接口状态
     n = 0
+    nn = 0
     while True:
-        n = n + 1
-        if st_status == False and n > 50:
-            print("/sillytavern 文件不存在，结束检测")
+        n += 1
+        if not os.path.exists(data_folder):
+            logging.error(f"/sillytavern/ 文件不存在，结束检测")
             break
         if Service_status:
-            print("结束检测")
+            logging.info("结束检测")
             break
-        url = f"{st_url}/csrf-token"  # 确保这个 URL 是正确的   
+        url = f"{st_url}/csrf-token"
         try:
             response = requests_retry_session().get(url, timeout=30)
-            response.raise_for_status()  # 检查响应状态
-            # 尝试解析 JSON 响应
-            response_json = response.json()  # 获取 JSON 内容
-            print(url,"接口返回信息：", response_json)
+            response.raise_for_status()
+            response_json = response.json()
+            logging.info("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
             if "token" in response_json:
-                print("检测到 token")
-                # try:
-                #     subprocess.run(f"rsync -avz -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{frp_url}:/sillytavern/ /sillytavern/", shell=True, check=True)
-                # except subprocess.CalledProcessError as e:
-                #     print(f"Rsync failed with return code: {e.returncode}")
-                #     print(f"Command output: {e.output}")
-                # # subprocess.run(f"rsync -avz -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{frp_url}:/sillytavern/ /sillytavern/", shell=True, check=True)
-                subprocess.run(f"sh /sync.sh -p {ssh_port} -s {frp_url}", shell=True, check=True)
-                break  # 跳出循环
+                logging.info("检测到 token")
+                nn = 0
+                retry_count = 3  # 设置重试次数
+                for attempt in range(retry_count):
+                    try:
+                        
+                        subprocess.run(f"rsync -avz -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/", 
+                                       shell=True, check=True, timeout=300)
+                        break  # 如果成功，跳出重试循环
+                    except subprocess.CalledProcessError as e:
+                        logging.error(f"Rsync 失败，返回码: {e.returncode}, 尝试次数: {attempt + 1}")
+                        if attempt == retry_count - 1:
+                            logging.error("所有重试均失败，停止尝试。")
+                            generate_ssh_key()  # 处理 SSH 密钥生成
             else:
-                print("接口返回信息：", response_json)
-        
+                logging.info("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
         except requests.exceptions.ConnectionError as e:
-            print(f"接口异常1: {e}")
-            # threading.Thread(target=Frpc, daemon=True).start()
-            break
-        
+            logging.error(f"接口异常1: {e}, 尝试次数: {n}, nn: {nn}")
+            nn += 1
+            if nn > 10:
+                break
         except requests.exceptions.Timeout as e:
-            print(f"接口异常2: {e}")
-            # threading.Thread(target=Frpc, daemon=True).start()
+            logging.error(f"接口异常2: {e}, 尝试次数: {n}")
             break
-            
         except requests.exceptions.RequestException as e:
-           print(f"接口异常3: {e}")
-           # threading.Thread(target=Frpc, daemon=True).start()
-           break
+            logging.error(f"接口异常3: {e}, 尝试次数: {n}")
+            break
         
-        time.sleep(5)  # 等待5秒后重试
-
-
-def frp(config_data1,config_file_path,backstage):
-    print('-----------FRP开始-------------')
-    '''FRP配置'''
-    os.system("mkdir -p /content/frp")
-    os.system("wget /content/frp/frpc https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
-    os.system("chmod +x /content/frp/frpc")
-    # config_file_path = '/content/frp/frpc.ini'
-    with open(config_file_path, 'w') as config_file:
-        config_file.write(config_data1)
-    # frpc 启动命令和参数
-    frpc_cmd = ['/content/frp/frpc', '-c', config_file_path]
-    if backstage:
-        subprocess.Popen(frpc_cmd)
-    else:
-        subprocess.run(f'/content/frp/frpc -c {config_file_path}', shell=True, check=True)
-    print('-----------FPR结束-------------')
-    # /content/frp/frpc -c /content/frp/frpc.ini
-    
+        time.sleep(5)
+
+
+def frp(configs, backstage):
+     print('-----------FRP开始-------------')
+     # 遍历所有配置并启动 FRP。
+     for config_data, config_file_path in configs:
+         with open(config_file_path, 'w') as config_file:
+             config_file.write(config_data)
+         
+         # 启动 frpc 命令和参数。
+         frpc_cmd=['/content/frp/frpc', '-c', config_file_path]
+
+         if backstage:
+             subprocess.Popen(frpc_cmd)
+         else:
+             subprocess.run(f'/content/frp/frpc -c {config_file_path}', shell=True, check=True)
+
+     print('-----------FRP结束-------------')
+   
 import requests
 import re
+from datetime import datetime, timedelta
+import psutil  # 用于获取系统启动时间
+import pytz  # 用于处理时区
 
 def get_current_ip():
     """获取当前公共 IP 地址"""
@@ -398,7 +455,7 @@ def get_geo_info(ip_address):
     response = requests.get(url, headers=headers)
     
     if response.status_code == 200:
-        geo_info = response.json()  # 解析为 JSON 格式
+        geo_info = response.json()
         
         if geo_info['code'] == 200:
             data = geo_info['data']
@@ -407,52 +464,94 @@ def get_geo_info(ip_address):
                 'country': data['country'],
                 'isp': data['isp']
             }
-        else:
-            print("无法获取地理位置信息")
-            return None
-    else:
-        print(f"请求失败, 状态码: {response.status_code}")
-        return None
-
-def replace_ip_and_country_in_file(file_path):
+    return None
+
+def get_next_relay_time():
+    """获取下一次接力时间（系统启动时间+12小时，转换为中国时区）"""
+    # 获取系统启动时间
+    boot_time = datetime.fromtimestamp(psutil.boot_time())
+    # 设置为UTC时区
+    utc = pytz.UTC
+    boot_time = utc.localize(boot_time)
+    # 转换为中国时区
+    china_tz = pytz.timezone('Asia/Shanghai')
+    boot_time_china = boot_time.astimezone(china_tz)
+    # 加上12小时
+    next_time = boot_time_china + timedelta(hours=12)
+    return next_time.strftime("%Y-%m-%d %H:%M:%S")
+
+def replace_info_in_file(file_path):
     try:
-        # 获取当前 IP 地址
+        # 获取当前 IP 地址和地理信息
         ip_address = get_current_ip()
-        print(f"获取到当前 IP: {ip_address}")
-        
-        # 获取地理位置信息
         geo_info = get_geo_info(ip_address)
+        next_relay_time = get_next_relay_time()
         
         if geo_info is not None:
-            print(f"获取到地理信息: {geo_info}")
-            
             # 读取文件内容
             with open(file_path, 'r', encoding='utf-8') as file:
                 content = file.read()
-                # print(f"读取到的文件内容: {content}")
             
-            # 使用正则表达式匹配 "IP[xxx]国家[yyy]" 的格式
-            pattern = r'IP\[.*?\]国家\[.*?\]'
-            replacement = f'机子IP[{geo_info["ip"]}]国家[{geo_info["country"]}] ISP[{geo_info["isp"]}]'
-            new_content = re.sub(pattern, replacement, content)
+            # 替换接力时间
+            time_pattern = r'接力时间\[.*?\]'
+            time_replacement = f'接力时间[{next_relay_time}]'
+            content = re.sub(time_pattern, time_replacement, content)
             
-            # print(f"替换后的内容: {new_content}")
+            # 替换 IP 信息
+            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(new_content)
+                file.write(content)
             
-            print(f"成功更新为: IP[{geo_info['ip']}] 国家[{geo_info['country']}] ISP[{geo_info['isp']}]")
+            print(f"成功更新信息：")
+            print(f"接力时间: {next_relay_time}")
+            print(f"IP信息: IP[{ip_address}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
     
-    except FileNotFoundError:
-        print(f"错误: 文件 {file_path} 不存在。")
-    except IOError as e:
-        print(f"IO 错误: {e}")
     except Exception as e:
-        print(f"发生其他错误: {e}")
-
+        print(f"发生错误: {e}")
 
+import socket
+import subprocess
+import time
 
+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:
+                print(f"端口 8000 正在使用中")
+            else:
+                print(f"端口 8000 未被使用")
+                backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
+                backup_thread.start()
+                # 启动脚本并在后台运行
+                # try:
+                #     os.chdir(data_folder)
+                #     process = subprocess.Popen(f'node "server.js" "$@"', shell=True)
+                #     print(f"已尝试启动 {data_folder }/start.sh")
+                #     # time.sleep(20)
+                # except Exception as e:  # 捕获所有异常
+                #     print(f"命令失败: {e}")
+        
+        time.sleep(5)  # 每5秒检查一次
+def Run_SillyTavern():
+    os.chdir(data_folder)
+    # subprocess.run(f'node "server.js" "$@"', shell=True, check=True)
+    try:
+        # 启动 Node.js 服务器，并将输出重定向到 /dev/null
+        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        print("已尝试启动 server.js")
+    except subprocess.CalledProcessError as e:
+        print(f"命令失败，返回码: {e.returncode}")
+    except Exception as e:  # 捕获所有其他异常
+        print(f"发生异常: {e}")
 def SillyTavern():
     print('-----------SillyTavern开始-------------')
     # 创建目录并写入 kaggle.json
@@ -464,68 +563,90 @@ def SillyTavern():
 
     clear_output()
 
-    os.system("rm -r /a /sillytavern /*.zi* /SillyTavern/")
-    os.system("mkdir -p /sillytavern")
+    os.system(f"rm -r /a /sillytavern /*.zi* {data_folder}")
+    os.system(f"mkdir -p {data_folder}")
     os.chdir('/')
-    os.system("kaggle datasets download xovale7506/sillytavern-data")
+    print(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
+    # os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
+    while True:
+        # 执行下载命令
+        os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /")
+        # 检查文件是否存在
+        if os.path.exists(f'/{huggingface_Data_name}.zip'):
+            print(f"{huggingface_Data_name}.zip 下载成功！")
+            break  # 跳出循环
+    
+        print(f"{huggingface_Data_name}.zip 下载失败，正在重试...")
+    
+        time.sleep(5)  # 等待一段时间再重试（例如5秒
+    # os.system('kaggle datasets download xovale7506/sillytavern-data2')
     # 检查文件是否存在
-    if not os.path.exists('/sillytavern-data.zip'):
-        print(f"文件 /sillytavern-data.zip 不存在，程序将结束。")
-        st_status = False
-    # 如果文件存在，可以继续执行后续代码
-    print(f"文件 /sillytavern-data.zip 存在，继续执行程序。")
+    if not os.path.exists(f'/{huggingface_Data_name}.zip'):
+        print(f"文件 /{huggingface_Data_name}.zip 不存在，启用实时同步。")
+        generate_ssh_key()
+        copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
+        subprocess.run(f"rsync -avz -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/", shell=True, check=True)
+        # subprocess.run(f"rsync -avz --port=7075 ljj@{frp_url}::qilan {data_folder}/", shell=True, check=True)
+        # sys.exit()
+    else:
+        
+        # 如果文件存在，可以继续执行后续代码
+        print(f"文件 /{huggingface_Data_name}.zip 存在，继续执行程序。")
     # # 解压 sillytavern.zip
-    os.system("7z x /sillytavern-data.zip -o/ -y")
-    os.system("mv /sillytavern.zip1 /sillytavern.zip")
-    os.system("7z x /sillytavern.zip -o/sillytavern -y")
-    os.system("rm *.zip")
-    clear_output()
+        # os.system("rm *.zip")
+        os.system("ls /")
+        os.system(f"7z x /{huggingface_Data_name}.zip -o/ -y")
+        # os.system("mv /sillytavern.zip1 /sillytavern.zip")
+        # os.system("7z x /sillytavern.zip -o/sillytavern -y")
+        os.system("mv /sillytavern.tck sillytavern.tar.gz")
+        os.system("mv /sillytavern.ctk sillytavern.tar.gz")
+        # os.system("tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz")
+        os.system(f"tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null")
+        # os.system("pv /sillytavern.tar.gz | tar -xvpf - -C / --use-compress-program=pigz")
 
-    # # 拉取最新版本
-    # !git clone https://github.com/SillyTavern/SillyTavern.git
-    # 强制替换掉备份
-    # !rsync -a --delete /SillyTavern/* /sillytavern/
-    
-    
-    # threading.Thread(target=Oneapi, daemon=True).start()
-    os.chdir('/sillytavern')
-    replace_ip_and_country_in_file('/sillytavern/public/login.html')
-    os.system("ls")
-    os.system("nvm install node")
-    os.system("nvm use node")
-    os.system("npm install -y")
-    try:
-        subprocess.run('yes | sh /sillytavern/start.sh', shell=True, check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Command '{e.cmd}' returned non-zero exit status {e.returncode}.")
-        print("Output:", e.output)
-    os.chdir('/sillytavern')
-    subprocess.run('yes | sh /sillytavern/start.sh', shell=True, check=True)
-    subprocess.run('yes | sh /sillytavern/start.sh', shell=True, check=True)
-    subprocess.run('yes | sh /sillytavern/start.sh', shell=True, check=True)
-    subprocess.run('yes | sh /sillytavern/start.sh', shell=True, check=True)
-    print('-----------SillyTavern结束-------------')
-    # os.system("yes | sh start.sh -y")
-
-    # commands = [
-    #     'yes | sh start.sh -y'
-    # ]
-    # run_commands(commands)    
+        
+        os.chdir(data_folder)
+        os.system(f"ls {data_folder}")
+        os.system("nvm install node")
+        os.system("nvm use node")
+        os.system("npm install -y")
+        try:
+            subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Command '{e.cmd}' returned non-zero exit status {e.returncode}.")
+            print("Output:", e.output)
+        os.system(f"ls {data_folder}")
+        print('更新文件')
+        os.system('git pull --rebase --autostash')
+        backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
+        backup_thread.start()
+        # subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
+        # subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
+        # subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
+        # subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
+    print('-----------SillyTavern结束-------------')  
 threading.Thread(target=SillyTavern, daemon=True).start()
+time.sleep(60)
 check_api1()
-if not os.path.exists('/sillytavern-data.zip'):
+os.system("rm -r /qilan-st2.zip /sillytavern.tar.gz")
+if os.path.exists(f'{data_folder}/start.sh'):
+    replace_info_in_file(f'{data_folder}/public/login.html')
     # threading.Thread(target=repeat_task, daemon=True).start() #压缩备份
     # backup_thread = threading.Thread(target=repeat_task, daemon=True)
-    # backup_thread.start()
+    backup_thread.start()
     print("开始衔接")
     Service_status = True
+    frp(configs, True)
     # frp(config_data2,'/content/frp/frpc2.ini',True)
-    # frp(config_data,'/content/frp/frpc.ini',False)
+    # frp(config_data,'/content/frp/frpc.ini',True)
+    # frp(config_data3,'/content/frp/frpc3.ini',True)
+    # frp(config_data4,'/content/frp/frpc4.ini',True)
     # 以线程的形式运行 frp 任务
-    frp_thread1 = threading.Thread(target=frp, args=(config_data2, '/content/frp/frpc2.ini', True))
-    frp_thread1.start()
-    frp_thread2 = threading.Thread(target=frp, args=(config_data, '/content/frp/frpc.ini', False))
-    frp_thread2.start()
+    # frp_thread1 = threading.Thread(target=frp, args=(config_data2, '/content/frp/frpc2.ini', True))
+    # frp_thread1.start()
+    # frp_thread2 = threading.Thread(target=frp, args=(config_data, '/content/frp/frpc.ini', False))
+    # frp_thread2.start()
+    threading.Thread(target=monitor_port, daemon=True).start()#检测端口状态
     while True:
         if backup_thread.is_alive():
             print("备份线程仍在运行...")
@@ -534,15 +655,8 @@ if not os.path.exists('/sillytavern-data.zip'):
             # backup_thread = threading.Thread(target=repeat_task, daemon=True)
             # backup_thread.start()
             # break
-        try:
-            # 检查 /sillytavern/start.sh 是否在运行
-            subprocess.check_output(['pgrep', '-f', '/sillytavern/start.sh'])
-            # print("脚本正在运行。")
-        except subprocess.CalledProcessError:
-            print("脚本未运行。退出循环。")
-            compress_folder()
-            break
         time.sleep(5)
 
 else:
-    print("/sillytavern 文件不存在结束执行")
+    print("/sillytavern 文件不存在结束执行")
+compress_folder()