Update server6.py

server6.py

@@ -1,9 +1,9 @@
-ini_content = {"username":"hdsg142saa","key":"2da57ac0c245c1ebba26017f161d5558"}
+ini_content = {"username":"ighlnvd551","key":"14dee8c2e790b386ca7a61e974537d66"}
 frp_url = '119.8.118.149'
 ssh_port = '7079'
 ssh_url = '43.135.135.22'
 st_url = f'http://{frp_url}:7077'
-huggingface_name = 'hdsg142saa'
+huggingface_name = 'ighlnvd551'
 huggingface_Data_name = 'qilan-st5'
 configs = [
     ("""
@@ -11,13 +11,13 @@ configs = [
     server_addr = 47.237.156.222
     server_port = 7000
 
-    [safsa666]
+    [safsa66]
     type = tcp
     local_ip = 127.0.0.1
     local_port = 8000
     remote_port = 7082
     
-    [sascb2f666]
+    [sascb2f66]
     type = tcp
     local_ip = 127.0.0.1
     local_port = 22
@@ -32,38 +32,38 @@ configs = [
     type = tcp
     local_ip = 127.0.0.1
     local_port = 8000
-    remote_port = 7077
+    remote_port = 7076
     """, '/content/frp/frpc1.ini'),
-   #  ("""
-   #  [common]
-   #  server_addr = 47.237.78.158
-   #  server_port = 7000
-   #  [kjas2]
-   #  type = tcp
-   #  local_ip = 127.0.0.1
-   #  local_port = 8000
-   #  remote_port = 7075
-   #  """, '/content/frp/frpc2.ini'),
-   # ("""
-   # [common]
-   # server_addr = 45.94.69.159
-   # server_port = 7000
-   # [kja1sh5]
-   # type = tcp
-   # local_ip = 127.0.0.1
-   # local_port = 8000
-   # remote_port = 7075
-   # """, '/content/frp/frpc3.ini'),
-   # ("""
-   # [common]
-   # server_addr = 43.128.135.88
-   # server_port=7000 
-   # [kkji1mk5] 
-   # type=tcp 
-   # local_ip=127.0.0.1
-   # local_port=8000 
-   # remote_port=7075
-   #   """, '/content/frp/frpc4.ini'),
+    ("""
+    [common]
+    server_addr = 47.237.78.158
+    server_port = 7000
+    [kjas6]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 8000
+    remote_port = 7075
+    """, '/content/frp/frpc2.ini'),
+   ("""
+   [common]
+   server_addr = 45.94.69.159
+   server_port = 7000
+   [kja1sh6]
+   type = tcp
+   local_ip = 127.0.0.1
+   local_port = 8000
+   remote_port = 7075
+   """, '/content/frp/frpc3.ini'),
+   ("""
+   [common]
+   server_addr = 43.128.135.88
+   server_port=7000 
+   [kkji1mk6] 
+   type=tcp 
+   local_ip=127.0.0.1
+   local_port=8000 
+   remote_port=7075
+     """, '/content/frp/frpc4.ini'),
    (f"""
    [common]
    server_addr = {ssh_url}
@@ -84,6 +84,7 @@ st_status = True
 import subprocess
 import os
 import sys
+import configparser
 from IPython.display import clear_output
 import urllib.request
 from pathlib import Path
@@ -92,16 +93,18 @@ import json
 import threading
 import time
 import pexpect
+import socket
+import time
 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")
+# 创建 FRP 文件夹并下载 frpc 可执行文件。
 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."""
@@ -115,7 +118,7 @@ def is_installed(package):
 def install_package(package):
     """Install a package using apt."""
     print(f"Installing {package}...")
-    os.system(f"sudo apt install {package} -y  > /dev/null 2>&1")
+    os.system(f"sudo apt install {package} -y")
 def update():
     print('-----------更新软件包列表开始-------------')
     # os.system("sudo apt update")
@@ -128,18 +131,17 @@ def update():
     
     if not is_installed('npm'):
         install_package('npm')
-    os.system("pip install -U kaggle > /dev/null 2>&1")   
+    # 安装 p7zip-full
+    os.system("sudo apt install p7zip-full -y")
+    os.system("pip install -U kaggle")
     os.system("pip uninstall -y kaggle > /dev/null 2>&1")    
-    os.system("pip install kaggle==1.5.6 > /dev/null 2>&1")
-    # os.system("apt-get install inotify-tools > /dev/null 2>&1")
-    os.system("pip install ruamel.yaml > /dev/null 2>&1")  # install ruamel.yaml to solve the import issue
-    os.system("pip install pexpect > /dev/null 2>&1")
-    os.system("pip install pytz > /dev/null 2>&1")
-    os.system('pip install paramiko > /dev/null 2>&1')
-    os.system('apt-get install pigz -y > /dev/null 2>&1')
-    os.system('apt-get install pv -y > /dev/null 2>&1')
-    os.system("sudo apt install p7zip-full -y > /dev/null 2>&1")
-
+    os.system("pip install kaggle==1.5.6 > /dev/null 2>&1") 
+    # 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()
 
@@ -157,6 +159,7 @@ def kill_frpc_processes():
         print(f"结束frpc进程时出错: {e}")
 kill_frpc_processes()
 
+
 # SSH
 def run_command(command):
     try:
@@ -184,89 +187,87 @@ def ssh():
 ssh()
 clear_output()
 
-import json
-import os
-import subprocess
-import threading
-import time
+
 
 # 创建一个锁
 lock = threading.Lock()
-# 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
 
+
 def update_last_uploaded_size(size):
     global last_uploaded_size
     last_uploaded_size = size
 
+def get_folder_size(folder):
+    """使用 du 命令获取文件夹的总大小（字节数）"""
+    result = subprocess.run(['du', '-sb', folder], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode == 0:
+        size = result.stdout.split()[0]  # 获取大小
+        return int(size)
+    else:
+        print(f"Error calculating size: {result.stderr.decode()}")
+        return 0
+
 def compress_folder():
     global last_uploaded_size  # 声明使用全局变量
-
     # 清理并创建目录 /a
     if os.path.exists('/a'):
         subprocess.run(['rm', '-r', '/a/'])
-
     os.makedirs('/a', exist_ok=True)
-
     with lock:  # 使用锁
-        if os.path.exists(zip_file_path):
-            print(f"压缩文件 {zip_file_path} 已存在，跳过本次压缩。")
-            return
-        
-        print('开始压缩数据')
-        #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}")
+        # 获取当前文件夹的大小
+        current_folder_size = get_folder_size(data_folder)
+        print(f"当前文件夹大小: {current_folder_size} 字节")
 
-        print('重命名压缩后的文件')
-        file_path = "/a/sillytavern.ctk"
-        print(zip_file_path)
-        
-        subprocess.run(['mv', zip_file_path,file_path])
-        if result.returncode != 0:
-            print("压缩失败，请检查7z命令是否正确")
+        # 判断文件夹大小是否大于 800MB (800MB = 800 * 1024 * 1024 字节)
+        if current_folder_size < (800 * 1024 ** 2):
+            print("文件夹小于800MB，不进行上传和压缩。")
             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 < (400 * 1024 ** 2):  
-            print("文件小于800MB，不进行上传。")
-            return
-        
-        if last_uploaded_size == -1 or file_size != last_uploaded_size:
-            # 判断是否为首次运行或上次上传大小为0
+        # 如果是首次运行或者文件夹大小不同于上次上传，进行压缩
+        if last_uploaded_size == -1 or current_folder_size != last_uploaded_size:
+            print('开始压缩数据')
+            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"命令失败，返回代码: {e.returncode}")
+                return
+
+            print('压缩完成')
+            file_path = "/a/sillytavern.ctk"
+            subprocess.run(['mv', zip_file_path, file_path])
+            print(f"数据压缩为 {file_path}")
+
+            file_size = os.path.getsize(file_path)  # 获取压缩包的大小
+            print('文件大小:', file_size)
+
+            if file_size < (800 * 1024 ** 2):  # 判断压缩后的大小是否小于 800MB
+                print("压缩文件小于800MB，不进行上传。")
+                return
+
+            # 执行上传
             if last_uploaded_size == -1:
                 print("首次运行，正在执行上传...")
-                update_last_uploaded_size(file_size)  # 更新为当前文件大小
+                update_last_uploaded_size(file_size)
 
                 with open(metadata_file_path, 'w') as json_fid:
                     json.dump(kaggle_metadata, json_fid)
-                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
+
+                subprocess.run(['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'])
                 last_uploaded_size = file_size
-            
-            elif file_size > last_uploaded_size:
-                print(f"新文件 {zip_file_path} 大于上次上传的大小，正在执行上传...")
-                update_last_uploaded_size(file_size)  # 更新元数据中的最后一次上传大小
+            else:
+                print(f"新文件大小 {file_size} 大于上次上传的大小，正在执行上传...")
+                update_last_uploaded_size(file_size)
 
                 with open(metadata_file_path, 'w') as json_fid:
                     json.dump(kaggle_metadata, json_fid)
@@ -275,21 +276,19 @@ def compress_folder():
                 last_uploaded_size = file_size
             
         else:
-            print(f"新文件 {zip_file_path} 不大于上次上传的大小，跳过")
-
+            print(f"新文件夹大小 {current_folder_size} 不大于上次上传的大小，跳过")
 
 def repeat_task():
     print('------打包线程启动-------------')
     while True:
         print('等待打包')
         time.sleep(18000)
-        # compress_folder()
+        compress_folder()
     print('------打包线程结束-------------')
+# repeat_task()
+# compress_folder()
 
 
-import os
-import subprocess
-import pexpect
 
 def generate_ssh_key():
     # 生成 SSH 密钥对，并捕获输出和错误信息
@@ -324,12 +323,24 @@ def copy_public_key_to_remote(host, port, user, password):
 # 生成 SSH 密钥对
 generate_ssh_key()
 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):
+
+
+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)
+    session.mount('http://', adapter)
+    session.mount('https://', adapter)
+    return session
+
+def write_rsyncd_conf(path, port=7075):
     rsyncd_conf_content = f"""
 port = {port}
+
 [qilan]
     path = {path}
     comment = My rsync module
@@ -339,44 +350,19 @@ port = {port}
     with open('/etc/rsyncd.conf', 'w') as f:
         f.write(rsyncd_conf_content.strip())
     print(f"Successfully wrote to /etc/rsyncd.conf for module .")
+    os.system("sudo rsync --daemon")
+    os.system("sudo rsync --daemon")
+    os.system("sudo rsync --daemon")
+    os.system("sudo rsync --daemon")
     
-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):
-    """创建一个带重试机制的请求会话"""
-    session = session or requests.Session()
-    retry = Retry(total=retries, backoff_factor=backoff_factor, status_forcelist=status_forcelist)
-    adapter = HTTPAdapter(max_retries=retry)
-    session.mount('http://', adapter)
-    session.mount('https://', adapter)
-    return session
-
+# write_rsyncd_conf(data_folder)
+# os.system("ps aux | grep rsync")
 import os
 import time
 import requests
 import subprocess
 import logging
 
-import paramiko
-
-def check_ssh_connection(host, port, username, password):
-    try:
-        client = paramiko.SSHClient()
-        # 允许连接到不在 known_hosts 中的主机
-        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        # 尝试连接
-        client.connect(hostname=host, port=port, username=username, password=password)
-        client.close()
-        return True
-    except Exception as e:
-        print(f"SSH 连接失败: {e}")
-        return False
-
-
-
-
 # 配置日志
 logging.basicConfig(level=logging.INFO)
 
@@ -427,7 +413,6 @@ def check_api1():
             if "token" in response_json:
                 print("检测到 token")
                 try:  
-                    print(f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/")
                     subprocess.run(f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",shell=True, check=True)
                     # break  # 如果成功，跳出重试循环
                 except subprocess.CalledProcessError as e:
@@ -452,13 +437,14 @@ def check_api1():
         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]
 
@@ -466,9 +452,8 @@ def frp(configs, 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
@@ -548,9 +533,6 @@ def replace_info_in_file(file_path):
     except Exception as e:
         print(f"发生错误: {e}")
 
-import socket
-import subprocess
-import time
 
 def monitor_port():
     while True:
@@ -560,14 +542,20 @@ def monitor_port():
                 print(f"端口 8000 正在使用中")
             else:
                 print(f"端口 8000 未被使用")
-                backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
-                backup_thread.start()
+                # 读取 config.ini 中的 monitor_port_enabled 配置项
+                config = configparser.ConfigParser()
+                config.read('/config.ini')
+                monitor_port_enabled = config.getboolean('general', 'monitor_port_enabled', fallback=False)
+                if monitor_port_enabled:
+                    backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
+                    backup_thread.start()
+                else:
+                    print(f"monitor_port_enabled 为False跳过")
+        
         time.sleep(5)  # 每5秒检查一次
 def Run_SillyTavern():
-    
-    # subprocess.run(f'node "server.js" "$@"', shell=True, check=True)
+    os.chdir(data_folder)
     try:
-        os.chdir(data_folder)
         # 启动 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)
@@ -576,9 +564,10 @@ def Run_SillyTavern():
         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"Run_SillyTavern命令失败，返回码: {e.returncode}")
+        print(f"命令失败，返回码: {e.returncode}")
     except Exception as e:  # 捕获所有其他异常
-        print(f"Run_SillyTavern发生异常: {e}")
+        print(f"发生异常: {e}")
+
 def SillyTavern():
     print('-----------SillyTavern开始-------------')
     # 创建目录并写入 kaggle.json
@@ -593,161 +582,85 @@ def SillyTavern():
     os.system(f"rm -r /a /sillytavern /*.zi* {data_folder}")
     os.system(f"mkdir -p {data_folder}")
     os.chdir('/')
-    print(f"开始下载 kaggle 数据集 {huggingface_name}/{huggingface_Data_name}")
-    
-    # 改进的下载逻辑
+    print(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
+    # os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
     download_n = 0
-    max_retries = 5  # 修改为5次尝试
-    download_success = False
-    
-    while download_n < max_retries:
-        try:
-            # 使用subprocess.run捕获命令的输出和错误
-            result = subprocess.run(
-                f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /",
-                shell=True,
-                check=False,  # 不要在失败时抛出异常
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            
-            # 检查文件是否存在
-            if os.path.exists(f'/{huggingface_Data_name}.zip'):
-                print(f"{huggingface_Data_name}.zip 下载成功！")
-                download_success = True
-                break  # 跳出循环
-            
-            # 输出错误信息
-            print(f"下载尝试 {download_n+1}/{max_retries} 失败")
-            if result.stderr:
-                print(f"错误信息: {result.stderr.decode('utf-8', errors='replace')}")
-                
-            download_n += 1
-            
-            if download_n < max_retries:
-                wait_time = 60  # 减少等待时间以加快失败后的切换
-                print(f"等待 {wait_time} 秒后重试...")
-                time.sleep(wait_time)
-            
-        except Exception as e:
-            print(f"下载过程中发生错误: {str(e)}")
-            download_n += 1
-            if download_n < max_retries:
-                print(f"等待 60 秒后重试...")
-                time.sleep(60)
-    
-    # 检查文件是否存在，如果不存在则使用rsync同步
-    if not download_success or not os.path.exists(f'/{huggingface_Data_name}.zip'):
-        print(f"下载 {huggingface_Data_name}.zip 失败 {max_retries} 次，切换到rsync同步")
-        os.system("mkdir -p /root/SillyTavern")
-        
-        # 添加rsync重试次数计数器
-        rsync_retry_count = 0
-        max_rsync_retries = 10
-        
-        while rsync_retry_count < max_rsync_retries:
-            try:
-                print(f"rsync同步尝试 {rsync_retry_count + 1}/{max_rsync_retries}")
-                print("开始生成SSH密钥...")
-                generate_ssh_key()
-                print("复制SSH密钥到远程服务器...")
-                copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
-                print(f"开始从 {ssh_url}:{ssh_port} 同步数据到 {data_folder}")
-                # 添加进度显示
-                rsync_cmd = f"rsync -avz --progress --stats --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/"
-                print(f"执行命令: {rsync_cmd}")
-                
-                # 设置超时
-                result = subprocess.run(rsync_cmd, shell=True, check=True, timeout=1800)  # 30分钟超时
-                print("rsync同步完成")
-                break  # 同步成功，跳出循环
-                
-            except subprocess.TimeoutExpired:
-                print(f"rsync同步超时，这是第 {rsync_retry_count + 1} 次尝试")
-                rsync_retry_count += 1
-                
-            except subprocess.CalledProcessError as e:
-                print(f"rsync同步失败: 返回码 {e.returncode}")
-                if hasattr(e, 'stdout') and e.stdout:
-                    print(f"输出: {e.stdout}")
-                if hasattr(e, 'stderr') and e.stderr:
-                    print(f"错误: {e.stderr}")
-                
-                rsync_retry_count += 1
-                
-            except Exception as e:
-                print(f"rsync同步过程中发生未知错误: {str(e)}")
-                rsync_retry_count += 1
-            
-            # 检查是否达到最大重试次数
-            if rsync_retry_count >= max_rsync_retries:
-                print(f"rsync同步失败达到最大重试次数 {max_rsync_retries}，结束程序")
-                sys.exit(1)  # 使用非零退出码表示错误
-            
-            # 等待一段时间后重试
-            wait_time = 30
-            print(f"等待 {wait_time} 秒后重试...")
-            time.sleep(wait_time)
+    while True:
+        # 执行下载命令
+        if download_n > 6:
+            break
+        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 下载失败，正在重试...")
+        download_n += 1
+        time.sleep(300)  # 等待一段时间再重试（例如5秒
+    # os.system('kaggle datasets download xovale7506/sillytavern-data2')
+    # 检查文件是否存在
+    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 --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",shell=True, check=True)
     else:
+        
         # 如果文件存在，可以继续执行后续代码
         print(f"文件 /{huggingface_Data_name}.zip 存在，继续执行程序。")
-        # 解压文件
+    # # 解压 sillytavern.zip
+        # os.system("rm *.zip")
+        
+        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("ls /")
+        # 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")
+
+        print('更新文件')
+        # os.system('git pull --rebase --autostash')
+        
+        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:
-            os.system("ls /")
-            print("开始解压文件...")
-            os.system(f"7z x /{huggingface_Data_name}.zip -o/ -y")
-            os.system("mv /sillytavern.tck sillytavern.tar.gz 2>/dev/null || true")
-            os.system("mv /sillytavern.ctk sillytavern.tar.gz 2>/dev/null || true")
-            
-            # 检查tar.gz文件是否存在
-            if os.path.exists("/sillytavern.tar.gz"):
-                print("开始解压tar.gz文件...")
-                os.system(f"tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null")
-                print("tar.gz文件解压完成")
-            else:
-                print("警告: sillytavern.tar.gz文件不存在")
-            
-            os.chdir(data_folder)
-            print('更新文件')
-            os.system(f"ls {data_folder}")
-            os.system("nvm install node")
-            os.system("nvm use node")
-            os.system("npm install -y")
-            
-            try:
-                print("尝试启动SillyTavern...")
-                subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
-            except subprocess.CalledProcessError as e:
-                print(f"启动失败: {e.returncode}")
-                print(f"命令: {e.cmd}")
-                if hasattr(e, 'output') and e.output:
-                    print(f"输出: {e.output}")
-            
-            os.system(f"ls {data_folder}")
-            
-            # 启动后台线程
-            backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
-            backup_thread.start()
-            # 清理下载的文件
-            print("清理临时文件...")
-            os.system(f"rm -r /{huggingface_Data_name}.zip /sillytavern.tar.gz 2>/dev/null || true")
-        except Exception as e:
-            print(f"解压或启动过程中发生错误: {str(e)}")
-
-    print('-----------SillyTavern结束-------------')
+            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}")
+        backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
+        backup_thread.start()
+        os.system("rm -r /qilan-st2.zip /sillytavern.tar.gz")
+    print('-----------SillyTavern结束-------------')  
 threading.Thread(target=SillyTavern, daemon=True).start()
 time.sleep(60)
 check_api1()
 
+
+# 创建 ConfigParser 对象
+config = configparser.ConfigParser()
+# 添加一个 'general' 部分
+config.add_section('general')
+# 设置 'monitor_port_enabled' 选项的值为 True
+config.set('general', 'monitor_port_enabled', 'True')
+# 将配置写入到 'config.ini' 文件中
+with open('/config.ini', 'w') as configfile:
+    config.write(configfile)
+
 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 = threading.Thread(target=repeat_task, daemon=True)#压缩备份
     backup_thread.start()
     print("开始衔接")
     Service_status = True
     frp(configs, True)
-
     threading.Thread(target=monitor_port, daemon=True).start()#检测端口状态
     while True:
         if backup_thread.is_alive():
@@ -756,7 +669,7 @@ if os.path.exists(f'{data_folder}/start.sh'):
             print("备份线程已停止.")
             backup_thread = threading.Thread(target=repeat_task, daemon=True)
             backup_thread.start()
-            break
+            # break
         time.sleep(5)
 
 else: