server6.py

ini_content = {"username":"hdsg142saa","key":"2da57ac0c245c1ebba26017f161d5558"}
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_Data_name = 'qilan-st5'
configs = [
    ("""
    [common]
    server_addr = 47.237.156.222
    server_port = 7000

    [safsa666]
    type = tcp
    local_ip = 127.0.0.1
    local_port = 8000
    remote_port = 7082
    
    [sascb2f666]
    type = tcp
    local_ip = 127.0.0.1
    local_port = 22
    remote_port = 7083
    """, '/content/frp/frpc.ini'),
    (f"""
    [common]
    server_addr = {frp_url}
    server_port = 7000
    token = qilan
    [kkjmk6]
    type = tcp
    local_ip = 127.0.0.1
    local_port = 8000
    remote_port = 7077
    """, '/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'),
   (f"""
   [common]
   server_addr = {ssh_url}
   server_port=7000 
   [kkji1mk6] 
   type=tcp 
   local_ip=127.0.0.1
   local_port=22 
   remote_port={ssh_port}
     """, '/content/frp/frpc5.ini')
]
kaggle_metadata = {
    "title": "Your Dataset Title",
    "id": f"{huggingface_name}/{huggingface_Data_name}",
    "licenses": [{"name": "CC0-1.0"}]
}
st_status = True
import subprocess
import os
import sys
from IPython.display import clear_output
import urllib.request
from pathlib import Path
import requests
import json
import threading
import time
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  > /dev/null 2>&1")
def update():
    print('-----------更新软件包列表开始-------------')
    # os.system("sudo apt update")
    # 安装 Node.js 和 npm
    # 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')
    os.system("pip install -U kaggle > /dev/null 2>&1")   
    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")

    print('-----------更新软件包列表结束-------------')
update()


from ruamel.yaml import YAML
clear_output(wait=True)  # 清除输出

def kill_frpc_processes():
    try:
        # 使用pkill命令结束所有frpc进程
        subprocess.run(['pkill', '-f', 'frpc'], check=True)
        print("所有frpc进程已被结束。")
    except subprocess.CalledProcessError as e:
        # 如果pkill命令失败，打印错误信息
        print(f"结束frpc进程时出错: {e}")
kill_frpc_processes()

# SSH
def run_command(command):
    try:
        subprocess.run(command, check=True, shell=True)
    except subprocess.CalledProcessError as e:
        print(f"An error occurred: {e}")
def ssh():
    print('-----------SSH开始-------------')
    subprocess.run("apt update", check=True, shell=True)
    subprocess.run("apt install openssh-server -y", check=True, shell=True)
    subprocess.run("apt-get install vim -y", check=True, shell=True)
    
    config_client_cmd = "sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config"
    subprocess.run(config_client_cmd, check=True, shell=True)
    config_server_cmd = "sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config"
    subprocess.run(config_server_cmd, check=True, shell=True)
    run_command("systemctl restart ssh")

    os.system("/etc/init.d/ssh restart")
    os.system("echo 'root:qilan' | sudo chpasswd")
    os.system("echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config")
    os.system("service ssh restart ")
    os.system("export LD_LIBRARY_PATH=$(echo $LD_LIBRARY_PATH | tr ':' '\n' | grep -v '/opt/conda/lib' | paste -sd ':') ")
    print('-----------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 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}")

        print('重命名压缩后的文件')
        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 < (400 * 1024 ** 2):  
            print("文件小于800MB，不进行上传。")
            return
        
        if last_uploaded_size == -1 or file_size != last_uploaded_size:
            # 判断是否为首次运行或上次上传大小为0
            if last_uploaded_size == -1:
                print("首次运行，正在执行上传...")
                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
                last_uploaded_size = file_size
            
            elif file_size > last_uploaded_size:
                print(f"新文件 {zip_file_path} 大于上次上传的大小，正在执行上传...")
                update_last_uploaded_size(file_size)  # 更新元数据中的最后一次上传大小

                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'])
                last_uploaded_size = file_size
            
        else:
            print(f"新文件 {zip_file_path} 不大于上次上传的大小，跳过")


def repeat_task():
    print('------打包线程启动-------------')
    while True:
        print('等待打包')
        time.sleep(18000)
        # compress_folder()
    print('------打包线程结束-------------')


import os
import subprocess
import pexpect

def generate_ssh_key():
    # 生成 SSH 密钥对，并捕获输出和错误信息
    os.system("rm -f ~/.ssh/id_rsa ~/.ssh/id_rsa.pub")
    keygen_command = "ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -N ''"
    try:
        result = subprocess.run(keygen_command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        print("SSH key pair generated.")
        print(result.stdout.decode())   # 打印标准输出信息（如成功消息）
    except subprocess.CalledProcessError as e:
        print(f"Failed to generate SSH key: {e.stderr.decode() if e.stderr else e}")

def copy_public_key_to_remote(host, port, user, password):
    # 使用 pexpect 自动输入密码来复制公钥
    try:
        command = f"ssh-copy-id -o StrictHostKeyChecking=no -p {port} {user}@{host}"
        child = pexpect.spawn(command)

        # 等待密码提示并发送密码
        child.expect("password:", timeout=10)  # 增加超时时间
        child.sendline(password)

        # 等待命令完成并输出结果
        child.expect(pexpect.EOF)
        
        print(child.before.decode())  # 打印输出结果
        
    except Exception as e:
        print(f"An error occurred: {e}")


# 生成 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):
    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):
    """创建一个带重试机制的请求会话"""
    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

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)

def check_api1():
    # 第一次检查 SillyTavern 是否启动
    thread_started = False
    n = 0
    while True:
        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
            
            print("SillyTavern未启动，状态码:", response.status_code, n)

        except requests.exceptions.RequestException as e:
            print(f"SillyTavern未启动3: {e}, 尝试次数: {n}")
        
        time.sleep(5)
    
    print('ST本地已经运行，开始检测接口状态')
    Service_status = False
    n = 0
    nn = 0
    while True:
        n += 1
        if not os.path.exists(data_folder):
            print(f"/sillytavern/ 文件不存在，结束检测")
            break
        if Service_status:
            print("结束检测")
            break
        if nn > 2:
            break
        url = f"{st_url}/csrf-token"
        try:
            response = requests_retry_session().get(url, timeout=30)
            response.raise_for_status()
            response_json = response.json()
            print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
            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:
                    nn += 1
                    print(f"Rsync 失败，返回码: {e.returncode}, 尝试次数: {nn}")
                    generate_ssh_key()  # 处理 SSH 密钥生成
            else:
                print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
        except requests.exceptions.ConnectionError as e:
            print(f"接口异常1: {e}, 尝试次数: {n}, nn: {nn}")
            # time.sleep(3)
            nn += 1
            if nn > 5:
                break
        except requests.exceptions.Timeout as e:
            print(f"接口异常2: {e}, 尝试次数: {n}")
            break
        except requests.exceptions.RequestException as e:
            print(f"接口异常3: {e}, 尝试次数: {n}")
            break
        
        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 地址"""
    response = requests.get("https://ipinfo.io/ip")
    return response.text.strip()

def get_geo_info(ip_address):
    """根据 IP 地址获取地理位置信息"""
    url = f"https://api.qjqq.cn/api/Local"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
    }
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        geo_info = response.json()
        
        if geo_info['code'] == 200:
            data = geo_info['data']
            return {
                'ip': data['ip'],
                'country': data['country'],
                'isp': data['isp']
            }
    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_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 信息
            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)
            
            print(f"成功更新信息：")
            print(f"接力时间: {next_relay_time}")
            print(f"IP信息: IP[{ip_address}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
    
    except Exception as 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()
        time.sleep(5)  # 每5秒检查一次
def Run_SillyTavern():
    
    # subprocess.run(f'node "server.js" "$@"', shell=True, check=True)
    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)
        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"Run_SillyTavern命令失败，返回码: {e.returncode}")
    except Exception as e:  # 捕获所有其他异常
        print(f"Run_SillyTavern发生异常: {e}")
def SillyTavern():
    print('-----------SillyTavern开始-------------')
    # 创建目录并写入 kaggle.json
    os.system("mkdir -p ~/.kaggle")
    file_path = '/root/.kaggle/kaggle.json'
    with open(file_path, 'w') as json_file:
        json.dump(ini_content, json_file, indent=4)
    os.system("chmod 600 ~/.kaggle/kaggle.json")

    clear_output()

    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}")
    
    # 改进的下载逻辑
    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)
    else:
        # 如果文件存在，可以继续执行后续代码
        print(f"文件 /{huggingface_Data_name}.zip 存在，继续执行程序。")
        # 解压文件
        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结束-------------')
threading.Thread(target=SillyTavern, daemon=True).start()
time.sleep(60)
check_api1()

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()
    print("开始衔接")
    Service_status = True
    frp(configs, True)

    threading.Thread(target=monitor_port, daemon=True).start()#检测端口状态
    while True:
        if backup_thread.is_alive():
            print("备份线程仍在运行...")
        else:
            print("备份线程已停止.")
            backup_thread = threading.Thread(target=repeat_task, daemon=True)
            backup_thread.start()
            break
        time.sleep(5)

else:
    print("/sillytavern 文件不存在结束执行")
compress_folder()