Update server6.py

server6.py

@@ -0,0 +1,923 @@
+ini_content = {"username":"hdsg142saa","key":"2da57ac0c245c1ebba26017f161d5558"}
+frp_url = '119.8.118.149'
+ssh_port = '7078'
+ssh_url = '43.135.135.22'
+st_url = f'http://{frp_url}:7076'
+huggingface_name = 'hdsg142saa'
+huggingface_Data_name = 'qilan-st5'
+configs = [
+    ("""
+    [common]
+    server_addr = 47.237.156.222
+    server_port = 7000
+
+    [safsa55]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 8000
+    remote_port = 7080
+    
+    [sascb2f55]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 22
+    remote_port = 7081
+    """, '/content/frp/frpc.ini'),
+    (f"""
+    [common]
+    server_addr = {frp_url}
+    server_port = 7000
+    token = qilan
+    [kkjmk5]
+    type = tcp
+    local_ip = 127.0.0.1
+    local_port = 8000
+    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'),
+   (f"""
+   [common]
+   server_addr = {ssh_url}
+   server_port=7000 
+   [kkji1mk5] 
+   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
+import logging
+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
+import socket
+import re
+from datetime import datetime, timedelta
+import psutil
+import pytz
+import paramiko
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+from ruamel.yaml import YAML
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# 文件和目录设置
+data_folder = '/root/SillyTavern'  # 要压缩的目录
+zip_file_path = '/a/sillytavern.tar.gz'  # 输出的 tar.gz 文件路径
+metadata_file_path = '/a/dataset-metadata.json'
+
+# 创建锁和共享变量
+lock = threading.Lock()
+last_uploaded_size = -1
+service_status = False
+
+# 初始设置
+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 https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
+os.system("chmod +x /content/frp/frpc")
+
+# 更新软件包列表
+def is_installed(package):
+    """检查软件包是否已安装"""
+    try:
+        subprocess.run(['dpkg', '-s', package], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE,
+                      check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+def install_package(package):
+    """使用apt安装软件包"""
+    logger.info(f"正在安装 {package}...")
+    subprocess.run(
+        f"sudo apt install {package} -y > /dev/null 2>&1",
+        shell=True,
+        check=False
+    )
+
+def update_packages():
+    """更新和安装所需软件包"""
+    logger.info('开始更新软件包列表')
+    
+    # 安装必要的系统依赖
+    packages = {
+        'system': ['nodejs', 'npm', 'pigz', 'pv', 'p7zip-full', 'openssh-server', 'vim'],
+        'python': ['kaggle==1.5.6', 'ruamel.yaml', 'pexpect', 'pytz', 'paramiko']
+    }
+    
+    # 安装系统包
+    for pkg in packages['system']:
+        if not is_installed(pkg):
+            install_package(pkg)
+    
+    # 安装Python包
+    for pkg in packages['python']:
+        if '==' in pkg:
+            pkg_name = pkg.split('==')[0]
+            pkg_version = pkg.split('==')[1]
+            os.system(f"pip uninstall -y {pkg_name} > /dev/null 2>&1")
+            os.system(f"pip install {pkg} > /dev/null 2>&1")
+        else:
+            os.system(f"pip install {pkg} > /dev/null 2>&1")
+    
+    logger.info('软件包列表更新完成')
+
+def kill_frpc_processes():
+    """结束所有frpc进程"""
+    try:
+        subprocess.run(['pkill', '-f', 'frpc'], check=True)
+        logger.info("所有frpc进程已被结束")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"结束frpc进程时出错: {e}")
+
+# 运行系统更新
+update_packages()
+clear_output(wait=True)  # 清除输出
+
+# 关闭可能运行的frpc进程
+kill_frpc_processes()
+
+def run_command(cmd, check=True, shell=True, silent=False):
+    """运行系统命令的通用函数"""
+    try:
+        kwargs = {
+            'shell': shell,
+            'check': check
+        }
+        
+        if silent:
+            kwargs.update({
+                'stdout': subprocess.DEVNULL,
+                'stderr': subprocess.DEVNULL
+            })
+            
+        return subprocess.run(cmd, **kwargs)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"命令执行失败: {e}")
+        return None
+
+# Oneapi中转
+def Oneapi():
+    print('-----------Oneapi中转开始-------------')
+    # 删除旧的 one-api 文件夹（如果存在）
+    os.system("rm -rf /one/one-api")  # 使用 -f 参数以避免错误
+    os.system("mkdir -p /one")  # 创建目录
+    # 下载 one-api 文件
+    url = "https://github.com/songquanpeng/one-api/releases/download/v0.6.8/one-api"
+    os.system(f"wget {url} -O /one/one-api")  # 正确下载并重命名为 /one/one-api
+    # 修改文件权限，使其可执行
+    os.system("chmod +x /one/one-api")
+    # 设置环境变量
+    os.environ["THEME"] = "berry"
+    os.environ["TIKTOKEN_CACHE_DIR"] = os.getcwd()  # 使用Python的os.getcwd()获取当前工作目录
+    # 设置MySQL数据库的环境变量
+    db_user = "oneapi"
+    db_password = "epBjK5ZKysCe6yr3"
+    db_host = "106.52.51.116"
+    db_port = "3306"
+    db_name = "oneapi"
+    dsn = f"{db_user}:{db_password}@tcp({db_host}:{db_port})/{db_name}"
+    os.environ["SQL_DSN"] = dsn
+    command = ['/one/one-api', '--port', '3000']
+    process = subprocess.Popen(command)  # 启动程序并将其放到后台执行
+    print(f"OneAPI程序已在后台启动，进程ID为：{process.pid}")
+    print('-----------Oneapi中转结束-------------')
+# Oneapi()
+
+# SSH相关功能
+def ssh():
+    """安装和配置SSH服务器"""
+    logger.info('开始配置SSH服务')
+    
+    # 安装SSH服务器
+    run_command("apt update", silent=True)
+    run_command("apt install openssh-server -y", silent=True)
+    run_command("apt-get install vim -y", silent=True)
+    
+    # 配置SSH
+    run_command("sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config")
+    run_command("sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config")
+    run_command("systemctl restart ssh")
+    run_command("/etc/init.d/ssh restart")
+    run_command("echo 'root:qilan' | sudo chpasswd")
+    run_command("echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config")
+    run_command("service ssh restart")
+    run_command("export LD_LIBRARY_PATH=$(echo $LD_LIBRARY_PATH | tr ':' '\n' | grep -v '/opt/conda/lib' | paste -sd ':') ")
+    
+    logger.info('SSH服务配置完成')
+
+def generate_ssh_key():
+    """生成SSH密钥对"""
+    logger.info("生成SSH密钥对")
+    # 删除已有的SSH密钥
+    os.system("rm -f ~/.ssh/id_rsa ~/.ssh/id_rsa.pub")
+    
+    # 生成新的SSH密钥
+    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
+        )
+        logger.info("SSH密钥对已生成")
+        
+        # 设置权限
+        os.system('chmod 600 ~/.ssh/id_rsa')
+        return True
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr.decode() if e.stderr else str(e)
+        logger.error(f"SSH密钥生成失败: {error_msg}")
+        return False
+
+def copy_public_key_to_remote(host, port, user, password):
+    """将公钥复制到远程服务器"""
+    logger.info(f"正在将公钥复制到 {user}@{host}:{port}")
+    try:
+        command = f"ssh-copy-id -o StrictHostKeyChecking=no -p {port} {user}@{host}"
+        child = pexpect.spawn(command)
+
+        # 等待密码提示并发送密码
+        child.expect("password:", timeout=15)
+        child.sendline(password)
+
+        # 等待命令完成
+        child.expect(pexpect.EOF)
+        logger.info("公钥已成功复制到远程服务器")
+        return True
+    except Exception as e:
+        logger.error(f"复制公钥失败: {e}")
+        return False
+
+def check_ssh_connection(host, port, username, password):
+    """检查SSH连接是否可用"""
+    try:
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        client.connect(hostname=host, port=int(port), username=username, password=password, timeout=10)
+        client.close()
+        logger.info(f"SSH连接到 {username}@{host}:{port} 成功")
+        return True
+    except Exception as e:
+        logger.error(f"SSH连接失败: {e}")
+        return False
+
+def write_rsyncd_conf(path, port=7071):
+    """配置rsync守护进程"""
+    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())
+    logger.info(f"已配置rsync守护进程，端口为 {port}")
+    
+    # 启动rsync守护进程
+    run_command("sudo rsync --daemon")
+    run_command("ps aux | grep rsync", silent=True)
+
+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,
+        read=retries,
+        connect=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 monitor_port(port=8000, check_interval=5):
+    """监控指定端口，如果未使用则重新启动SillyTavern"""
+    logger.info(f"开始监控端口 {port}")
+    while True:
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                result = sock.connect_ex(('localhost', port))
+                if result == 0:
+                    logger.info(f"端口 {port} 正在使用中")
+                else:
+                    logger.warning(f"端口 {port} 未被使用，尝试重新启动SillyTavern")
+                    threading.Thread(target=Run_SillyTavern, daemon=True).start()
+        except Exception as e:
+            logger.error(f"端口监控异常: {e}")
+            
+        time.sleep(check_interval)
+
+def Run_SillyTavern():
+    """运行SillyTavern服务器"""
+    logger.info("尝试启动SillyTavern")
+    try:
+        # 确保在正确的目录中
+        os.chdir(data_folder)
+        
+        # 多次尝试启动，提高成功率
+        for i in range(5):
+            logger.info(f"第{i+1}次尝试启动SillyTavern")
+            result = run_command(f'yes | sh {data_folder}/start.sh', silent=True)
+            if result and result.returncode == 0:
+                logger.info("SillyTavern已成功启动")
+                break
+            time.sleep(2)
+            
+        logger.info("SillyTavern启动过程完成")
+    except Exception as e:
+        logger.error(f"启动SillyTavern时发生异常: {e}")
+
+def check_api_status():
+    """检查SillyTavern API是否正常运行"""
+    # 检查本地服务是否启动
+    max_retries = 30
+    retry_count = 0
+    
+    # 第一步：检查本地API是否启动
+    logger.info("检查SillyTavern本地API是否启动")
+    while retry_count < max_retries:
+        retry_count += 1
+        
+        if not os.path.exists(data_folder):
+            logger.error(f"数据目录 {data_folder} 不存在，终止检测")
+            return False
+            
+        try:
+            url = "http://127.0.0.1:8000/v1"
+            response = requests.get(url, timeout=5)
+            
+            if response.status_code == 403:
+                logger.info("SillyTavern本地API已启动")
+                break
+            
+            logger.warning(f"SillyTavern未启动，状态码: {response.status_code}，重试次数: {retry_count}")
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"SillyTavern未启动: {e}，重试次数: {retry_count}")
+        
+        if retry_count >= max_retries:
+            logger.error("SillyTavern本地API启动检测超时")
+            return False
+            
+        time.sleep(5)
+    
+    # 第二步：检查远程API是否可访问
+    logger.info("本地API已启动，开始检测远程API状态")
+    retry_count = 0
+    retry_limit = 10
+    sync_attempts = 0
+    
+    while retry_count < retry_limit:
+        retry_count += 1
+        
+        if sync_attempts >= 3:
+            logger.error("同步尝试次数过多，终止检测")
+            break
+            
+        url = f"{st_url}/csrf-token"
+        try:
+            response = requests_retry_session().get(url, timeout=10)
+            response.raise_for_status()
+            response_json = response.json()
+            
+            logger.info(f"远程API返回信息: {response_json}")
+            
+            if "token" in response_json:
+                logger.info("远程API正常，检测到token")
+                try:
+                    # 使用rsync从远程同步数据
+                    result = run_command(
+                        f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",
+                        check=True
+                    )
+                    if result and result.returncode == 0:
+                        logger.info("数据同步成功")
+                        return True
+                except Exception as e:
+                    sync_attempts += 1
+                    logger.error(f"数据同步失败: {e}，尝试次数: {sync_attempts}")
+                    if sync_attempts < 3:
+                        # 重新生成SSH密钥重试
+                        generate_ssh_key()
+            else:
+                logger.warning(f"远程API返回数据中没有token: {response_json}")
+                
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"远程API连接异常: {e}，重试次数: {retry_count}")
+            sync_attempts += 1
+        except requests.exceptions.Timeout as e:
+            logger.error(f"远程API超时: {e}")
+            break
+        except requests.exceptions.RequestException as e:
+            logger.error(f"远程API请求异常: {e}")
+            break
+        
+        time.sleep(5)
+    
+    return False
+
+def frp(configs, backstage=True):
+    """启动FRP代理客户端"""
+    logger.info('开始配置FRP客户端')
+    
+    # 杀死之前可能运行的frpc进程
+    kill_frpc_processes()
+    
+    # 遍历配置启动FRP
+    for idx, (config_data, config_file_path) in enumerate(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:
+            # 后台运行
+            process = subprocess.Popen(frpc_cmd)
+            logger.info(f"FRP客户端[{idx}]已在后台启动，PID: {process.pid}")
+        else:
+            # 前台运行（阻塞）
+            logger.info(f"FRP客户端[{idx}]正在前台启动")
+            run_command(f'/content/frp/frpc -c {config_file_path}', shell=True)
+    
+    logger.info('所有FRP客户端已启动')
+
+def get_current_ip():
+    """获取当前公共IP地址"""
+    try:
+        response = requests.get("https://ipinfo.io/ip", timeout=10)
+        ip = response.text.strip()
+        logger.info(f"当前公共IP: {ip}")
+        return ip
+    except Exception as e:
+        logger.error(f"获取IP地址失败: {e}")
+        return "未知"
+
+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 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    }
+    
+    try:
+        response = requests_retry_session().get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            geo_info = response.json()
+            
+            if geo_info.get('code') == 200:
+                data = geo_info.get('data', {})
+                result = {
+                    'ip': data.get('ip', "未知"),
+                    'country': data.get('country', "未知"),
+                    'isp': data.get('isp', "未知")
+                }
+                logger.info(f"获取地理信息成功: {result}")
+                return result
+                
+        logger.warning(f"获取地理信息失败，状态码: {response.status_code}")
+        return None
+    except Exception as e:
+        logger.error(f"获取地理信息时发生错误: {e}")
+        return None
+
+def get_next_relay_time():
+    """获取下一次接力时间（系统启动时间+12小时，转换为中国时区）"""
+    try:
+        # 获取系统启动时间
+        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")
+    except Exception as e:
+        logger.error(f"计算下次接力时间失败: {e}")
+        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+def replace_info_in_file(file_path):
+    """更新登录页面中的接力时间和IP信息"""
+    try:
+        # 检查文件是否存在
+        if not os.path.exists(file_path):
+            logger.error(f"文件{file_path}不存在，无法更新信息")
+            return False
+            
+        # 获取当前IP地址和地理信息
+        ip_address = get_current_ip()
+        geo_info = get_geo_info(ip_address)
+        next_relay_time = get_next_relay_time()
+        
+        if geo_info is None:
+            logger.error("无法获取地理信息，更新文件信息失败")
+            return False
+            
+        # 读取文件内容
+        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[{geo_info["ip"]}] 国家 [{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)
+        
+        logger.info("成功更新信息:")
+        logger.info(f"接力时间: {next_relay_time}")
+        logger.info(f"IP信息: IP[{geo_info['ip']}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
+        return True
+        
+    except Exception as e:
+        logger.error(f"更新文件信息时发生错误: {e}")
+        return False
+
+def update_last_uploaded_size(size):
+    """更新上次上传的文件大小"""
+    global last_uploaded_size
+    last_uploaded_size = size
+    logger.info(f"上次上传文件大小已更新为: {size} 字节")
+
+def compress_folder():
+    """压缩SillyTavern文件夹并上传到Kaggle"""
+    global last_uploaded_size  # 声明使用全局变量
+
+    # 清理并创建目录 /a
+    if os.path.exists('/a'):
+        run_command('rm -r /a/')
+
+    os.makedirs('/a', exist_ok=True)
+
+    with lock:  # 使用锁防止多线程冲突
+        # 检查文件是否已存在
+        if os.path.exists(zip_file_path):
+            logger.info(f"压缩文件 {zip_file_path} 已存在，跳过本次压缩")
+            return
+        
+        logger.info('开始压缩数据')
+        
+        # 使用pigz进行多核压缩以提高效率
+        try:
+            result = run_command(
+                f'tar -cvf - {data_folder} | pigz -p 2 -1 > {zip_file_path} 2> /dev/null',
+                shell=True,
+                check=True,
+                silent=True
+            )
+        except Exception as e:
+            logger.error(f"压缩命令失败: {e}")
+            return
+
+        logger.info('重命名压缩后的文件')
+        file_path = "/a/sillytavern.ctk"
+        
+        run_command(['mv', zip_file_path, file_path], shell=False)
+        
+        # 检查压缩是否成功
+        if not os.path.exists(file_path):
+            logger.error("压缩失败，文件不存在")
+            return
+
+        logger.info(f"数据已压缩到 {file_path}")
+        
+        # 获取文件大小
+        file_size = os.path.getsize(file_path)
+        logger.info(f'文件大小: {file_size} 字节, 上次文件大小: {last_uploaded_size} 字节')
+        
+        # 文件大小必须超过400MB才会上传
+        min_size = 400 * 1024 * 1024  # 400MB
+        if file_size < min_size:  
+            logger.info(f"文件小于{min_size/(1024*1024)}MB，不进行上传")
+            return
+        
+        # 检查是否需要上传
+        if last_uploaded_size == -1 or file_size > last_uploaded_size:
+            # 首次运行或文件变大
+            if last_uploaded_size == -1:
+                logger.info("首次运行，准备上传...")
+            else:
+                logger.info(f"新文件 {file_path} 大于上次上传的大小，准备上传...")
+            
+            # 更新上传大小记录
+            update_last_uploaded_size(file_size)
+            
+            # 创建元数据文件
+            with open(metadata_file_path, 'w') as json_fid:
+                json.dump(kaggle_metadata, json_fid)
+            
+            # 上传到Kaggle
+            logger.info("开始上传到Kaggle...")
+            os.system("kaggle datasets version -m 'new version message' -p /a")
+            logger.info("上传完成")
+        else:
+            logger.info(f"新文件 {file_path} 不大于上次上传的大小，跳过上传")
+
+def repeat_task():
+    """定期压缩和上传的后台任务"""
+    logger.info('打包备份线程已启动')
+    try:
+        while True:
+            logger.info('等待下一次打包时间...')
+            time.sleep(18000)  # 5小时执行一次
+            compress_folder()
+    except Exception as e:
+        logger.error(f"打包线程异常: {e}")
+    logger.info('打包线程已结束')
+
+def setup_tavern_environment():
+    """设置SillyTavern运行环境"""
+    logger.info("设置SillyTavern运行环境")
+    
+    try:
+        # 切换到SillyTavern目录
+        os.chdir(data_folder)
+        
+        # 安装Node.js环境
+        run_command("nvm install node", silent=True)
+        run_command("nvm use node", silent=True)
+        
+        # 安装依赖
+        run_command("npm install -y", silent=True)
+        
+        # 首次运行SillyTavern
+        try:
+            run_command(f'yes | sh {data_folder}/start.sh', check=False, silent=True)
+            logger.info("SillyTavern环境设置完成")
+            return True
+        except Exception as e:
+            logger.error(f"首次启动SillyTavern失败: {e}")
+            return False
+    except Exception as e:
+        logger.error(f"设置SillyTavern环境时出错: {e}")
+        return False
+
+def SillyTavern():
+    """安装和配置SillyTavern"""
+    logger.info('开始安装SillyTavern')
+    
+    # 设置Kaggle凭证
+    setup_kaggle()
+    
+    # 清除输出
+    clear_output()
+    
+    # 清理旧文件
+    run_command(f"rm -rf /a /sillytavern /*.zi* {data_folder}", silent=True)
+    run_command(f"mkdir -p {data_folder}", silent=True)
+    
+    # 切换到根目录
+    os.chdir('/')
+    
+    # 尝试从Kaggle下载
+    download_success = download_from_kaggle()
+    
+    if not download_success:
+        logger.warning("从Kaggle下载失败，尝试使用rsync同步")
+        # 使用SSH同步备份方案
+        generate_ssh_key()
+        copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
+        
+        try:
+            run_command(
+                f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",
+                check=True
+            )
+            logger.info("通过rsync成功同步数据")
+        except Exception as e:
+            logger.error(f"rsync同步失败: {e}")
+            return False
+    else:
+        # 如果下载成功，解压数据
+        extract_success = extract_tavern_data()
+        if not extract_success:
+            logger.error("解压SillyTavern数据失败")
+            return False
+    
+    # 设置环境并启动
+    setup_success = setup_tavern_environment()
+    if not setup_success:
+        logger.error("设置SillyTavern环境失败")
+        return False
+    
+    # 在后台启动SillyTavern
+    backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
+    backup_thread.start()
+    
+    logger.info('SillyTavern安装和配置完成')
+    return True
+
+# 主函数
+if __name__ == "__main__":
+    # 安装SSH服务
+    ssh()
+    
+    # 生成SSH密钥
+    generate_ssh_key()
+    
+    # 复制SSH公钥到远程服务器
+    copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
+    
+    # 配置rsync
+    write_rsyncd_conf(data_folder)
+    
+    # 启动SillyTavern
+    tavern_thread = threading.Thread(target=SillyTavern, daemon=True)
+    tavern_thread.start()
+    tavern_thread.join(timeout=60)  # 等待最多60秒
+    
+    # 检查API状态
+    api_status = check_api_status()
+    
+    # 如果SillyTavern已安装成功
+    if os.path.exists(f'{data_folder}/start.sh'):
+        # 更新登录页面信息
+        replace_info_in_file(f'{data_folder}/public/login.html')
+        
+        # 启动备份线程
+        backup_thread = threading.Thread(target=repeat_task, daemon=True)
+        backup_thread.start()
+        
+        logger.info("开始配置网络连接")
+        # 服务状态设为可用
+        st_status = True
+        
+        # 启动FRP代理
+        frp(configs, True)
+        
+        # 启动端口监控
+        threading.Thread(target=monitor_port, daemon=True).start()
+        
+        # 监控备份线程状态
+        while True:
+            if backup_thread.is_alive():
+                logger.info("备份线程正在运行...")
+            else:
+                logger.warning("备份线程已停止，重新启动")
+                backup_thread = threading.Thread(target=repeat_task, daemon=True)
+                backup_thread.start()
+                break
+            time.sleep(30)  # 每30秒检查一次
+        
+        # 运行一次压缩备份
+        compress_folder()
+    else:
+        logger.error(f"{data_folder} 文件夹不存在，安装失败")
+
+def setup_kaggle():
+    """设置Kaggle API凭证"""
+    logger.info("设置Kaggle API凭证")
+    # 创建目录并写入kaggle.json
+    os.makedirs("~/.kaggle", exist_ok=True)
+    
+    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")
+    logger.info("Kaggle凭证设置完成")
+
+def download_from_kaggle():
+    """从Kaggle下载SillyTavern数据"""
+    logger.info(f"开始从Kaggle下载数据集 {huggingface_name}/{huggingface_Data_name}")
+    
+    max_attempts = 6
+    for attempt in range(1, max_attempts + 1):
+        logger.info(f"第{attempt}次尝试下载")
+        
+        # 执行下载命令
+        run_command(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /", silent=True)
+        
+        # 检查文件是否存在
+        if os.path.exists(f'/{huggingface_Data_name}.zip'):
+            logger.info(f"{huggingface_Data_name}.zip 下载成功")
+            return True
+            
+        logger.warning(f"{huggingface_Data_name}.zip 下载失败，正在重试...")
+        
+        if attempt < max_attempts:
+            logger.info(f"等待5分钟后重试...")
+            time.sleep(300)  # 等待5分钟再重试
+    
+    logger.error("多次尝试下载失败")
+    return False
+
+def extract_tavern_data():
+    """解压SillyTavern数据"""
+    logger.info("开始解压SillyTavern数据")
+    
+    # 检查目标文件
+    zip_path = f'/{huggingface_Data_name}.zip'
+    if not os.path.exists(zip_path):
+        logger.error(f"文件 {zip_path} 不存在，无法解压")
+        return False
+        
+    try:
+        # 解压缩文件
+        run_command(f"7z x {zip_path} -o/ -y", silent=True)
+        
+        # 重命名解压后的文件
+        if os.path.exists('/sillytavern.tck'):
+            run_command("mv /sillytavern.tck sillytavern.tar.gz")
+        
+        if os.path.exists('/sillytavern.ctk'):
+            run_command("mv /sillytavern.ctk sillytavern.tar.gz")
+        
+        # 使用pigz解压tar.gz文件
+        if os.path.exists('/sillytavern.tar.gz'):
+            run_command("tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null", silent=True)
+            logger.info("SillyTavern数据解压完成")
+            
+            # 清理下载和临时文件
+            run_command(f"rm -r {zip_path} /sillytavern.tar.gz", silent=True)
+            return True
+        else:
+            logger.error("解压后的tar.gz文件不存在")
+            return False
+    except Exception as e:
+        logger.error(f"解压SillyTavern数据时出错: {e}")
+        return False