# 示例：获取当前连接状态（假设端口为8972，无需认证）
curl http://127.0.0.1:8972/api/v1/status

# 如果API需要认证，命令可能类似如下（假设使用Bearer Token）：
curl -H "Authorization: Bearer YOUR_API_TOKEN_HERE" http://127.0.0.1:8972/api/v1/status

import requests
import json

API_BASE = "http://127.0.0.1:8972"
# 假设需要头部认证
HEADERS = {"Authorization": "Bearer YOUR_TOKEN"}

def get_node_list():
    """获取所有可用服务器节点"""
    try:
        response = requests.get(f"{API_BASE}/api/v1/nodes", headers=HEADERS)
        response.raise_for_status() # 检查HTTP错误
        nodes = response.json()
        print(f"共获取到 {len(nodes)} 个节点。")
        # 打印前5个节点信息示例
        for node in nodes[:5]:
            print(f"ID: {node['id']}, 地区: {node['country']}-{node.get('city', 'N/A')}, 标签: {node.get('tags', [])}")
        return nodes
    except requests.exceptions.RequestException as e:
        print(f"获取节点列表失败: {e}")
        return []

if __name__ == "__main__":
    node_list = get_node_list()

def connect_to_node(node_id):
    """连接到指定ID的节点"""
    data = {"node_id": node_id}
    try:
        response = requests.post(f"{API_BASE}/api/v1/connect", json=data, headers=HEADERS)
        response.raise_for_status()
        result = response.json()
        if result.get("success"):
            print(f"已发起连接到节点 {node_id} 的请求。")
        else:
            print(f"连接请求失败: {result.get('message')}")
    except requests.exceptions.RequestException as e:
        print(f"连接调用失败: {e}")

def disconnect_vpn():
    """断开当前VPN连接"""
    try:
        response = requests.post(f"{API_BASE}/api/v1/disconnect", headers=HEADERS)
        response.raise_for_status()
        print("已发起断开连接的请求。")
    except requests.exceptions.RequestException as e:
        print(f"断开连接调用失败: {e}")

# 使用示例：连接到ID为“us-sfo-01”的节点
# connect_to_node("us-sfo-01")
# 断开连接
# disconnect_vpn()

import time

def monitor_connection(interval_seconds=10, duration_seconds=60):
    """监控连接状态与速度，持续一段时间"""
    end_time = time.time() + duration_seconds
    while time.time() < end_time:
        try:
            response = requests.get(f"{API_BASE}/api/v1/status", headers=HEADERS)
            status = response.json()
            if status.get("connected"):
                node = status.get("current_node", {})
                print(f"[{time.strftime('%H:%M:%S')}] 已连接 | "
                      f"节点: {node.get('country', 'N/A')} | "
                      f"时长: {status.get('duration', 0)}s | "
                      f"上传: {status.get('upload_speed', 0):.2f} KB/s | "
                      f"下载: {status.get('download_speed', 0):.2f} KB/s")
            else:
                print(f"[{time.strftime('%H:%M:%S')}] 未连接")
        except requests.exceptions.RequestException:
            print(f"[{time.strftime('%H:%M:%S')}] 状态查询失败")
        time.sleep(interval_seconds)

# 启动监控，每10秒检查一次，共监控1分钟
# monitor_connection(10, 60)

def connect_to_best_node(nodes):
    """从节点列表中筛选并连接到延迟最低的节点"""
    if not nodes:
        print("节点列表为空。")
        return
    # 过滤出可用的、有延迟数据的节点
    available_nodes = [n for n in nodes if n.get('latency') is not None and n.get('latency') > 0]
    if not available_nodes:
        print("没有找到可用的带延迟数据的节点。")
        return
    # 按延迟升序排序
    best_node = min(available_nodes, key=lambda x: x['latency'])
    print(f"延迟最低的节点是: {best_node['country']}-{best_node.get('city')} (ID: {best_node['id']}, 延迟: {best_node['latency']}ms)")
    connect_to_node(best_node['id'])

# 整合调用
# all_nodes = get_node_list()
# connect_to_best_node(all_nodes)

import smtplib
from email.mime.text import MIMEText

def send_alert_email(subject, body):
    """简单的邮件告警函数（需配置SMTP）"""
    # 此处为示例，需要填入您的SMTP服务器信息
    sender = "your_alert@email.com"
    receivers = ["admin@yourcompany.com"]
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = sender
    msg['To'] = ", ".join(receivers)
    try:
        # 示例使用本地SMTP，生产环境请配置真实SMTP服务器
        smtp_obj = smtplib.SMTP('localhost')
        smtp_obj.sendmail(sender, receivers, msg.as_string())
        print("告警邮件发送成功")
    except smtplib.SMTPException:
        print("错误：无法发送告警邮件")

def health_check_and_recover():
    """健康检查：如果断开连接，则尝试重连最优节点"""
    try:
        status_resp = requests.get(f"{API_BASE}/api/v1/status", headers=HEADERS)
        status = status_resp.json()
        if not status.get("connected"):
            print("检测到VPN连接已断开！尝试自动恢复...")
            # 记录日志或发送轻度告警
            # send_alert_email("快连VPN连接断开告警", "检测到VPN连接已断开，正在尝试自动恢复。")
            # 获取节点并重连
            nodes = get_node_list()
            if nodes:
                connect_to_best_node(nodes)
                # 等待几秒后再次检查
                time.sleep(5)
                status_resp2 = requests.get(f"{API_BASE}/api/v1/status", headers=HEADERS)
                if status_resp2.json().get("connected"):
                    print("自动恢复成功！")
                else:
                    print("自动恢复失败，可能需要人工干预。")
                    send_alert_email("快连VPN自动恢复失败", "VPN连接断开后自动重连失败，请立即检查！")
            else:
                print("无法获取节点列表，恢复失败。")
                send_alert_email("快连VPN节点获取失败", "无法获取可用节点列表，请检查客户端与API服务。")
        else:
            # 连接正常，可以检查延迟是否过高，进行预警
            current_latency = status.get('current_node', {}).get('latency')
            if current_latency and current_latency > 300: # 假设300ms为阈值
                print(f"警告：当前节点延迟较高 ({current_latency}ms)，建议切换。")
    except requests.exceptions.RequestException as e:
        print(f"健康检查过程中发生网络错误: {e}")
        send_alert_email("快连VPN API通信异常", f"无法与本地API服务通信: {e}")

# 可以将此函数设置为定时任务（如cron job或Windows计划任务），每5分钟执行一次。

import requests
from your_spider_module import YourSpider # 假设的爬虫类

class VPNManagedSpider:
    def __init__(self):
        self.api_base = "http://127.0.0.1:8972"
        self.headers = {"Authorization": "Bearer YOUR_TOKEN"}
        self.request_count = 0
        self.switch_threshold = 100 # 每爬取100个请求切换一次IP

    def make_request(self, url):
        """封装请求，并计数"""
        # 在实际请求前，可以检查是否需要切换IP
        if self.request_count >= self.switch_threshold:
            self.switch_vpn_node()
            self.request_count = 0
        # 执行实际网络请求（此处简化）
        response = requests.get(url)
        self.request_count += 1
        return response

    def switch_vpn_node(self):
        """随机切换到一个新的节点"""
        try:
            # 1. 断开当前连接
            requests.post(f"{self.api_base}/api/v1/disconnect", headers=self.headers)
            time.sleep(2) # 等待断开完成
            # 2. 获取节点列表
            resp = requests.get(f"{self.api_base}/api/v1/nodes", headers=self.headers)
            nodes = resp.json()
            if nodes:
                # 随机选择一个节点ID（这里简单取第一个，实际可随机选择）
                import random
                new_node = random.choice(nodes)
                # 3. 连接到新节点
                requests.post(f"{self.api_base}/api/v1/connect",
                              json={"node_id": new_node['id']},
                              headers=self.headers)
                print(f"已切换至新节点: {new_node['country']}，等待连接稳定...")
                time.sleep(5) # 等待新连接稳定
        except Exception as e:
            print(f"切换VPN节点时发生错误: {e}")

# 使用示例
# spider = VPNManagedSpider()
# for url in url_list:
#     html = spider.make_request(url)
#     # ... 处理html内容 ...