橘夏网 - 专注于优质资源聚合的分享平台

重新定义 Cloudflare 管控体验的全能面板

Thu, 20 Nov 2025 00:00:00 GMT

让 Cloudflare 管理更简单

全能第三方管理面板，为你重新定义 Cloudflare 运维体验

在 Cloudflare 的生态中，官方 Dashboard 功能强大，但操作路径分散、管理维度复杂，对于多站点、多域名、多环境用户来说，想要高效完成日常管控并不轻松。

因此，我们打造了这一款 专为 Cloudflare 深度用户设计的第三方全能管理面板。通过统一界面、极简操作和更灵活的增强功能，为你带来比官方面板更高效、更顺手的全栈管理体验。

为什么需要一个更好的 Cloudflare 管控工具？

Cloudflare 提供了丰富的服务：CDN、DNS、WAF、安全规则、Workers、Tunnel、R2、流量分析……但：

多级页面跳转让操作不够直观
批量操作支持有限
企业级功能上手门槛高
多站点运维容易乱、数据不集中
Workers、WAF、规则等页面查看不便
官方 Dashboard 偶尔出现加载慢或不稳定

我们的目标很简单：
让 Cloudflare 的每一项能力都能在一个界面里，被更快、更轻松地使用。

面板核心能力一览

1. CDN 加速与缓存控制

一键清缓存
批量启用/关闭加速
节点状态与性能数据快速查看

2. DNS 完整管理

支持新增、编辑、批量删除记录
智能识别常用 DNS 类型
更直观的记录结构与搜索能力

3. WAF & 安全策略管理

全量展示 WAF 规则
快速启停安全策略
自定义拦截逻辑与规则匹配查看

4. Workers 一站式体验

部署、环境变量、日志、监控一体化
支持脚本管理与多项目
Workers KV / Durable Objects 管理更直观

5. 分析与监控可视化

流量图表
攻击统计
请求详细分布
缓存命中率分析

6. 批量操作与自动化增强

批量清缓存
批量修改 DNS
自动化任务与脚本支持

为什么说它比官方更强？

操作路径更短：几乎所有功能都不超过两步
数据更聚合：多域名、多站点一屏掌握
更灵活的策略管理：规则更好找、操作更顺
更快的响应速度：轻量化面板减少无关加载
更友好：面向国内用户的习惯优化
更适合中大型站点运维

一句话总结：
这不是 Cloudflare 的替代，而是更实用、更高效的 Cloudflare 使用方式。

适用人群

多站点站长
需要统一管理 Cloudflare 资源的团队
使用 Workers 进行开发/部署的工程师
对安全策略管理有更高要求的用户
想减少 Cloudflare Dashboard 操作成本的人

结语

如果你觉得 Cloudflare 官方 Dashboard 偶尔有点“又强又难用”，那这个面板会彻底改变你的体验。
它把 Cloudflare 复杂而强大的能力，变成了更快、更稳、更专业的一体化管理方案，让你真正专注在网站与业务，而不是面板本身。

欢迎体验，感受一个更顺手的 Cloudflare 控制中心。

官网：www.swowd.com

Cloudflare 全球大规模故障引发“网络地震”：社交平台X等多服务中断

Tue, 18 Nov 2025 00:00:00 GMT

摘要：北京时间 2025 年 11 月 18 日晚，互联网基础设施巨头 Cloudflare 遭遇严重故障。截至北京时间 22:42 最新消息：官方正式宣布问题已修复（Fixed），事件状态更新为“已解决”。目前仪表盘（Dashboard）、Access、WARP 以及各类应用程序服务均已完全恢复正常。

事故核心动态分析（终局）

本次故障呈现典型的“分层恢复”特征，现已全部修复：

控制面（已恢复）：仪表盘 (Dashboard) 功能完全恢复，配置下发无延迟。
安全接入层（已恢复）：Cloudflare Access 和 WARP 服务运行稳定，伦敦节点已重新并网。
应用服务层（已恢复）：此前受影响广泛的 应用程序服务 (Application Services) 已修复，官方确认问题解决。

故障时间线全景复盘（更新至 22:42 故障结束）

注：时间已统一换算为北京时间 (UTC+8)

时间节点	状态	关键事件详情
20:03	异常爆发	Cloudflare 确认内部服务故障。部分服务出现间歇性中断，官方紧急介入。
20:21	初步调查	故障排查进行中，尚未锁定具体根源。
20:37	波动恢复	监测数据显示部分服务开始复苏，但错误率依然远高于正常水平。
20:53	持续攻坚	技术团队持续调查，服务处于高风险状态。
21:04	物理隔离	[伦敦区域] 为阻断故障级联效应，紧急切断伦敦节点 WARP 接入，当地服务完全中断。
21:09	根因定位	问题已查明，官方开始实施针对性修复方案。
21:13	关键突破	Access 与 WARP 服务宣告恢复。错误率回落，伦敦节点重新启用。
21:35	重心转移	修复工作的重心转移至受影响的应用程序服务。
21:58	持续修复	针对应用程序服务的修复工作仍在紧张进行。
22:22	持续修复	团队继续努力恢复剩余受影响的服务客户。
22:34	里程碑	已部署变更，成功恢复仪表盘 (Dashboard) 服务。
22:42	故障修复	[终局] 官方确认问题已修复，事件状态标记为“已解决” (Resolved)。监控显示各项服务已恢复正常。

网站站长后续建议（恢复与检查）

鉴于故障已完全修复，建议站长从“紧急防御”转为“恢复验证”：

1. 回滚应急配置

如果在故障期间修改了配置，现在是时候改回来了：

DNS 设置：若此前切换为 <kbd>DNS Only</kbd>，请切回 <kbd>Proxied (代理)</kbd> 模式，以重新获得 DDoS 防护和 CDN 加速。
防火墙：关闭此前为源站临时开启的宽松防火墙规则。

2. 验证缓存与规则

检查页面规则：登录刚刚恢复的 Dashboard，确认 Page Rules 和 WAF 规则是否正常生效。
清理缓存：若用户仍反馈访问异常（如样式错乱），建议执行一次 Purge Cache (清除缓存)。

3. 记录与复盘

截图保存 Cloudflare Status 页面的故障记录，作为业务中断的依据。
企业版（Enterprise）用户请统计受影响时长，准备 SLA 赔偿申请材料。

深度观察：脆弱的互联网基石

此次事故从 20:03 持续至 22:42，历时约 2 小时 40 分钟。

值得注意的是，Cloudflare 采取了**“先保核心安全服务（WARP/Access）→ 再恢复管理控制台（Dashboard）→ 最后修复应用服务”的策略。这再次提醒企业级用户：在构建容灾架构时，不应假设 CDN 永远可用，必须建立独立于 CDN 之外的第三方监控与DNS 自动切换机制**，以应对未来的单一基础设施故障。

OVH 服务器自动抢购工具

Mon, 17 Nov 2025 00:00:00 GMT

OVH 可乐 - OVH 服务器自动抢购工具

🎯 纯 Go 语言编写的 OVH 独立服务器自动监控和抢购工具，支持多账户、多机房、多配置并发监控。

✨ 主要特性

🚀 纯净抢购 - 无 Web 界面，纯命令行运行，资源占用极低
👥 多账户支持 - 同时监控多个 OVH 账户，互不干扰
🌍 多地区监控 - 支持监控多个数据中心（RBX、GRA、SBG 等）
⚙️ 灵活配置 - 支持自定义硬件配置选项（带宽、内存、存储）
🔥 热重载 - 修改配置文件后自动生效，无需重启
💨 高并发抢单 - 发现有货时使用多个并发快速下单
🔍 智能监控 - 并发检查 + 随机延迟，避免 API 限流
📱 Telegram 通知 - 支持 Telegram Bot 实时通知
🛡️ 线程安全 - 使用 RWMutex 保证多账户并发安全

📦 快速开始

1. 下载

# 克隆项目
git clone https://github.com/gokele/OVH
cd OVH
# 运行
./ovh-sniper

::github{repo="gokele/OVH"}

2. 配置文件

编辑 config.json，填入你的 OVH API 凭据。

⚙️ 配置说明

监控配置 (monitor)

参数	说明	默认值	推荐值
`check_interval`	每隔几秒检查一次库存	5	3-10 秒
`check_concurrency`	每个账户同时检查几个目标（避免请求过多）	3	3-5
`order_concurrency`	发现有货后同时下几个订单	10	5-20
`random_delay_min`	随机延迟最小值，避免被限流（毫秒）	100	50-200ms
`random_delay_max`	随机延迟最大值（毫秒）	500	300-1000ms

示例配置：

{
  "monitor": {
    "check_interval": 5,
    "check_concurrency": 3,
    "order_concurrency": 10,
    "random_delay_min": 100,
    "random_delay_max": 500
  }
}

Telegram 通知配置

{
  "telegram": {
    "enabled": false,
    "bot_token": "",
    "chat_id": ""
  }
}

如何获取 Telegram 配置：

创建 Bot：与 @BotFather 对话，发送 /newbot 创建机器人
获取 Token：BotFather 会给你一个 bot_token
获取 Chat ID：
- 与你的 Bot 发送任意消息
- 访问：https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates
- 在返回的 JSON 中找到 chat.id

账户配置 (accounts)

API 端点说明：

端点	地区	API 地址
`ovh-eu`	欧洲	https://eu.api.ovh.com/createToken/
`ovh-ca`	加拿大	https://ca.api.ovh.com/createToken/
`ovh-us`	美国	https://us.api.ovh.com/createToken/

如何获取 API 凭据：

访问对应地区的 API Token 创建页面
设置权限：
- GET /dedicated/server/*
- POST /order/*
- PUT /order/*
点击创建，保存 Application Key、Application Secret、Consumer Key

示例配置：

{
  "accounts": [
    {
      "name": "主账户",
      "endpoint": "ovh-eu",
      "app_key": "YOUR_APP_KEY",
      "app_secret": "YOUR_APP_SECRET",
      "consumer_key": "YOUR_CONSUMER_KEY",
      "ovh_subsidiary": "IE",
      "enabled": true,
      "targets": [...]
    }
  ]
}

OVH Subsidiary 说明

ovh_subsidiary 字段决定账户的地区和税率，不同地区的价格和服务条款可能不同。

常用代码：

代码	国家/地区	说明
`IE`	爱尔兰	欧洲默认地区
`FR`	法国	法国本土
`DE`	德国	德国本土
`ES`	西班牙	西班牙本土
`GB`	英国	英国本土
`IT`	意大利	意大利本土
`NL`	荷兰	荷兰本土
`PL`	波兰	波兰本土
`PT`	葡萄牙	葡萄牙本土
`CA`	加拿大	加拿大地区
`US`	美国	美国地区

注意事项：

如果不设置，默认使用 IE（爱尔兰）
ovh_subsidiary 必须与你的账户地区匹配
不同地区的价格、税率、服务条款可能不同

监控目标配置 (targets)

参数详解：

参数	说明	示例
`name`	目标名称，用于日志识别	`"KS-LE-B NVMe 高配"`
`plan_code`	产品代码，在 OVH 官网查看	`"26skleb01-v1"`
`datacenters`	机房列表<br>• 空数组 `[]` = 监控所有机房<br>• 指定机房 `["rbx", "gra"]` = 只监控这些机房	`["rbx", "gra", "sbg"]`
`auto_order`	• `true` = 有货自动下单<br>• `false` = 只监控通知	`true`
`quantity`	有货时抢购几台	`1` 或 `2`
`options`	硬件升级选项，空数组表示默认配置	见下方

常用机房代码：

代码	机房名称	位置
`rbx`	Roubaix	法国鲁贝
`gra`	Gravelines	法国格拉夫林
`sbg`	Strasbourg	法国斯特拉斯堡
`bhs`	Beauharnois	加拿大博阿尔努瓦

硬件配置选项示例：

{
  "options": [
    "bandwidth-500-26skle",
    "ram-32g-ecc-2400-26skleb01-v1",
    "softraid-2x450nvme-26skleb01-v1"
  ]
}

如何查找配置选项代码：

访问 OVH API 文档：https://eu.api.ovh.com/console/
使用接口：GET /order/cart/{cartId}/eco/options?planCode={planCode}
查看返回的可用选项列表

完整示例：

{
  "targets": [
    {
      "name": "KS-LE-B 默认配置",
      "plan_code": "26skleb01-v1",
      "datacenters": ["rbx", "gra"],
      "auto_order": true,
      "quantity": 1,
      "options": []
    },
    {
      "name": "KS-LE-B NVMe 高配",
      "plan_code": "26skleb01-v1",
      "datacenters": [],
      "auto_order": true,
      "quantity": 2,
      "options": [
        "bandwidth-500-26skle",
        "ram-32g-ecc-2400-26skleb01-v1",
        "softraid-2x450nvme-26skleb01-v1"
      ]
    },
    {
      "name": "只监控不下单",
      "plan_code": "26skleb01-v1",
      "datacenters": ["rbx"],
      "auto_order": false,
      "quantity": 1,
      "options": []
    }
  ]
}

📋 完整配置示例

{
  "monitor": {
    "check_interval": 5,
    "check_concurrency": 3,
    "order_concurrency": 10,
    "random_delay_min": 100,
    "random_delay_max": 500
  },

  "telegram": {
    "enabled": true,
    "bot_token": "123456789:ABCdefGHIjklMNOpqrsTUVwxyz",
    "chat_id": "123456789"
  },

  "accounts": [
    {
      "name": "主账户",
      "endpoint": "ovh-eu",
      "app_key": "your_app_key",
      "app_secret": "your_app_secret",
      "consumer_key": "your_consumer_key",
      "ovh_subsidiary": "IE",
      "enabled": true,
      "targets": [
        {
          "name": "KS-LE-B 默认配置",
          "plan_code": "26skleb01-v1",
          "datacenters": ["rbx", "gra"],
          "auto_order": true,
          "quantity": 1,
          "options": []
        }
      ]
    },

    {
      "name": "备用账户",
      "endpoint": "ovh-eu",
      "app_key": "another_app_key",
      "app_secret": "another_app_secret",
      "consumer_key": "another_consumer_key",
      "ovh_subsidiary": "FR",
      "enabled": false,
      "targets": [
        {
          "name": "备用目标",
          "plan_code": "26skleb01-v1",
          "datacenters": ["gra"],
          "auto_order": true,
          "quantity": 1,
          "options": []
        }
      ]
    }
  ]
}

🚀 运行逻辑

监控架构

多账户并发监控：
├── 账户1 (独立协程)
│   ├── 并发检查目标1 ──┐
│   ├── 并发检查目标2   │ 最多 3 个并发 (check_concurrency)
│   ├── 并发检查目标3   │ 每次检查前随机延迟 100-500ms
│   └── 并发检查目标4 ──┘
│   └── 发现有货 ──> 开启 10 个并发抢单 (order_concurrency)
│
├── 账户2 (独立协程)
│   ├── 并发检查目标1 ──┐
│   └── 并发检查目标2   │ 独立运行，互不干扰
│   └── 发现有货 ──> 开启 10 个并发抢单
│
└── 账户3 (独立协程)
    └── ...

工作流程

初始化
- 加载配置文件 config.json
- 为每个启用的账户创建 OVH API 客户端
- 为每个账户启动独立的监控协程
监控阶段
- 每个账户独立运行，互不干扰
- 使用并发检查该账户的所有目标
- 每次检查前随机延迟，避免 API 限流
- 检测到库存状态变化时触发通知
下单阶段
- 检测到 unavailable → available 时触发
- 如果 auto_order: true，立即开启高并发抢单
- 使用信号量控制并发数，避免请求过多
- 实时记录成功/失败数量
热重载
- 监控 config.json 文件变化
- 检测到修改后自动重新加载配置
- 清空旧的监控状态
- 重新初始化所有客户端

📊 日志说明

运行时的日志输出示例：

🎯 OVH 可乐 - 抢购程序 (支持热重载)
========================================
2025/11/17 16:32:00 ✅ 从 config.json 加载了 1 个账户
========================================
👥 账户数量: 1 个
📊 监控目标: 2 个
⏱️  检查间隔: 5 秒
🔍 检查并发: 3
💨 下单并发: 10
⏲️  随机延迟: 100-500 毫秒
📱 Telegram 通知: 未启用

📋 监控目标列表:

  账户: 主账户 (ovh-eu)
    1. 24rise012 | 机房: 所有机房 | 配置: [softraid-2x512nvme] | 自动下单: ✅ | 数量: 2
    2. 26skleb01-v1 | 机房: 所有机房 | 配置: 默认配置 | 自动下单: ✅ | 数量: 10
========================================
2025/11/17 16:32:00 📋 已启用 config.json 热重载
2025/11/17 16:32:00 🔥 配置热重载已启用，修改 config.json 后自动生效
2025/11/17 16:32:00 🚀 监控已启动
2025/11/17 16:32:00 🔍 开始监控账户: 主账户
2025/11/17 16:32:00 🔍 [主账户] 正在检查 24rise012 的可用性...
2025/11/17 16:32:00 🔍 [主账户] 正在检查 26skleb01-v1 的可用性...
2025/11/17 16:32:02 🎉 [主账户] 24rise012@bhs 有货了！(配置: ram-128g-ecc-2933+softraid-2x512nvme, 状态: 72H)
2025/11/17 16:32:02 🎉 [主账户] 24rise012@waw 有货了！(配置: ram-128g-ecc-2933+softraid-2x512nvme, 状态: 1H-low)
2025/11/17 16:32:02 🛒 [主账户] 24rise012@bhs 开始下单 1 台 (配置: ram-128g-ecc-2933 + softraid-2x512nvme)
2025/11/17 16:32:02 🛒 [主账户] 24rise012@waw 开始下单 1 台 (配置: ram-128g-ecc-2933 + softraid-2x512nvme)
2025/11/17 16:32:05 🔍 [主账户] 正在检查 26skleb01-v1 的可用性...
2025/11/17 16:32:10 ✅ 订单创建成功！订单号: 238869343, 价格: 88.99 €
2025/11/17 16:32:10 🔍 [主账户] 正在检查 26skleb01-v1 的可用性...
2025/11/17 16:32:10 ✅ 订单创建成功！订单号: 238869344, 价格: 88.99 €
2025/11/17 16:32:10 🎊 [主账户] 24rise012 下单完成 - 机房: [bhs, waw] | 成功: 2 台 | 失败: 0 台 | 耗时: 8.44 秒 [进度: 2/2]
2025/11/17 16:32:15 🔍 [主账户] 正在检查 26skleb01-v1 的可用性...
^C
⚠️  收到退出信号，正在停止...
2025/11/17 16:32:18 ⏹️  账户 主账户 监控已停止
👋 再见！

🛡️ 安全建议

保护配置文件
- config.json 包含 API 凭据，请勿泄露
- 已添加到 .gitignore，不会被提交到 Git
API 权限控制
- 建议只给必要的 API 权限
- 定期更换 API 密钥
并发控制
- 不要设置过高的并发数，避免触发 OVH API 限流
- 推荐：check_concurrency: 3, order_concurrency: 10
随机延迟
- 必须启用随机延迟，避免被识别为机器人
- 推荐：100-500ms

🔧 常见问题

Q1: 如何查看可用的产品代码？

访问 OVH 官网的 Kimsufi/SoYouStart 页面，在产品详情页 URL 中可以找到 plan_code。

Q2: 如何查找硬件配置选项代码？

使用 OVH API Console：

GET /order/cart/{cartId}/eco/options?planCode={planCode}

Q3: 热重载不生效？

检查文件监控是否启动成功，如果看到 ⚠️ 启动配置监控失败，需要手动重启程序。

Q4: 提示 API 限流怎么办？

降低 check_concurrency 和 order_concurrency
增加 check_interval
增大随机延迟范围

📄 许可证

MIT License

🤝 贡献

欢迎提交 Issue 和 Pull Request！

🙏 致谢

基于原项目 OVH-BUY 的核心逻辑重写。

注意： 本工具仅供学习和个人使用，请遵守 OVH 服务条款，合理使用 API。

Docker 部署 Vertex 进行刷流

Sat, 15 Nov 2025 00:00:00 GMT

项目介绍

Vertex 是一个专为 PT（私有种子网络）玩家设计的追剧刷流一体化综合管理工具。它集成了多种功能，帮助用户高效地管理和追踪剧集，特别适合喜欢使用 PT 的用户群体。项目基于 JavaScript、Vue.js 和 Less 开发，使用 Node.js 作为后端技术栈，并支持 Docker 容器化部署，简化了环境配置和依赖管理。

主要功能

追剧管理：帮助用户追踪和管理剧集进度。
刷流支持：优化 PT 网络中的刷流任务，提升效率。
自动化任务：通过 Webhook 实现任务触发和通知。
媒体库集成：支持与 Emby 等媒体库工具集成，方便播放和管理

部署

其实官网已经有完善的部署

apt update -y &&
apt upgrade -y &&
apt install curl -y &&
curl -fsSL https://get.docker.com -o get-docker.sh &&
sh get-docker.sh &&
timedatectl set-timezone Asia/Shanghai &&
mkdir -p /root/vertex &&
chmod 777 /root/vertex &&
docker run -d --name vertex --restart unless-stopped --network host -v /root/vertex:/vertex -e TZ=Asia/Shanghai lswl/vertex:stable

访问Vertex

访问vertex存储路径/root/vertex/data/ 鼠标双击password查看初始密码。

 cat /root/vertex/data/password

如果和上面一眼，默认vertex服务监听的3000端口
访问 ip:3000
默认用户admin，密码是上面获取的

配置

我这里就不在赘述一些qb的连接配置，TG的通知什么的。
Vertex的基础安装参照：https://wiki.vertex.icu（感谢栗佬）
下面部分配置来自互联网备份。有的原作者已经删帖，无法引用。
根据自身盒子io情况，硬盘大小和刷的站点，勾选删种和修改里面的参数，不要直接套用。

黑车1

(maindata, torrent) => {
  const categoryList = ["keep"];
  let ruleData = [
    { down: 10, up: 2 },
    { down: 5, up: 1 },
  ];
  const { state, category, uploadSpeed, downloadSpeed } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  for (const rule of ruleData) {
    if (
      state == "downloading" &&
      downloadSpeed >= util.calSize(rule.down, "MiB") &&
      uploadSpeed <= util.calSize(rule.up, "MiB")
    ) {
      return true;
    }
  }

  return false;
};

黑车2

(maindata, torrent) => {
  const categoryList = ["keep"];
  const { state, category, uploadSpeed, downloadSpeed } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    state == "downloading" &&
    downloadSpeed >= util.calSize(10, "MiB") &&
    downloadSpeed / uploadSpeed >= 1.8
  ) {
    return true;
  }

  return false;
};

第一版的黑车是通过写死的key和value然后for循环去取里面的数值，简单粗暴，但是在2.5g管以及10g管的情况下，判断就用不上了，维护成本过高。第二版的黑车主要思路是，下载速度除上传速度当大于1.8这区间的时候进行删种。分成写两个的原因是黑车1是针对刚开始发车追车时候判断的，避免一开始下载10上传5这种被误删。

无效做种

(maindata, torrent) => {
  const categoryList = ["keep"];
  const stateList = ["uploading", "stalledUP"];
  const { state, uploadSpeed, category, completedTime } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    stateList.indexOf(state) !== -1 &&
    uploadSpeed <= util.calSize(512, "KiB") &&
    moment().unix() - completedTime >= 5400
  ) {
    return true;
  }

  return false;
};

无效做种是针对做种超过一个半小时的时候，并且上传小于512kb的种子。如果下载或者做种的种子本身过多，可以进行修改。

分享率

(maindata, torrent) => {
  const categoryList = [
    "keep",
    "chdbits",
    "ourbits",
    "hdhome",
    "lemonhd",
    "pter",
    "audiences",
    "hdchina",
    "hdsky",
    "hddolby",
  ];
  const { uploaded, size, category } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (uploaded / size >= 3) {
    return true;
  }

  return false;
};

分享率就是3倍跳车，具体要改什么站点，就按格式改categoryList里的参数即可，每个人根据站点以及vip情况自行修改。

最长下载时间

(maindata, torrent) => {
  const categoryList = ["keep"];
  const stateList = ["downloading", "stalledDL"];
  const { state, addedTime, category, uploadSpeed } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    stateList.indexOf(state) !== -1 &&
    moment().unix() - addedTime >= 57600 &&
    uploadSpeed <= util.calSize(5, "MiB")
  ) {
    return true;
  }

  return false;
};

针对那些16个小时内没有下完的龟速种子，大部分情况下都是发种人盒子崩了什么的。上传速度如果大于5m的，不删除。

慢车持续40s

(maindata, torrent) => {
  const categoryList = ["keep"];
  const stateList = ["downloading", "stalledDL"];
  const { state, uploadSpeed, progress, category, leecher } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    (moment().hour() >= 0 && moment().hour() <= 8) ||
    maindata.leechingCount <= 10 ||
    leecher >= 100
  ) {
    return false;
  }
  if (
    stateList.indexOf(state) !== -1 &&
    uploadSpeed <= util.calSize(250, "KiB") &&
    progress >= 0.1
  ) {
    return true;
  }

  return false;
};

1.在0点-8点这个时间段，种子数量小于10个时跳过，下载人数大于100时跳过，保证夜间不误删，能有足够的种子。
2.进度大于10%，上传速度小于250kb持续40的跳车。

长时间未开始

(maindata, torrent) => {
  const categoryList = ["keep"];
  const { state, category, progress, addedTime } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    moment().hour() >= 0 &&
    moment().hour() <= 8 &&
    state == "stalledDL" &&
    progress <= 0.05 &&
    moment().unix() - addedTime >= 18000
  ) {
    return true;
  }
  if (
    state == "stalledDL" &&
    progress <= 0.05 &&
    moment().unix() - addedTime >= 14400
  ) {
    return true;
  }

  return false;
};

删除0-8点这个时间段，超过五小时并且进度小于5%的种子。删除常规时间段，超过四小时并且进度小于5%的种子

下载人数少

(maindata, torrent) => {
  const categoryList = ["keep"];
  const stateList = ["downloading", "stalledDL"];
  const { state, category, leecher, uploadSpeed, addedTime } = torrent;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (
    stateList.indexOf(state) !== -1 &&
    leecher <= 10 &&
    uploadSpeed <= util.calSize(500, "KiB") &&
    moment().unix() - addedTime >= 900
  ) {
    return true;
  }

  return false;
};

删除下载人数小于10，上传速度低于500kb，添加超过20分钟的非潜力种。

空1小时跳车

(maindata, torrent) => {
  const categoryList = ["keep"];
  const { state, category, progress } = torrent;
  const { eta } = torrent.originProp;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (state == "downloading" && category == 'hdsky' && progress >= 0.05 && progress <= 0.2 && (eta / 60) <= 70) {
    return true;
  }

  return false;
};

持续时间10-15s

瓷器非免跳车

(maindata, torrent) => {
  const categoryList = ["keep"];
  const { state, category, addedTime } = torrent;
  const { num_incomplete } = torrent.originProp;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (state == 'downloading' && category == 'hdchina' && moment().unix() - addedTime >= 180 && num_incomplete <= 12) {
    return true;
  }

  return false;
};

qb的分类必须和下方的判断一致。默认使用hdchina

岛非免跳车

(maindata, torrent) => {
  const categoryList = ["keep"];
  const { state, category, addedTime } = torrent;
  const { num_incomplete } = torrent.originProp;
  if (categoryList.indexOf(category) !== -1) {
    return false;
  }
  if (state == 'downloading' && category == 'chdbits' && moment().unix() - addedTime >= 180 && num_incomplete <= 40) {
    return true;
  }

  return false;
};

qb的分类必须和下方的判断一致。默认使用chdbits

剩余空间删种

我这里是10g，你需要根据你的盒子自己改

根据种子的流行程度动态删除种子

超过七天才可能删除符合规则的种子，删种按分享率删除，每在3的基础上多0.1分享率就多留一天。

(maindata, torrent) => {
const config = {
  deleteHours: 7 * 24 *3600,    // 超时才删种的时间
  ratioThreshold: 3,          // 基础分享率一阈值（上传量 / 种子大小）
  enableLogging: false,        // 是否启用日志记录
};
    const moment = require('moment'); // 确保 moment 模块可用
    const now = moment().unix();

  // 辅助函数：向 /vertex/log22/log.txt 中追加日志信息
function logFailure(message) {
  if (!config.enableLogging) return; // 如果未启用日志记录，直接返回
  const fs = require('fs');
  const path = require('path');
  const logFilePath = '/vertex/log22/log.txt';
  const logDir = path.dirname(logFilePath);
  if (!fs.existsSync(logDir)) {
    fs.mkdirSync(logDir, { recursive: true });
  }
  const logMessage = `${new Date().toISOString()} - ${message}\n`;
  fs.appendFileSync(logFilePath, logMessage);
}

  // 计算下载时间和分享率
 const downloadTime = now - torrent.addedTime;
 const downloadTime2 = downloadTime - config.deleteHours;
 const extraDays = Math.max(0, Math.floor(downloadTime2 / 86400)); // 每天86400秒
  // 动态调整分享率上限
 const ratioLimit = config.ratioThreshold + extraDays * 0.1;

    // 检查种子是否完成下载
    if (now - torrent.completedTime < config.deleteHours ) {
    return false; // 不删除种子
    }
    if (torrent.completedTime > 0 && torrent.ratio < ratioLimit && torrent.uploadSpeed < 10* 1024) {
            return true; // 删除种子
    }
    return false; // 不删除种子
};

适用于Hz Cloud 馒头盒子

效果：适应馒头标盒机制，对于小流量的机器不当冤大头额外上传不计入上传流量的部分。同时又不暂停，可以获取魔力。规则：不实际删除种子，超过分享率后设置限速100k，两天后解除限速（适用于馒头盒子机制：新种标盒，两天盒子规则消失，盒子规则限制时间内只计算3倍种子大小上传量，标盒过期后取消限制）

// 参数：
//   maindata：qBittorrent 的全局数据
//   torrent：当前种子的信息
(maindata, torrent) => {
  // 统一配置对象（所有时间单位均为小时）
const config = {
  pauseThresholdHours: 72,    // 当种子添加时间小于72小时（3天）且分享率大于阈值时触发暂停
  resumeThresholdHours: 72,   // 当种子添加时间大于72小时时用于恢复（这里与暂停阈值相同）
  ratioThreshold: 3,          // 分享率一阈值（上传量 / 种子大小 > 3时触发操作）
  enableLogging: false,        // 是否启用日志记录
  downloaderId: 'e88e88dd',     // 下载器ID，指定适用的下载器ID
  speedLimit: 100 * 1024,            // 限速值（单位：KB/s）
};

// 辅助函数：向 /vertex/log22/log.txt 中追加日志信息
function logFailure(message) {
  if (!config.enableLogging) return; // 如果未启用日志记录，直接返回
  const fs = require('fs');
  const path = require('path');
  const logFilePath = '/vertex/log22/log.txt';
  const logDir = path.dirname(logFilePath);
  if (!fs.existsSync(logDir)) {
    fs.mkdirSync(logDir, { recursive: true });
  }
  const logMessage = `${new Date().toISOString()} - ${message}\n`;
  fs.appendFileSync(logFilePath, logMessage);
}

// 获取下载器ID和下载器对象
  const downloaderId = config.downloaderId;
  const client = global.runningClient[downloaderId];
if (!client) {
  logFailure(`未找到下载器 ${downloaderId}`);
  return false;
}

  const moment = require('moment'); // 确保 moment 模块可用
  const now = moment().unix();
  // 计算种子添加后的持续时间（单位：秒）
  const ageSeconds = now - torrent.addedTime;
  // 根据配置中的小时数转换为秒数
  const thresholdSeconds = config.pauseThresholdHours * 3600;
  const thresholdSeconds2 = config.resumeThresholdHours * 3600;
  // 计算“分享率一”：上传量 / 种子大小
  const shareRatio1 = torrent.size > 0 ? torrent.uploaded / torrent.size : 0;

 // 如果种子添加时间小于阈值（72小时）且分享率大于阈值，则限速种子
  if (ageSeconds < thresholdSeconds && shareRatio1 > config.ratioThreshold) {
    client.setSpeedLimit(torrent.hash, 'upload', config.speedLimit)
      .then(() => {
        logFailure(`限速种子成功: ${torrent.name}`);
      })
      .catch(err => {
        logFailure(`限速种子 ${torrent.name} 失败: ${err}`);
      });
  }

  // 如果种子当前已限速且添加时间大于阈值，则取消限速
  if (ageSeconds > thresholdSeconds2) {
    client.setSpeedLimit(torrent.hash, 'upload', 0)  // 设置为0表示取消限速
      .then(() => {
        logFailure(`取消限速成功: ${torrent.name}`);
      })
      .catch(err => {
        logFailure(`取消限速 ${torrent.name} 失败: ${err}`);
      });
  }

  // 始终返回 false，不会执行删种操作

  return false;
};

RSS规则

可以根据更多规则选择要刷的种子，对于小盘鸡友好，完全不会超过设置的保种体积，同时计算体积带矫正，和性能缓解，2分钟前算过体积就不重新计算了，不会每个种子都算一遍全盘种子大小。可以限制下载数量，种子大小，文件名等，可以自定义开启关闭功能进行组合。15G小盘鸡也能刷了，添加种子前计算下载器中种子的大小，这个不是vertex自带的剩余空间大小，那个实际因为没下完种子可能会超过空间导致占满空间，当然可用提前分配缓解，但是还是不符合需求，这个可以直接实现完全不会超过设置空间。可以说是非常人性化了。注意要设置相应下载器的id。

(torrent) => {
  // 配置部分：这些部分可以自定义
  const config = {
    downloaderId: 'e88e88dd',             // 下载器ID，指定适用的下载器ID
    enableLogging: false,                  // 是否启用日志记录
    enableSeedingVolumeLimit: true,        // 是否启用保种体积限制
    seedingVolumeLimit: 50 * 1024 * 1024 * 1024, // 保种体积限制（单位：字节），例如14GB
    enableTaskCountLimit: true,            // 是否启用下载器任务数量限制
    taskCountLimit: 200,                    // 下载器任务数量限制，设置最大任务数
    enableSizeLimit: true,                 // 是否启用种子大小限制
    sizeLimitRange: [1 * 1024 * 1024 * 1024, 10 * 1024 * 1024 * 1024],  // 种子大小范围（单位：字节）
    enableFileNameMatchLimit: false,        // 是否启用文件名匹配限制
    fileNameRegex: /sample|test/i          // 文件名正则匹配，支持正则表达式
  };

  const fs = require('fs');
  const path = require('path');

  // 获取本地时间字符串
  function getLocalTimeString() {
    return new Date().toLocaleString('zh-CN', { hour12: false });
  }

  // 辅助函数：向 /vertex/log22/log.txt 中追加日志信息
  function logFailure(message) {
    if (!config.enableLogging) return; // 如果未启用日志记录，直接返回
    const logFilePath = '/vertex/log22/log.txt';
    const logDir = path.dirname(logFilePath);
    if (!fs.existsSync(logDir)) {
      fs.mkdirSync(logDir, { recursive: true });
    }
    const now = getLocalTimeString();
    fs.appendFileSync(logFilePath, `[${now}] ${message}\n`);
  }

  // 获取下载器ID和下载器对象
  const downloaderId = config.downloaderId; // 当前下载器ID
  const client = global.runningClient[downloaderId];
  if (!client) {
    logFailure(`未找到下载器 ${downloaderId}`);
    return false;
  }

  // 2. 保种体积限制：先检查 /vertex/${downloaderId}/size.txt 中存储的时间和累计体积
  if (config.enableSeedingVolumeLimit) {
    const sizeFilePath = `/vertex/${downloaderId}/size.txt`;
    const sizeDir = path.dirname(sizeFilePath);
    if (!fs.existsSync(sizeDir)) {
      fs.mkdirSync(sizeDir, { recursive: true });
    }
    let currentCumulative = 0;  // 当前累计体积（字节）
    let fileTimestamp = 0;      // 文件中记录的时间（秒）
    const now = Math.floor(Date.now() / 1000); // 当前时间，单位：秒

    // 尝试读取文件，如果存在则解析内容（格式：timestamp,cumulativeSize）
    if (fs.existsSync(sizeFilePath)) {
      try {
        const data = fs.readFileSync(sizeFilePath, 'utf8').trim();
        if (data) {
          const parts = data.split(',');
          if (parts.length === 2) {
            fileTimestamp = Number(parts[0]);
            currentCumulative = Number(parts[1]);
          }
        }
      } catch (err) {
        logFailure(`读取 size.txt 失败: ${err}`);
      }
    } else {
      // 如果文件不存在，则计算累计体积并创建文件
      client.maindata.torrents.forEach(t => {
        currentCumulative += Number(t.size || 0);
      });
      fileTimestamp = now;
      try {
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
      } catch (err) {
        logFailure(`写入 size.txt 失败: ${err}`);
      }
    }

    // 如果下载器中没有任务，则重置累计体积为 0
    if (!client.maindata.torrents || client.maindata.torrents.length === 0) {
      currentCumulative = 0;
      fileTimestamp = now;
      try {
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
      } catch (err) {
        logFailure(`重置 size.txt 失败: ${err}`);
      }
    }
    // 如果文件中的时间超过2分钟，则重新计算累计体积
    else if (now - fileTimestamp > 120) {
      currentCumulative = 0;
      client.maindata.torrents.forEach(t => {
        currentCumulative += Number(t.size || 0);
      });
      fileTimestamp = now;
      try {
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
      } catch (err) {
        logFailure(`更新 size.txt 失败: ${err}`);
      }
    }

    // 确保 torrent.size 为数值
    const torrentSize = Number(torrent.size);

    // 将累计体积加上当前种子的大小，与保种体积限制比较
    if ((currentCumulative + torrentSize) >= config.seedingVolumeLimit) {
      logFailure(`保种体积限制不通过：累计体积 ${currentCumulative} + 当前种子 ${torrentSize} 超过限制 ${config.seedingVolumeLimit}`);
      return false;
    }
  }

  // 3. 下载器任务数量限制：检查下载器当前任务数量
  if (config.enableTaskCountLimit) {
    if (client.maindata.torrents.length >= config.taskCountLimit) {
      logFailure(`任务数量限制不通过：当前任务数量 ${client.maindata.torrents.length} 超过限制 ${config.taskCountLimit}`);
      return false;
    }
  }

  // 4. 种子大小限制：检查种子的大小是否在规定范围内
  if (config.enableSizeLimit) {
    const size = Number(torrent.size);
    if (size < config.sizeLimitRange[0] || size > config.sizeLimitRange[1]) {
      logFailure(`种子大小限制不通过：种子大小 ${size} 不在范围 ${config.sizeLimitRange[0]} - ${config.sizeLimitRange[1]}`);
      return false;
    }
  }

  // 5. 文件名匹配限制：检查文件名是否符合正则匹配
  if (config.enableFileNameMatchLimit) {
    const fileName = torrent.name;
    if (!fileName.match(config.fileNameRegex)) {
      logFailure(`文件名匹配限制不通过：种子名称 "${fileName}" 未匹配正则 ${config.fileNameRegex}`);
      return false;
    }
  }

  // 如果所有条件都满足，则表示添加该种子。
  // 在返回 true 前，如果启用了保种体积限制，则更新 /vertex/${downloaderId}/size.txt
  if (config.enableSeedingVolumeLimit) {
    const sizeFilePath = `/vertex/${downloaderId}/size.txt`;
    let cumulative = 0;
    let fileTimestamp = 0;
    if (fs.existsSync(sizeFilePath)) {
      try {
        const data = fs.readFileSync(sizeFilePath, 'utf8').trim();
        if (data) {
          const parts = data.split(',');
          if (parts.length === 2) {
            fileTimestamp = Number(parts[0]);
            cumulative = Number(parts[1]);
          }
        }
      } catch (err) {
        logFailure(`读取 size.txt 更新部分失败: ${err}`);
      }
    }
    cumulative += Number(torrent.size);
    try {
      fs.writeFileSync(sizeFilePath, `${fileTimestamp},${cumulative}`);
    } catch (err) {
      logFailure(`更新 size.txt 失败: ${err}`);
    }
  }

  return true;
};

🚀 本站已正式从 WordPress 迁移至 Astro

Fri, 14 Nov 2025 00:00:00 GMT

亲爱的橘夏网访客：

为了提供更快的访问速度、更稳定的站点结构以及更舒适的阅读体验，橘夏网（www.juxw.com） 已于近日 完成从 WordPress 向 Astro 的全面迁移。

🛠️ 为什么选择 Astro？

迁移选择 Astro，是经过多方考虑后的技术升级，主要基于以下几点：

极致性能提升：Astro 默认零 JS 负载，让页面加载更迅速、体验更丝滑。
轻量与灵活：能以 Markdown / MDX 管理内容，写作更加专注高效。
前端可扩展性强：支持 React / Vue / Svelte 等框架的按需使用。
无需传统后台：摆脱数据库与插件负担，降低维护成本，提高安全性。

🔄 迁移期间的变更说明

部分旧文章仍在重新格式化，如遇排版不一致，后续会陆续修复。
旧站评论暂未迁移，未来将评估新的评论系统方案。
个别历史链接可能发生变动，若发现错误链接欢迎向我反馈。

📬 联系与反馈

如果你在访问过程中发现任何问题、页面错误或有建议，欢迎随时留言或联系我。
你的反馈将帮助橘夏网变得更好！

邮箱：admin@juxw.com

感谢你一直以来的支持与陪伴。
全新的橘夏网，期待为你带来更有温度的内容与体验。