Docker 部署 Vertex 进行刷流

其实我已经不刷了，把方案和配置留存记录一下。一些脚本在上一篇文章里。

首先我建议你需要买个盒子，大陆家宽刷流的省省还有付费买商人盒子之类的，一点意义没有。

项目介绍#

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

主要功能#

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

部署#

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

1
apt update -y &&
2
apt upgrade -y &&
3
apt install curl -y &&
4
curl -fsSL https://get.docker.com -o get-docker.sh &&
5
sh get-docker.sh &&
6
timedatectl set-timezone Asia/Shanghai &&
7
mkdir -p /root/vertex &&
8
chmod 777 /root/vertex &&
9
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查看初始密码。

1
 cat /root/vertex/data/password

如果和上面一眼，默认vertex服务监听的3000端口

访问 ip:3000

默认用户admin，密码是上面获取的

配置#

我这里就不在赘述一些qb的连接配置，TG的通知什么的。

Vertex的基础安装参照：https://wiki.vertex.icu（感谢栗佬）

下面部分配置来自互联网备份。有的原作者已经删帖，无法引用。

还有部分规则来自 Nodeseek-vertex刷流工具的规则

1
根据自身盒子io情况，硬盘大小和刷的站点，勾选删种和修改里面的参数，不要直接套用。

黑车1#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  let ruleData = [
4
    { down: 10, up: 2 },
5
    { down: 5, up: 1 },
6
  ];
7
  const { state, category, uploadSpeed, downloadSpeed } = torrent;
8
  if (categoryList.indexOf(category) !== -1) {
9
    return false;
10
  }
11
  for (const rule of ruleData) {
12
    if (
13
      state == "downloading" &&
14
      downloadSpeed >= util.calSize(rule.down, "MiB") &&
15
      uploadSpeed <= util.calSize(rule.up, "MiB")
16
    ) {
17
      return true;
18
    }
19
  }
20

21
  return false;
22
};

黑车2#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const { state, category, uploadSpeed, downloadSpeed } = torrent;
4
  if (categoryList.indexOf(category) !== -1) {
5
    return false;
6
  }
7
  if (
8
    state == "downloading" &&
9
    downloadSpeed >= util.calSize(10, "MiB") &&
10
    downloadSpeed / uploadSpeed >= 1.8
11
  ) {
12
    return true;
13
  }
14

15
  return false;
16
};

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

无效做种#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const stateList = ["uploading", "stalledUP"];
4
  const { state, uploadSpeed, category, completedTime } = torrent;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (
9
    stateList.indexOf(state) !== -1 &&
10
    uploadSpeed <= util.calSize(512, "KiB") &&
11
    moment().unix() - completedTime >= 5400
12
  ) {
13
    return true;
14
  }
15

16
  return false;
17
};

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

分享率#

1
(maindata, torrent) => {
2
  const categoryList = [
3
    "keep",
4
    "chdbits",
5
    "ourbits",
6
    "hdhome",
7
    "lemonhd",
8
    "pter",
9
    "audiences",
10
    "hdchina",
11
    "hdsky",
12
    "hddolby",
13
  ];
14
  const { uploaded, size, category } = torrent;
15
  if (categoryList.indexOf(category) !== -1) {
16
    return false;
17
  }
18
  if (uploaded / size >= 3) {
19
    return true;
20
  }
21

22
  return false;
23
};

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

最长下载时间#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const stateList = ["downloading", "stalledDL"];
4
  const { state, addedTime, category, uploadSpeed } = torrent;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (
9
    stateList.indexOf(state) !== -1 &&
10
    moment().unix() - addedTime >= 57600 &&
11
    uploadSpeed <= util.calSize(5, "MiB")
12
  ) {
13
    return true;
14
  }
15

16
  return false;
17
};

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

慢车持续40s#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const stateList = ["downloading", "stalledDL"];
4
  const { state, uploadSpeed, progress, category, leecher } = torrent;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (
9
    (moment().hour() >= 0 && moment().hour() <= 8) ||
10
    maindata.leechingCount <= 10 ||
11
    leecher >= 100
12
  ) {
13
    return false;
14
  }
15
  if (
16
    stateList.indexOf(state) !== -1 &&
17
    uploadSpeed <= util.calSize(250, "KiB") &&
18
    progress >= 0.1
19
  ) {
20
    return true;
21
  }
22

23
  return false;
24
};

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

长时间未开始#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const { state, category, progress, addedTime } = torrent;
4
  if (categoryList.indexOf(category) !== -1) {
5
    return false;
6
  }
7
  if (
8
    moment().hour() >= 0 &&
9
    moment().hour() <= 8 &&
10
    state == "stalledDL" &&
11
    progress <= 0.05 &&
12
    moment().unix() - addedTime >= 18000
13
  ) {
14
    return true;
15
  }
16
  if (
17
    state == "stalledDL" &&
18
    progress <= 0.05 &&
19
    moment().unix() - addedTime >= 14400
20
  ) {
21
    return true;
22
  }
23

24
  return false;
25
};

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

下载人数少#

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const stateList = ["downloading", "stalledDL"];
4
  const { state, category, leecher, uploadSpeed, addedTime } = torrent;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (
9
    stateList.indexOf(state) !== -1 &&
10
    leecher <= 10 &&
11
    uploadSpeed <= util.calSize(500, "KiB") &&
12
    moment().unix() - addedTime >= 900
13
  ) {
14
    return true;
15
  }
16

17
  return false;
18
};

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

空1小时跳车#

1
持续时间10-15s

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

12
  return false;
13
};

瓷器非免跳车#

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

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const { state, category, addedTime } = torrent;
4
  const { num_incomplete } = torrent.originProp;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (state == 'downloading' && category == 'hdchina' && moment().unix() - addedTime >= 180 && num_incomplete <= 12) {
9
    return true;
10
  }
11

12
  return false;
13
};

岛非免跳车#

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

1
(maindata, torrent) => {
2
  const categoryList = ["keep"];
3
  const { state, category, addedTime } = torrent;
4
  const { num_incomplete } = torrent.originProp;
5
  if (categoryList.indexOf(category) !== -1) {
6
    return false;
7
  }
8
  if (state == 'downloading' && category == 'chdbits' && moment().unix() - addedTime >= 180 && num_incomplete <= 40) {
9
    return true;
10
  }
11

12
  return false;
13
};

剩余空间删种#

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

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

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

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

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

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

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

适用于Hz Cloud 馒头盒子#

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

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

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

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

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

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

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

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

71
  return false;
72
};

RSS规则#

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

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

16
  const fs = require('fs');
17
  const path = require('path');
18

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

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

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

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

55
    // 尝试读取文件，如果存在则解析内容（格式：timestamp,cumulativeSize）
56
    if (fs.existsSync(sizeFilePath)) {
57
      try {
58
        const data = fs.readFileSync(sizeFilePath, 'utf8').trim();
59
        if (data) {
60
          const parts = data.split(',');
61
          if (parts.length === 2) {
62
            fileTimestamp = Number(parts[0]);
63
            currentCumulative = Number(parts[1]);
64
          }
65
        }
66
      } catch (err) {
67
        logFailure(`读取 size.txt 失败: ${err}`);
68
      }
69
    } else {
70
      // 如果文件不存在，则计算累计体积并创建文件
71
      client.maindata.torrents.forEach(t => {
72
        currentCumulative += Number(t.size || 0);
73
      });
74
      fileTimestamp = now;
75
      try {
76
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
77
      } catch (err) {
78
        logFailure(`写入 size.txt 失败: ${err}`);
79
      }
80
    }
81

82
    // 如果下载器中没有任务，则重置累计体积为 0
83
    if (!client.maindata.torrents || client.maindata.torrents.length === 0) {
84
      currentCumulative = 0;
85
      fileTimestamp = now;
86
      try {
87
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
88
      } catch (err) {
89
        logFailure(`重置 size.txt 失败: ${err}`);
90
      }
91
    }
92
    // 如果文件中的时间超过2分钟，则重新计算累计体积
93
    else if (now - fileTimestamp > 120) {
94
      currentCumulative = 0;
95
      client.maindata.torrents.forEach(t => {
96
        currentCumulative += Number(t.size || 0);
97
      });
98
      fileTimestamp = now;
99
      try {
100
        fs.writeFileSync(sizeFilePath, `${fileTimestamp},${currentCumulative}`);
101
      } catch (err) {
102
        logFailure(`更新 size.txt 失败: ${err}`);
103
      }
104
    }
105

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

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

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

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

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

142
  // 如果所有条件都满足，则表示添加该种子。
143
  // 在返回 true 前，如果启用了保种体积限制，则更新 /vertex/${downloaderId}/size.txt
144
  if (config.enableSeedingVolumeLimit) {
145
    const sizeFilePath = `/vertex/${downloaderId}/size.txt`;
146
    let cumulative = 0;
147
    let fileTimestamp = 0;
148
    if (fs.existsSync(sizeFilePath)) {
149
      try {
150
        const data = fs.readFileSync(sizeFilePath, 'utf8').trim();
151
        if (data) {
152
          const parts = data.split(',');
153
          if (parts.length === 2) {
154
            fileTimestamp = Number(parts[0]);
155
            cumulative = Number(parts[1]);
156
          }
157
        }
158
      } catch (err) {
159
        logFailure(`读取 size.txt 更新部分失败: ${err}`);
160
      }
161
    }
162
    cumulative += Number(torrent.size);
163
    try {
164
      fs.writeFileSync(sizeFilePath, `${fileTimestamp},${cumulative}`);
165
    } catch (err) {
166
      logFailure(`更新 size.txt 失败: ${err}`);
167
    }
168
  }
169

170
  return true;
171
};

Hetzner Cloud 自动检测流量并删除开机脚本#

实时监测Hetzner流量状况，超过预设值时自动删除并用制定快照创建新机器。

属于滥用，我就不公开了，想写的自己写吧。