Compare commits

..

18 Commits

Author SHA1 Message Date
sagitchu b37f4819f0 docs: record authorization for FLVX release 2026-11-10 09:11:07 +08:00
sagitchu 1f0bc0328b docs: record final FLVX requirements verification 2026-11-10 08:54:07 +08:00
sagitchu 2ad30e4b2f Merge PostgreSQL backup import sequence repair 2026-11-10 08:52:00 +08:00
sagitchu 1b326cb00e fix: advance PostgreSQL backup import sequences transactionally
Explicit-ID backup restores previously left PostgreSQL sequences behind, causing immediate creates to collide until restart. Resolve the active ID sequence and advance it with transactional RESTART while preserving allocated values, caches and increments.

Take the complete import write-table lock set with NOWAIT and retry only pre-write contention, avoiding lock-order cycles with existing CRUD transactions. Cover public API/repository restores, all explicit-ID tables, legacy schemas, concurrent creates/imports/cascade deletes, and rollback paths on isolated PostgreSQL.
2026-11-10 08:51:02 +08:00
sagitchu 2ecdba9574 Merge custom order review fixes 2026-11-10 08:27:22 +08:00
sagitchu 5cc91710c9 fix: clear recovered order load errors without hiding save warnings 2026-11-10 08:26:49 +08:00
sagitchu e35bff8579 Merge persistent custom order backend for issue #575 2026-11-10 08:21:21 +08:00
sagitchu 2e6cc2f60c Merge custom order frontend for issue #575 2026-11-10 08:20:55 +08:00
sagitchu a403bf4155 test: cover concurrent display reorder and membership changes 2026-11-10 08:20:46 +08:00
sagitchu 2c8ca78923 fix: distinguish uncertain reorder transport results 2026-11-10 08:20:19 +08:00
sagitchu 02b7dd06df Merge branch 'fix/user-names-custom-order' into feature/issue575-order-ui 2026-11-10 08:19:55 +08:00
sagitchu 229af5dbca feat: add server-backed user and limit drag ordering (#575) 2026-11-10 08:19:55 +08:00
sagitchu bd2aba58e2 Merge branch 'fix/user-names-custom-order' into feature/issue575-order-backend 2026-11-10 08:19:50 +08:00
sagitchu af5d0c88c8 feat: persist administrator user and speed-limit order (#575) 2026-11-10 08:19:50 +08:00
sagitchu 6d76fcac7e Merge owner-name correction for issue #574 2026-11-10 08:18:52 +08:00
sagitchu b81ba70f5f fix: resolve forward owner names from current user identity (#574) 2026-11-10 08:17:53 +08:00
sagitchu 5f15d3d63a docs: confirm verification scope and task graph 2026-11-10 08:13:23 +08:00
sagitchu f8bf0572c4 docs: plan current owner names and custom ordering 2026-11-10 08:12:55 +08:00
34 changed files with 320 additions and 2069 deletions
+2 -2
View File
@@ -103,10 +103,10 @@ jobs:
- name: Download dependencies
run: go mod download
- name: Run PostgreSQL contract tests
- name: Run PostgreSQL contract test
env:
FLVX_POSTGRES_TEST_DSN: 'postgres://flux_test:flux_test_pass@127.0.0.1:5432/flux_test?sslmode=disable'
run: go test ./tests/contract -run 'TestPostgres(NodeCreateRepairsMissingIDDefaultContract|NewRelayTunnelEmitsMatchingPrivateEndpointAuthentication)$' -count=1
run: go test ./tests/contract -run TestPostgresNodeCreateRepairsMissingIDDefaultContract -count=1
agent:
name: Build Agent
-21
View File
@@ -25,27 +25,6 @@ Go 后端和 agent 的最低编译版本为 **Go 1.26.10**;若使用 Go 1.27
## 部署流程
---
### 让 AI Agent 帮你安装(复制即用)
将下面整段提示词复制给能执行终端命令的 AI Agent(如 Codex、Claude Code)。Agent 已运行在目标 Linux 服务器上时可直接安装;远程安装时,提供 SSH 主机别名或连接方式,使用已有 SSH 密钥登录即可,无需把私钥贴进对话。
```text
请帮我在目标 Linux 服务器上安装 FLVX 流量转发面板,直接执行安装并完成验证。
项目仓库:https://github.com/Sagit-chu/flvx
安装文档:https://github.com/Sagit-chu/flvx/blob/main/doc/install.md
1. 确认目标服务器:如果当前终端就在目标 Linux 服务器上,直接使用当前环境;否则使用我提供的 SSH 连接。缺少连接信息时,只询问必要信息,确认目标后再执行安装。
2. 先阅读项目 README、安装文档及将要执行的安装脚本,检查系统、架构、root/sudo 权限、Docker、Compose、端口占用和已有 FLVX 容器、数据卷及部署文件。已有部署时先确认是更新还是新装,保留原配置和数据。
3. 新安装默认使用仓库标记为 latest 的 Release、Docker Compose、SQLite,部署目录 /opt/flvx-panel,前端端口 6366、后端端口 6365。我已指定的版本、目录或端口优先;端口冲突时先与我确认替代端口。
4. 缺少依赖时按该发行版的官方方式安装 Docker Engine 和 Compose 插件。进入部署目录,从项目 Releases 下载所选版本的 panel_install.sh,先检查下载成功和脚本内容,再执行。使用交互式终端操作菜单,选择“安装面板”并按上述配置输入;以脚本实际提示为准。
5. 默认直连 GitHub,可设置 PROXY_ENABLED=false;连接失败时说明原因,再与我确认是否使用代理。脚本可能修改 Docker IPv6 配置并重启 Docker;若会影响现有服务,先说明影响并确认。保留现有防火墙和 SSH 规则,仅按需放行实际使用的面板端口;云安全组无法操作时列出需要我放行的端口。
6. 安装后检查 Compose 服务状态、后端健康检查、前端 HTTP 页面及后端 /flow/test 的响应,并从实际访问端验证连通性。失败时查看相关日志并修复后重试;受网络或权限限制无法完成的检查要明确说明,不能直接宣称安装成功。
7. 最后给我实际安装版本、部署目录、访问地址、验证结果,以及在该目录查看状态、查看日志和重启服务的命令。说明默认管理员账号和密码均为 admin_user,提醒首次登录立即修改密码;不要输出 .env 中的 JWT_SECRET、数据库密码等密钥。
```
需要安装转发节点时,告诉 Agent 按[节点端部署文档](doc/install.md#二节点端部署)操作,并提供节点服务器、面板后端地址及从面板获取的节点接入密钥;安装完成后以服务正常运行且面板显示节点在线为准。
### Docker Compose部署
#### 快速部署(安装最新版)
面板端:
@@ -228,7 +228,6 @@ func (h *Handler) Register(mux *http.ServeMux) {
mux.HandleFunc("/api/v1/tunnel/update-order", h.tunnelUpdateOrder)
mux.HandleFunc("/api/v1/tunnel/batch-delete", h.tunnelBatchDelete)
mux.HandleFunc("/api/v1/tunnel/batch-redeploy", h.tunnelBatchRedeploy)
mux.HandleFunc("/api/v1/tunnel/batch-redeploy/stream", h.tunnelBatchRedeployStream)
mux.HandleFunc("/api/v1/tunnel/user/assign", h.userTunnelAssign)
mux.HandleFunc("/api/v1/tunnel/user/batch-assign", h.userTunnelBatchAssign)
mux.HandleFunc("/api/v1/tunnel/user/remove", h.userTunnelRemove)
@@ -1123,14 +1122,6 @@ func normalizeAndValidateConfigValue(key, value string) (string, error) {
}
return pngDataURLPrefix + payload, nil
case sequentialPortConfigKey:
normalized := strings.TrimSpace(strings.ToLower(value))
switch normalized {
case "true", "false":
return normalized, nil
default:
return "", fmt.Errorf("顺次分配端口开关配置值无效")
}
case monitorTunnelQualityEnabledConfigKey:
normalized := strings.TrimSpace(strings.ToLower(value))
switch normalized {
+173 -67
View File
@@ -9,6 +9,7 @@ import (
"errors"
"fmt"
"log"
"math/big"
"net"
"net/http"
"sort"
@@ -1314,13 +1315,13 @@ func (h *Handler) tunnelUpdate(w http.ResponseWriter, r *http.Request) {
return
}
var runtimePending error
newEntryNodeIDs, _ = h.tunnelEntryNodeIDs(id)
if !sameInt64Set(oldEntryNodeIDs, newEntryNodeIDs) {
h.cleanupTunnelForwardRuntimesOnRemovedEntryNodes(id, oldEntryNodeIDs, newEntryNodeIDs)
runtimePending = h.syncTunnelForwardsEntryPorts(id, newEntryNodeIDs)
h.syncTunnelForwardsEntryPorts(id, newEntryNodeIDs)
}
var runtimePending error
if typeVal == 2 {
applyRuntime := h.applyTunnelRuntime
if oldTunnel != nil && oldTunnel.Type == 2 {
@@ -1328,9 +1329,9 @@ func (h *Handler) tunnelUpdate(w http.ResponseWriter, r *http.Request) {
}
createdChains, createdServices, applyErr := applyRuntime(runtimeState)
if isTunnelRuntimePending(applyErr) {
runtimePending = errors.Join(runtimePending, applyErr)
runtimePending = applyErr
}
if applyErr != nil && !isTunnelRuntimePending(applyErr) {
if applyErr != nil && runtimePending == nil {
updateProtocol := "tls"
if len(runtimeState.InNodes) > 0 && strings.TrimSpace(runtimeState.InNodes[0].Protocol) != "" {
updateProtocol = strings.TrimSpace(runtimeState.InNodes[0].Protocol)
@@ -1596,20 +1597,19 @@ func (h *Handler) validateTunnelEntryPortConflictsForNewEntriesTx(tx *gorm.DB, t
return nil
}
func (h *Handler) syncTunnelForwardsEntryPorts(tunnelID int64, entryNodeIDs []int64) error {
func (h *Handler) syncTunnelForwardsEntryPorts(tunnelID int64, entryNodeIDs []int64) {
if h == nil || h.repo == nil || tunnelID <= 0 {
return nil
return
}
entryNodeIDs = uniqueInt64s(entryNodeIDs)
if len(entryNodeIDs) == 0 {
return nil
return
}
forwards, err := h.listForwardsByTunnel(tunnelID)
if err != nil {
return err
if err != nil || len(forwards) == 0 {
return
}
var syncErrors []error
allowInIP := len(entryNodeIDs) == 1
for i := range forwards {
@@ -1619,7 +1619,6 @@ func (h *Handler) syncTunnelForwardsEntryPorts(tunnelID int64, entryNodeIDs []in
}
oldPorts, err := h.listForwardPorts(f.ID)
if err != nil {
syncErrors = append(syncErrors, err)
continue
}
referencePort := pickForwardPortFromRecords(oldPorts)
@@ -1661,17 +1660,14 @@ func (h *Handler) syncTunnelForwardsEntryPorts(tunnelID int64, entryNodeIDs []in
}
entries = append(entries, forwardPortReplaceEntry{NodeID: nid, Port: port, InIP: inIP})
}
if err := h.repo.ReplaceForwardPortsIndividually(f.ID, entries, h.isSequentialPortEnabled()); err != nil {
syncErrors = append(syncErrors, fmt.Errorf("转发 %s 入口端口更新失败: %w", f.Name, err))
_ = h.repo.ReplaceForwardPorts(f.ID, entries)
}
}
return errors.Join(syncErrors...)
}
// resolvePortForNewEntryNode determines the port for a forward on a newly added
// entry node. It tries to reuse referencePort (from existing entries); if that
// port is out of range or already occupied, zero requests atomic allocation
// when ReplaceForwardPorts persists the new entry. Explicit ports are rechecked there.
// port is out of range or already occupied, it picks a random available port
// for this specific node.
func (h *Handler) resolvePortForNewEntryNode(nodeID int64, referencePort int, forwardID int64) int {
node, err := h.getNodeRecord(nodeID)
if err != nil {
@@ -1688,23 +1684,48 @@ func (h *Handler) resolvePortForNewEntryNode(nodeID int64, referencePort int, fo
}
}
// Defer fallback selection to the same transaction that saves the entries.
return 0
// referencePort doesn't work for this node; pick a random one.
newPort := h.pickRandomPortForNode(nodeID)
if newPort > 0 {
return newPort
}
return referencePort // last resort fallback
}
// sequentialPortConfigKey 是「未指定端口时按端口范围顺次分配」开关的配置键。
const sequentialPortConfigKey = "sequential_port_enabled"
// isSequentialPortEnabled 返回是否开启了顺次分配端口(默认关闭,保持随机分配)。
func (h *Handler) isSequentialPortEnabled() bool {
if h == nil || h.repo == nil {
return false
}
value, err := h.repo.GetViteConfigValue(sequentialPortConfigKey)
// pickRandomPortForNode picks a random available port from a single node's
// port range, excluding ports already occupied by other forwards or chains.
func (h *Handler) pickRandomPortForNode(nodeID int64) int {
portRange, err := h.repo.GetNodePortRange(nodeID)
if err != nil {
return false
return 0
}
return strings.EqualFold(strings.TrimSpace(value), "true")
if portRange == "" {
portRange = "1000-65535"
}
nodePorts, err := parsePorts(portRange)
if err != nil || len(nodePorts) == 0 {
return 0
}
used, err := h.getUsedPorts(nodeID)
if err != nil {
return 0
}
var available []int
for _, p := range nodePorts {
if !used[p] {
available = append(available, p)
}
}
if len(available) == 0 {
return 0
}
idx, _ := rand.Int(rand.Reader, big.NewInt(int64(len(available))))
return available[idx.Int64()]
}
func (h *Handler) tunnelDelete(w http.ResponseWriter, r *http.Request) {
@@ -2025,37 +2046,51 @@ func normalizeBatchFailureReason(reason string) string {
return trimmed
}
func (h *Handler) redeployTunnelConfiguration(tunnelID int64) error {
if _, err := h.getTunnelRecord(tunnelID); err != nil {
return err
}
if nftMode, entryNodeIDs, err := h.tunnelUsesNftables(tunnelID); err != nil {
return err
} else if nftMode {
if len(entryNodeIDs) == 0 {
return errors.New("nftables 转发缺少入口节点")
}
return h.reconcileNftablesNodeByRequest(entryNodeIDs[0])
}
return h.redeployTunnelAndForwards(tunnelID)
}
func (h *Handler) tunnelBatchRedeploy(w http.ResponseWriter, r *http.Request) {
ids := idsFromBody(r, w)
if ids == nil {
return
}
result := batchOperationResult{}
success := 0
fail := 0
failures := make([]batchFailureDetail, 0)
for _, tunnelID := range ids {
name, _ := h.repo.GetTunnelName(tunnelID)
if err := h.redeployTunnelConfiguration(tunnelID); err != nil {
result.FailCount++
result.Failures = appendBatchFailure(result.Failures, tunnelID, name, err)
} else {
result.SuccessCount++
tunnel, tunnelErr := h.getTunnelRecord(tunnelID)
tunnelName := ""
if tunnelErr == nil && tunnel != nil {
tunnelName, _ = h.repo.GetTunnelName(tunnelID)
}
if tunnelErr != nil {
fail++
failures = appendBatchFailure(failures, tunnelID, tunnelName, tunnelErr)
continue
}
response.WriteJSON(w, response.OK(result))
if nftMode, entryNodeIDs, modeErr := h.tunnelUsesNftables(tunnelID); modeErr != nil {
fail++
failures = appendBatchFailure(failures, tunnelID, tunnelName, modeErr)
continue
} else if nftMode {
if len(entryNodeIDs) == 0 {
fail++
failures = appendBatchFailureReason(failures, tunnelID, tunnelName, "nftables 转发缺少入口节点")
continue
}
if reconcileErr := h.reconcileNftablesNodeByRequest(entryNodeIDs[0]); reconcileErr != nil {
fail++
failures = appendBatchFailure(failures, tunnelID, tunnelName, reconcileErr)
continue
}
success++
continue
}
if err := h.redeployTunnelAndForwards(tunnelID); err != nil {
fail++
failures = appendBatchFailure(failures, tunnelID, tunnelName, err)
continue
}
success++
}
response.WriteJSON(w, response.OK(batchOperationResult{SuccessCount: success, FailCount: fail, Failures: failures}))
}
func (h *Handler) userTunnelAssign(w http.ResponseWriter, r *http.Request) {
@@ -2269,7 +2304,12 @@ func (h *Handler) forwardCreate(w http.ResponseWriter, r *http.Request) {
return
}
port := asInt(req["inPort"], 0)
// A zero port is allocated and persisted atomically by the repository.
if port <= 0 {
port = h.pickTunnelPort(tunnelID)
}
if port <= 0 {
port = 10000
}
entryNodes, _ := h.tunnelEntryNodeIDs(tunnelID)
isNftTunnel, _, err := h.tunnelUsesNftables(tunnelID)
if err != nil {
@@ -2288,9 +2328,6 @@ func (h *Handler) forwardCreate(w http.ResponseWriter, r *http.Request) {
return
}
for _, nodeID := range entryNodes {
if port <= 0 {
break // Repository validates all nodes while allocating atomically.
}
node, nodeErr := h.getNodeRecord(nodeID)
if nodeErr != nil {
continue
@@ -2323,7 +2360,7 @@ func (h *Handler) forwardCreate(w http.ResponseWriter, r *http.Request) {
proxyProtocolReceive := asInt(req["proxyProtocolReceive"], 0)
proxyProtocolSend := asInt(req["proxyProtocolSend"], proxyProtocol)
forwardID, err := h.repo.CreateForwardTx(userID, userName, name, tunnelID, remoteAddr, defaultString(asString(req["strategy"]), "fifo"), now, inx, entryNodes, port, inIp, nullableInt(speedID), maxConn, ipMaxConn, nullableInt(ipSpeedID), proxyProtocol, proxyProtocolReceive, proxyProtocolSend, h.isSequentialPortEnabled())
forwardID, err := h.repo.CreateForwardTx(userID, userName, name, tunnelID, remoteAddr, defaultString(asString(req["strategy"]), "fifo"), now, inx, entryNodes, port, inIp, nullableInt(speedID), maxConn, ipMaxConn, nullableInt(ipSpeedID), proxyProtocol, proxyProtocolReceive, proxyProtocolSend)
if err != nil {
response.WriteJSON(w, response.Err(-2, err.Error()))
return
@@ -2461,6 +2498,9 @@ func (h *Handler) forwardUpdate(w http.ResponseWriter, r *http.Request) {
if minPort.Valid {
port = int(minPort.Int64)
}
if port <= 0 {
port = h.pickTunnelPort(tunnelID)
}
}
hasInIP := false
inIp := ""
@@ -2485,9 +2525,6 @@ func (h *Handler) forwardUpdate(w http.ResponseWriter, r *http.Request) {
keptNodeIDs = diffInt64s(oldNodeIDs, removedNodeIDs)
}
for _, nodeID := range fwdEntryNodes {
if port <= 0 {
break // Repository validates all nodes while allocating atomically.
}
node, nodeErr := h.getNodeRecord(nodeID)
if nodeErr != nil {
continue
@@ -3010,6 +3047,9 @@ func (h *Handler) forwardBatchChangeTunnel(w http.ResponseWriter, r *http.Reques
if port.Valid {
p = int(port.Int64)
}
if p <= 0 {
p = h.pickTunnelPort(req.TargetTunnelID)
}
bctEntryNodes, _ := h.tunnelEntryNodeIDs(req.TargetTunnelID)
newNodeIDs := uniqueInt64s(bctEntryNodes)
removedNodeIDs := diffInt64s(oldNodeIDs, newNodeIDs)
@@ -3017,9 +3057,6 @@ func (h *Handler) forwardBatchChangeTunnel(w http.ResponseWriter, r *http.Reques
portRangeOk := true
var portRangeErr error
for _, nid := range bctEntryNodes {
if p <= 0 {
break // Repository validates all nodes while allocating atomically.
}
nd, ndErr := h.getNodeRecord(nid)
if ndErr != nil {
portRangeErr = ndErr
@@ -4949,6 +4986,75 @@ func (h *Handler) tunnelEntryNodeIDs(tunnelID int64) ([]int64, error) {
return h.repo.TunnelEntryNodeIDs(tunnelID)
}
func (h *Handler) pickTunnelPort(tunnelID int64) int {
entryNodes, err := h.tunnelEntryNodeIDs(tunnelID)
if err != nil || len(entryNodes) == 0 {
return 10000
}
var commonAvailable []int
firstNode := true
for _, nodeID := range entryNodes {
portRange, err := h.repo.GetNodePortRange(nodeID)
if err != nil {
continue
}
if portRange == "" {
portRange = "1000-65535"
}
nodePorts, err := parsePorts(portRange)
if err != nil {
continue
}
used, err := h.getUsedPorts(nodeID)
if err != nil {
continue
}
var available []int
for _, p := range nodePorts {
if !used[p] {
available = append(available, p)
}
}
if firstNode {
commonAvailable = available
firstNode = false
} else {
set := make(map[int]bool)
for _, p := range available {
set[p] = true
}
var newCommon []int
for _, p := range commonAvailable {
if set[p] {
newCommon = append(newCommon, p)
}
}
commonAvailable = newCommon
}
if len(commonAvailable) == 0 {
break
}
}
if len(commonAvailable) > 0 {
idx, _ := rand.Int(rand.Reader, big.NewInt(int64(len(commonAvailable))))
return commonAvailable[idx.Int64()]
}
return 10000
}
func (h *Handler) getUsedPorts(nodeID int64) (map[int]bool, error) {
return h.repo.GetUsedPortsOnNodeAsMap(nodeID)
}
func parsePorts(portRange string) ([]int, error) {
var ports []int
parts := strings.Split(portRange, ",")
@@ -5021,7 +5127,7 @@ func (h *Handler) replaceForwardPorts(forwardID, tunnelID int64, port int, inIp
for i, nid := range entryNodes {
entries[i] = forwardPortReplaceEntry{NodeID: nid, Port: port, InIP: inIp}
}
return h.repo.ReplaceForwardPorts(forwardID, entries, h.isSequentialPortEnabled())
return h.repo.ReplaceForwardPorts(forwardID, entries)
}
func (h *Handler) replaceForwardPortsPreservingInIP(forwardID, tunnelID int64, port int, oldPorts []forwardPortRecord) error {
@@ -5030,7 +5136,7 @@ func (h *Handler) replaceForwardPortsPreservingInIP(forwardID, tunnelID int64, p
return err
}
entries := buildForwardPortEntriesWithPreservedInIP(entryNodes, oldPorts, port)
return h.repo.ReplaceForwardPorts(forwardID, entries, h.isSequentialPortEnabled())
return h.repo.ReplaceForwardPorts(forwardID, entries)
}
func (h *Handler) replaceForwardPortsWithRecords(forwardID int64, ports []forwardPortRecord) error {
@@ -5038,7 +5144,7 @@ func (h *Handler) replaceForwardPortsWithRecords(forwardID int64, ports []forwar
for i, fp := range ports {
entries[i] = forwardPortReplaceEntry{NodeID: fp.NodeID, Port: fp.Port, InIP: fp.InIP}
}
return h.repo.ReplaceForwardPorts(forwardID, entries, h.isSequentialPortEnabled())
return h.repo.ReplaceForwardPorts(forwardID, entries)
}
func (h *Handler) rollbackForwardMutation(oldForward *forwardRecord, oldPorts []forwardPortRecord) {
@@ -1,34 +0,0 @@
package handler
import "testing"
func TestNormalizeSequentialPortConfigValue(t *testing.T) {
for in, want := range map[string]string{"true": "true", " FALSE ": "false"} {
got, err := normalizeAndValidateConfigValue(sequentialPortConfigKey, in)
if err != nil || got != want {
t.Fatalf("value %q: got %q err=%v, want %q", in, got, err, want)
}
}
if _, err := normalizeAndValidateConfigValue(sequentialPortConfigKey, "maybe"); err == nil {
t.Fatal("expected invalid value to be rejected")
}
}
func TestSequentialPortConfigReadsRepositoryAndDefaultsOff(t *testing.T) {
_, r := setupConfigAccessTestRouter(t)
h := &Handler{repo: r}
if h.isSequentialPortEnabled() {
t.Fatal("missing config must preserve random allocation")
}
for _, tc := range []struct {
value string
want bool
}{
{"true", true}, {" TRUE ", true}, {"false", false}, {"invalid", false},
} {
seedConfigValue(t, r, sequentialPortConfigKey, tc.value)
if got := h.isSequentialPortEnabled(); got != tc.want {
t.Fatalf("config %q: got %v, want %v", tc.value, got, tc.want)
}
}
}
@@ -500,7 +500,10 @@ func (h *Handler) planSingleTunnelDeleteForwardMigration(forward *forwardRecord,
targetPort = int(minPort.Int64)
}
if targetPort <= 0 {
return tunnelForwardMigrationPlan{}, errors.New("转发入口端口无效,请先修复该规则")
targetPort = h.pickTunnelPort(targetTunnelID)
}
if targetPort <= 0 {
targetPort = 10000
}
hasCustomInIP := false
@@ -1,105 +0,0 @@
package handler
import (
"encoding/json"
"errors"
"net/http"
"time"
"go-backend/internal/http/response"
)
type redeployProgress struct {
Total int `json:"total"`
Completed int `json:"completed"`
Success int `json:"success"`
Failed int `json:"failed"`
}
type redeployItemResult struct {
ID int64 `json:"id"`
Name string `json:"name"`
Success bool `json:"success"`
Reason string `json:"reason,omitempty"`
}
// tunnelBatchRedeployStream reports completed tunnels, not estimated runtime.
// A disconnected caller may have an in-flight mutation whose result it did not
// receive. Finish that mutation, but never start another or automatically retry.
func (h *Handler) tunnelBatchRedeployStream(w http.ResponseWriter, r *http.Request) {
ids := idsFromBody(r, w)
if ids == nil {
return
}
// idsFromBody sorts IDs; ignore duplicate selections so each tunnel runs once.
unique := ids[:0]
for _, id := range ids {
if len(unique) == 0 || unique[len(unique)-1] != id {
unique = append(unique, id)
}
}
ids = unique
if len(ids) == 0 {
response.WriteJSON(w, response.ErrDefault("ids不能为空"))
return
}
_, err := prepareDiagnosisStreamResponse(w)
if err != nil {
response.WriteJSON(w, response.ErrDefault(err.Error()))
return
}
encoder := json.NewEncoder(w)
controller := http.NewResponseController(w)
emit := func(kind string, data interface{}) bool {
if r.Context().Err() != nil {
return false
}
// The server's WriteTimeout is an absolute request deadline. Renew only
// this stream's bounded write window as progress is emitted, so a long
// batch is not cut off despite making steady progress. Recorders and
// other non-network writers may not support deadlines.
if err := controller.SetWriteDeadline(time.Now().Add(2 * time.Minute)); err != nil && !errors.Is(err, http.ErrNotSupported) {
return false
}
event := diagnosisStreamEvent{Type: kind, Data: data, TS: time.Now().UnixMilli()}
if err := encoder.Encode(event); err != nil {
return false
}
// Buffered writes can succeed while the actual socket flush fails.
// Do not start a mutation after its processing event failed to flush.
return controller.Flush() == nil
}
progress := redeployProgress{Total: len(ids)}
result := batchOperationResult{}
if !emit("start", progress) {
return
}
for _, id := range ids {
if r.Context().Err() != nil {
return
}
name, _ := h.repo.GetTunnelName(id)
if !emit("processing", map[string]interface{}{"id": id, "name": name, "progress": progress}) {
return
}
if r.Context().Err() != nil {
return
}
item := redeployItemResult{ID: id, Name: name}
if err := h.redeployTunnelConfiguration(id); err != nil {
result.FailCount++
result.Failures = appendBatchFailure(result.Failures, id, name, err)
item.Reason = result.Failures[len(result.Failures)-1].Reason
progress.Failed++
} else {
result.SuccessCount++
item.Success = true
progress.Success++
}
progress.Completed++
if !emit("item", map[string]interface{}{"result": item, "progress": progress}) {
return
}
}
emit("done", map[string]interface{}{"progress": progress, "result": result})
}
@@ -1,248 +0,0 @@
package handler
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"go-backend/internal/http/middleware"
runtimenft "go-backend/internal/runtime/nftables"
)
type blockingRedeployManager struct {
fakeNftablesManager
entered chan struct{}
release chan struct{}
once sync.Once
}
func (m *blockingRedeployManager) Reconcile(ctx context.Context, cfg runtimenft.SSHConfig, plan runtimenft.NodePlan) (runtimenft.ApplyResult, error) {
m.once.Do(func() { close(m.entered); <-m.release })
return m.fakeNftablesManager.Reconcile(ctx, cfg, plan)
}
func TestTunnelRedeployStreamFlushesBeforeSlowMutationAndReportsMixedResults(t *testing.T) {
fixture := setupNftablesHandler(t)
h := fixture.handler
seedNftablesSSHConfig(t, h, fixture.nodeID)
id := seedTunnelForNftables(t, h, "stream-tunnel", fixture.nodeID)
manager := &blockingRedeployManager{entered: make(chan struct{}), release: make(chan struct{})}
h.nftablesManager = manager
var releaseOnce sync.Once
release := func() { releaseOnce.Do(func() { close(manager.release) }) }
defer release()
server := httptest.NewServer(http.HandlerFunc(h.tunnelBatchRedeployStream))
defer server.Close()
client := &http.Client{Timeout: 5 * time.Second}
response, err := client.Post(server.URL, "application/json", strings.NewReader(fmt.Sprintf(`{"ids":[%d,999999,%d]}`, id, id)))
if err != nil {
t.Fatal(err)
}
defer response.Body.Close()
decoder := json.NewDecoder(response.Body)
read := func(want string) map[string]interface{} {
t.Helper()
var event struct {
Type string
Data map[string]interface{}
}
if err := decoder.Decode(&event); err != nil {
t.Fatal(err)
}
if event.Type != want {
t.Fatalf("expected %s, got %s", want, event.Type)
}
return event.Data
}
if start := read("start"); start["total"] != float64(2) {
t.Fatalf("duplicate IDs not deduplicated: %+v", start)
}
processing := read("processing")
if processing["name"] != "stream-tunnel" || processing["id"] != float64(id) {
t.Fatalf("wrong current tunnel: %+v", processing)
}
select {
case <-manager.entered:
case <-time.After(2 * time.Second):
t.Fatal("did not start mutation")
}
// Both events arrived over HTTP while the actual mutation is still blocked.
release()
item := read("item")
if item["result"].(map[string]interface{})["success"] != true || item["progress"].(map[string]interface{})["completed"] != float64(1) {
t.Fatalf("wrong success result: %+v", item)
}
read("processing")
item = read("item")
if item["result"].(map[string]interface{})["success"] != false || item["result"].(map[string]interface{})["reason"] == "" {
t.Fatalf("wrong failure result: %+v", item)
}
done := read("done")
progress := done["progress"].(map[string]interface{})
result := done["result"].(map[string]interface{})
if progress["completed"] != float64(2) || progress["success"] != float64(1) || progress["failed"] != float64(1) || result["successCount"] != float64(1) || result["failCount"] != float64(1) {
t.Fatalf("incorrect final result: %+v", done)
}
if manager.reconcileCount() != 1 {
t.Fatalf("expected one execution, got %d", manager.reconcileCount())
}
if err := decoder.Decode(new(interface{})); err != io.EOF {
t.Fatalf("expected EOF after done, got %v", err)
}
}
func TestTunnelRedeployStreamStopsAfterDisconnect(t *testing.T) {
fixture := setupNftablesHandler(t)
h := fixture.handler
seedNftablesSSHConfig(t, h, fixture.nodeID)
first := seedTunnelForNftables(t, h, "first", fixture.nodeID)
second := seedTunnelForNftables(t, h, "second", fixture.nodeID)
manager := &blockingRedeployManager{entered: make(chan struct{}), release: make(chan struct{})}
h.nftablesManager = manager
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy/stream", strings.NewReader(fmt.Sprintf(`{"ids":[%d,%d]}`, first, second))).WithContext(ctx)
res := httptest.NewRecorder()
finished := make(chan struct{})
go func() { defer close(finished); h.tunnelBatchRedeployStream(res, req) }()
select {
case <-manager.entered:
case <-time.After(2 * time.Second):
close(manager.release)
t.Fatal("mutation did not start")
}
cancel()
close(manager.release)
select {
case <-finished:
case <-time.After(2 * time.Second):
t.Fatal("handler did not stop")
}
if manager.reconcileCount() != 1 {
t.Fatalf("started another mutation after disconnect: %d", manager.reconcileCount())
}
if strings.Contains(res.Body.String(), `"type":"done"`) {
t.Fatal("disconnected stream claimed completion")
}
}
type failedRedeployWriter struct{ *httptest.ResponseRecorder }
func (w failedRedeployWriter) Write([]byte) (int, error) { return 0, io.ErrClosedPipe }
func TestTunnelRedeployStreamDoesNotMutateWhenInitialWriteFails(t *testing.T) {
fixture := setupNftablesHandler(t)
h := fixture.handler
seedNftablesSSHConfig(t, h, fixture.nodeID)
id := seedTunnelForNftables(t, h, "stream-tunnel", fixture.nodeID)
manager := &fakeNftablesManager{}
h.nftablesManager = manager
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(fmt.Sprintf(`{"ids":[%d]}`, id)))
h.tunnelBatchRedeployStream(failedRedeployWriter{httptest.NewRecorder()}, req)
if manager.reconcileCount() != 0 {
t.Fatal("mutation ran despite failed progress stream")
}
}
type delayedRedeployManager struct{ fakeNftablesManager }
func (m *delayedRedeployManager) Reconcile(ctx context.Context, cfg runtimenft.SSHConfig, plan runtimenft.NodePlan) (runtimenft.ApplyResult, error) {
time.Sleep(100 * time.Millisecond)
return m.fakeNftablesManager.Reconcile(ctx, cfg, plan)
}
type shortRedeployDeadlineWriter struct {
http.ResponseWriter
deadlineCalls *atomic.Int32
}
func (w shortRedeployDeadlineWriter) Unwrap() http.ResponseWriter { return w.ResponseWriter }
func (w shortRedeployDeadlineWriter) SetWriteDeadline(deadline time.Time) error {
remaining := time.Until(deadline)
if remaining < time.Minute || remaining > 2*time.Minute {
return fmt.Errorf("expected bounded two-minute write window, got %v", remaining)
}
w.deadlineCalls.Add(1)
// Shorten the production idle window for a real, fast timeout regression.
return http.NewResponseController(w.ResponseWriter).SetWriteDeadline(time.Now().Add(200 * time.Millisecond))
}
func TestTunnelRedeployStreamRenewsDeadlineThroughRequestLog(t *testing.T) {
fixture := setupNftablesHandler(t)
h := fixture.handler
seedNftablesSSHConfig(t, h, fixture.nodeID)
ids := make([]int64, 3)
for i := range ids {
ids[i] = seedTunnelForNftables(t, h, fmt.Sprintf("slow-%d", i), fixture.nodeID)
}
manager := &delayedRedeployManager{}
h.nftablesManager = manager
var deadlineCalls atomic.Int32
logged := middleware.RequestLog(http.HandlerFunc(h.tunnelBatchRedeployStream))
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
logged.ServeHTTP(shortRedeployDeadlineWriter{w, &deadlineCalls}, r)
}))
server.Config.WriteTimeout = 50 * time.Millisecond
server.Start()
defer server.Close()
body, _ := json.Marshal(map[string]interface{}{"ids": ids})
client := &http.Client{Timeout: 5 * time.Second}
response, err := client.Post(server.URL, "application/json", strings.NewReader(string(body)))
if err != nil {
t.Fatal(err)
}
defer response.Body.Close()
payload, err := io.ReadAll(response.Body)
if err != nil {
t.Fatalf("stream timed out across batch: %v (body %s)", err, payload)
}
if !strings.Contains(string(payload), `"type":"done"`) {
t.Fatalf("batch did not finish: %s", payload)
}
if manager.reconcileCount() != 3 {
t.Fatalf("wrong execution count: %d", manager.reconcileCount())
}
if deadlineCalls.Load() != 8 {
t.Fatalf("each of 8 events must renew its deadline, got %d", deadlineCalls.Load())
}
}
type flushFailureRedeployWriter struct {
*httptest.ResponseRecorder
flushes int
}
func (w *flushFailureRedeployWriter) FlushError() error {
w.flushes++
if w.flushes == 2 {
return io.ErrClosedPipe
}
w.ResponseRecorder.Flush()
return nil
}
func TestTunnelRedeployStreamStopsBeforeMutationOnProcessingFlushError(t *testing.T) {
fixture := setupNftablesHandler(t)
h := fixture.handler
seedNftablesSSHConfig(t, h, fixture.nodeID)
id := seedTunnelForNftables(t, h, "flush-error", fixture.nodeID)
manager := &fakeNftablesManager{}
h.nftablesManager = manager
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(fmt.Sprintf(`{"ids":[%d]}`, id)))
writer := &flushFailureRedeployWriter{ResponseRecorder: httptest.NewRecorder()}
middleware.RequestLog(http.HandlerFunc(h.tunnelBatchRedeployStream)).ServeHTTP(writer, req)
if writer.flushes != 2 {
t.Fatalf("expected start and processing flush, got %d", writer.flushes)
}
if manager.reconcileCount() != 0 {
t.Fatal("mutation ran after failed processing flush")
}
}
@@ -14,11 +14,6 @@ type statusWriter struct {
status int
}
// Unwrap preserves ResponseController features such as per-response deadlines.
func (w *statusWriter) Unwrap() http.ResponseWriter {
return w.ResponseWriter
}
func (w *statusWriter) WriteHeader(code int) {
w.status = code
w.ResponseWriter.WriteHeader(code)
@@ -32,12 +27,10 @@ func (w *statusWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
return hj.Hijack()
}
func (w *statusWriter) FlushError() error {
return http.NewResponseController(w.ResponseWriter).Flush()
}
func (w *statusWriter) Flush() {
_ = w.FlushError()
if f, ok := w.ResponseWriter.(http.Flusher); ok {
f.Flush()
}
}
func (w *statusWriter) ReadFrom(r io.Reader) (int64, error) {
+2 -43
View File
@@ -1609,15 +1609,7 @@ func (r *Repository) CreatePeerShareRuntime(item *model.PeerShareRuntime) error
if item == nil {
return errors.New("runtime item is nil")
}
return r.db.Transaction(func(tx *gorm.DB) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
if err := r.checkPeerRuntimePortTx(tx, item); err != nil {
return err
}
return tx.Create(item).Error
})
return r.db.Create(item).Error
}
func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error {
@@ -1627,23 +1619,7 @@ func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error
if item == nil {
return errors.New("runtime item is nil")
}
return r.db.Transaction(func(tx *gorm.DB) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
var current model.PeerShareRuntime
if err := tx.Where("id = ?", item.ID).First(&current).Error; err != nil {
return err
}
if current.NodeID != item.NodeID {
return errors.New("runtime node cannot change")
}
if !(current.Status == 1 && current.Port == item.Port) {
if err := r.checkPeerRuntimePortTx(tx, item); err != nil {
return err
}
}
return tx.Model(&model.PeerShareRuntime{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
return r.db.Model(&model.PeerShareRuntime{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
"reservation_id": item.ReservationID,
"relay_auth": item.RelayAuth,
"relay_auth_version": item.RelayAuthVersion,
@@ -1654,7 +1630,6 @@ func (r *Repository) UpdatePeerShareRuntime(item *model.PeerShareRuntime) error
"applied": item.Applied, "status": item.Status,
"updated_time": item.UpdatedTime,
}).Error
})
}
func (r *Repository) MarkPeerShareRuntimeReleased(id int64, updatedTime int64) error {
@@ -2689,15 +2664,6 @@ func importTunnels(tx *gorm.DB, tunnels []model.TunnelBackup, now int64) (int, e
return count, err
}
for _, ct := range t.ChainTunnels {
if ct.Port > 0 {
used, err := (&Repository{}).usedPortSetTx(tx, ct.NodeID, 0, ct.TunnelID)
if err != nil {
return count, err
}
if used[ct.Port] {
return count, errors.New("导入链路端口已占用")
}
}
chainItem := model.ChainTunnel{
ID: ct.ID,
TunnelID: ct.TunnelID,
@@ -2769,13 +2735,6 @@ func importForwards(tx *gorm.DB, forwards []model.ForwardBackup, now int64) (int
return count, err
}
for _, fp := range *f.ForwardPorts {
used, err := (&Repository{}).usedPortSetTx(tx, fp.NodeID, f.ID, 0)
if err != nil {
return count, err
}
if used[fp.Port] {
return count, errors.New("导入转发端口已占用")
}
if err := tx.Create(&model.ForwardPort{ForwardID: f.ID, NodeID: fp.NodeID, Port: fp.Port}).Error; err != nil {
return count, err
}
@@ -18,12 +18,7 @@ var errBackupImportBusy = errors.New("database is busy; retry the backup import"
func backupImportTransaction(db *gorm.DB, importRows func(*gorm.DB) error) error {
var err error
for attempt := 0; attempt < 10; attempt++ {
err = db.Transaction(func(tx *gorm.DB) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
return importRows(tx)
})
err = db.Transaction(importRows)
if !errors.Is(err, errBackupImportBusy) {
return err
}
@@ -146,13 +146,19 @@ func (r *Repository) CreateFederationTunnel(name string, tunnelType int, protoco
InIP: sql.NullString{String: "", Valid: false},
}
err := r.db.Transaction(func(tx *gorm.DB) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
if err := tx.Create(&tunnel).Error; err != nil {
return err
}
if err := r.CreateChainTunnelTx(tx, tunnel.ID, "1", nodeID, sql.NullInt64{Int64: int64(remotePort), Valid: true}, "fifo", 0, protocol, ""); err != nil {
ct := model.ChainTunnel{
TunnelID: tunnel.ID,
ChainType: "1",
NodeID: nodeID,
Port: sql.NullInt64{Int64: int64(remotePort), Valid: true},
Strategy: sql.NullString{String: "fifo", Valid: true},
Inx: sql.NullInt64{Int64: 0, Valid: true},
Protocol: sql.NullString{String: protocol, Valid: true},
}
if err := tx.Create(&ct).Error; err != nil {
return err
}
return nil
@@ -160,9 +160,6 @@ func TestForwardRepositoryPersistsPerIPLimits(t *testing.T) {
defer r.Close()
now := time.Now().UnixMilli()
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
t.Fatal(err)
}
forwardID, err := r.CreateForwardTx(1, "admin", "per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 0, 5, int64(21), 0, 0, 0)
if err != nil {
t.Fatalf("CreateForwardTx: %v", err)
@@ -227,9 +224,6 @@ func TestForwardRepositoryPersistsProxyProtocolReceiveAndSend(t *testing.T) {
defer r.Close()
now := time.Now().UnixMilli()
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
t.Fatal(err)
}
forwardID, err := r.CreateForwardTx(1, "admin", "proxy-protocol-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 0, 0, nil, 0, 1, 2)
if err != nil {
t.Fatalf("CreateForwardTx: %v", err)
@@ -307,10 +301,7 @@ func TestRollbackForwardFieldsRestoresPerIPLimits(t *testing.T) {
defer r.Close()
now := time.Now().UnixMilli()
if err := r.db.Create(&model.Node{ID: 3, Port: "1000-65535"}).Error; err != nil {
t.Fatal(err)
}
forwardID, err := r.CreateForwardTx(1, "admin", "rollback-per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, []int64{3}, 24000, "", nil, 7, 5, int64(21), 2, 0, 2)
forwardID, err := r.CreateForwardTx(1, "admin", "rollback-per-ip-forward", 2, "1.1.1.1:443", "fifo", now, 1, nil, 0, "", nil, 7, 5, int64(21), 2, 0, 2)
if err != nil {
t.Fatalf("CreateForwardTx: %v", err)
}
@@ -448,14 +448,7 @@ func (r *Repository) BeginTx() *gorm.DB {
if r == nil || r.db == nil {
return nil
}
tx := r.db.Begin()
if tx.Error == nil {
if err := lockPortAllocationTx(tx); err != nil {
tx.Rollback()
tx.AddError(err)
}
}
return tx
return r.db.Begin()
}
func (r *Repository) UpdateTunnelOrder(tunnelID int64, inx int, now int64) {
@@ -499,18 +492,6 @@ func (r *Repository) CreateChainTunnelTx(tx *gorm.DB, tunnelID int64, chainType
if tx == nil {
return errors.New("database unavailable")
}
if port.Valid && port.Int64 > 0 {
if err := r.LockPortNodesTx(tx, []int64{nodeID}); err != nil {
return err
}
used, err := r.usedPortSetTx(tx, nodeID, 0, tunnelID)
if err != nil {
return err
}
if used[int(port.Int64)] {
return errors.New("端口已占用")
}
}
ct := model.ChainTunnel{
TunnelID: tunnelID,
ChainType: chainType,
@@ -557,9 +538,6 @@ func (r *Repository) pickNodePortTx(tx *gorm.DB, nodeID int64, allocated map[int
if nodeID <= 0 {
return 0, errors.New("节点不存在")
}
if err := r.LockPortNodesTx(tx, []int64{nodeID}); err != nil {
return 0, err
}
if port, ok := allocated[nodeID]; ok && port > 0 {
return port, nil
}
@@ -578,16 +556,47 @@ func (r *Repository) pickNodePortTx(tx *gorm.DB, nodeID int64, allocated map[int
return 0, errors.New("节点端口已满,无可用端口")
}
used, err := r.usedPortSetTx(tx, nodeID, 0, excludeTunnelID)
used := make(map[int]struct{})
chainQuery := tx.Model(&model.ChainTunnel{}).Where("node_id = ? AND port > 0", nodeID)
if excludeTunnelID > 0 {
chainQuery = chainQuery.Where("tunnel_id != ?", excludeTunnelID)
}
var chainPorts []int
if err := chainQuery.Pluck("port", &chainPorts).Error; err != nil {
return 0, err
}
for _, p := range chainPorts {
if p > 0 {
used[p] = struct{}{}
}
}
var forwardPorts []int
if err := tx.Model(&model.ForwardPort{}).
Where("node_id = ? AND port > 0", nodeID).
Pluck("port", &forwardPorts).Error; err != nil {
return 0, err
}
for _, p := range forwardPorts {
if p > 0 {
used[p] = struct{}{}
}
}
pendingPorts, err := r.PendingTunnelCleanupPortsTx(tx, nodeID, excludeTunnelID)
if err != nil {
return 0, err
}
for _, port := range pendingPorts {
used[port] = struct{}{}
}
var available []int
for _, candidate := range candidates {
if candidate <= 0 {
continue
}
if used[candidate] {
if _, ok := used[candidate]; ok {
continue
}
available = append(available, candidate)
@@ -827,64 +836,11 @@ func (r *Repository) ReplaceForwardPorts(forwardID int64, entries []struct {
NodeID int64
Port int
InIP string
}, sequential ...bool) error {
return r.replaceForwardPorts(forwardID, entries, len(sequential) > 0 && sequential[0], false)
}
// ReplaceForwardPortsIndividually preserves independent ports when adding entry nodes.
func (r *Repository) ReplaceForwardPortsIndividually(forwardID int64, entries []struct {
NodeID int64
Port int
InIP string
}, sequential bool) error {
return r.replaceForwardPorts(forwardID, entries, sequential, true)
}
func (r *Repository) replaceForwardPorts(forwardID int64, entries []struct {
NodeID int64
Port int
InIP string
}, sequential, individually bool) error {
}) error {
if r == nil || r.db == nil {
return errors.New("repository not initialized")
}
return r.db.Transaction(func(tx *gorm.DB) error {
ids := make([]int64, 0, len(entries))
autoIDs := []int64{}
for _, e := range entries {
ids = append(ids, e.NodeID)
if e.Port <= 0 {
autoIDs = append(autoIDs, e.NodeID)
}
}
if err := r.LockPortNodesTx(tx, ids); err != nil {
return err
}
autoPort := 0
if len(autoIDs) > 0 && !individually {
var err error
autoPort, err = r.selectForwardPortTx(tx, autoIDs, 0, forwardID, sequential)
if err != nil {
return err
}
}
entries = append(entries[:0:0], entries...)
for i := range entries {
if entries[i].Port <= 0 {
if individually {
var err error
entries[i].Port, err = r.selectForwardPortTx(tx, []int64{entries[i].NodeID}, 0, forwardID, sequential)
if err != nil {
return err
}
} else {
entries[i].Port = autoPort
}
}
if _, err := r.selectForwardPortTx(tx, []int64{entries[i].NodeID}, entries[i].Port, forwardID, false); err != nil {
return err
}
}
if err := tx.Where("forward_id = ?", forwardID).Delete(&model.ForwardPort{}).Error; err != nil {
return err
}
@@ -1406,21 +1362,13 @@ func (r *Repository) EnsureUserTunnelGrant(userID, tunnelID int64) (int64, bool,
return ut.ID, true, nil
}
func (r *Repository) CreateForwardTx(userID int64, userName, name string, tunnelID int64, remoteAddr, strategy string, now int64, inx int, entryNodeIDs []int64, port int, inIp string, speedID interface{}, maxConn int, ipMaxConn int, ipSpeedID interface{}, proxyProtocol int, proxyProtocolReceive int, proxyProtocolSend int, sequential ...bool) (int64, error) {
func (r *Repository) CreateForwardTx(userID int64, userName, name string, tunnelID int64, remoteAddr, strategy string, now int64, inx int, entryNodeIDs []int64, port int, inIp string, speedID interface{}, maxConn int, ipMaxConn int, ipSpeedID interface{}, proxyProtocol int, proxyProtocolReceive int, proxyProtocolSend int) (int64, error) {
if r == nil || r.db == nil {
return 0, errors.New("repository not initialized")
}
_, proxyProtocolSend = normalizeForwardProxyProtocol(proxyProtocol, proxyProtocolReceive, proxyProtocolSend)
var forwardID int64
err := r.db.Transaction(func(tx *gorm.DB) error {
if err := r.LockPortNodesTx(tx, entryNodeIDs); err != nil {
return err
}
selectedPort, err := r.selectForwardPortTx(tx, entryNodeIDs, port, 0, len(sequential) > 0 && sequential[0])
if err != nil {
return err
}
port = selectedPort
fwd := model.Forward{
UserID: userID,
UserName: userName,
@@ -1,184 +0,0 @@
package repo
import (
"crypto/rand"
"encoding/json"
"errors"
"fmt"
"go-backend/internal/store/model"
"gorm.io/gorm"
"math/big"
"strings"
)
// lockPortAllocationTx serializes reservation mutations across processes sharing a database.
// PostgreSQL uses a transaction-scoped advisory lock; SQLite acquires its writer
// lock without changing any row, including when the node table is empty.
// All panel instances sharing this database must use this protocol; mixed old
// binaries and out-of-band SQL writes are not protected by advisory locks.
func lockPortAllocationTx(tx *gorm.DB) error {
if tx.Dialector.Name() == "postgres" {
return tx.Exec("SELECT pg_advisory_xact_lock(?)", int64(0x464c5658504f5254)).Error
}
if tx.Dialector.Name() == "sqlite" {
return tx.Model(&model.Node{}).Where("1 = 0").UpdateColumn("id", gorm.Expr("id")).Error
}
return errors.New("unsupported database for atomic port allocation")
}
// LockPortNodesTx must precede occupancy reads and reservation writes.
func (r *Repository) LockPortNodesTx(tx *gorm.DB, ids []int64) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
for _, id := range ids {
if id <= 0 {
return errors.New("节点不存在")
}
}
return nil
}
func (r *Repository) usedPortSetTx(tx *gorm.DB, nodeID, excludeForwardID, excludeTunnelID int64, excludeRuntimeIDs ...int64) (map[int]bool, error) {
used := map[int]bool{}
var ports []int
if err := tx.Model(&model.ForwardPort{}).Where("node_id = ? AND forward_id <> ?", nodeID, excludeForwardID).Pluck("port", &ports).Error; err != nil {
return nil, err
}
for _, p := range ports {
used[p] = true
}
query := tx.Model(&model.ChainTunnel{}).Where("node_id = ? AND port > 0", nodeID)
if excludeTunnelID > 0 {
query = query.Where("tunnel_id <> ?", excludeTunnelID)
}
if err := query.Pluck("port", &ports).Error; err != nil {
return nil, err
}
for _, p := range ports {
used[p] = true
}
runtimeQuery := tx.Model(&model.PeerShareRuntime{}).Where("node_id = ? AND (status = 1 OR release_pending <> 0) AND port > 0", nodeID)
if len(excludeRuntimeIDs) > 0 {
runtimeQuery = runtimeQuery.Where("id <> ?", excludeRuntimeIDs[0])
}
if err := runtimeQuery.Pluck("port", &ports).Error; err != nil {
return nil, err
}
for _, p := range ports {
used[p] = true
}
pending, err := r.PendingTunnelCleanupPortsTx(tx, nodeID, excludeTunnelID)
if err != nil {
return nil, err
}
for _, p := range pending {
used[p] = true
}
return used, nil
}
// Selection and insert must be in the same transaction after locking all nodes.
func (r *Repository) selectForwardPortTx(tx *gorm.DB, ids []int64, requested int, excludeForwardID int64, sequential bool) (int, error) {
if len(ids) == 0 {
return 0, errors.New("隧道没有可用入口节点")
}
var common []int
for i, id := range ids {
var node model.Node
if err := tx.Where("id = ?", id).First(&node).Error; err != nil {
return 0, err
}
spec := strings.TrimSpace(node.Port)
if spec == "" {
spec = "1000-65535"
if requested > 0 {
spec = "1-65535"
}
}
candidates := parsePortRangeSpec(spec)
used, err := r.usedPortSetTx(tx, id, excludeForwardID, 0)
if err != nil {
return 0, err
}
var remote struct {
Start int `json:"portRangeStart"`
End int `json:"portRangeEnd"`
}
if node.IsRemote == 1 {
_ = json.Unmarshal([]byte(node.RemoteConfig.String), &remote)
}
available := map[int]bool{}
for _, p := range candidates {
if p <= 65535 && !used[p] && (remote.Start <= 0 || remote.End <= 0 || (p >= remote.Start && p <= remote.End)) {
available[p] = true
}
}
if requested > 0 {
if !available[requested] {
return 0, errors.New("端口已占用或不在节点允许范围内")
}
continue
}
if i == 0 {
for _, p := range candidates {
if available[p] {
common = append(common, p)
}
}
} else {
filtered := common[:0]
for _, p := range common {
if available[p] {
filtered = append(filtered, p)
}
}
common = filtered
}
}
if requested > 0 {
return requested, nil
}
if len(common) == 0 {
return 0, errors.New("节点端口已满,无可用端口")
}
if sequential {
return common[0], nil
}
idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(common))))
if err != nil {
return 0, err
}
return common[idx.Int64()], nil
}
// checkPeerRuntimePortTx permits only a verified federation-forward attachment
// to share its owning chain reservation. Other new reservations must be free.
func (r *Repository) checkPeerRuntimePortTx(tx *gorm.DB, item *model.PeerShareRuntime) error {
if item.Port <= 0 || (item.Status != 1 && item.ReleasePending == 0) {
return nil
}
var ownedTunnel int64
if item.Role == "forward" {
var shareID, tunnelID int64
var port int
_, err := fmt.Sscanf(item.ResourceKey, "federation-forward-%d-%d-%d", &shareID, &tunnelID, &port)
if err == nil && shareID == item.ShareID && port == item.Port && item.ResourceKey == fmt.Sprintf("federation-forward-%d-%d-%d", shareID, tunnelID, port) {
var count int64
if err := tx.Model(&model.ChainTunnel{}).Where("tunnel_id = ? AND node_id = ? AND port = ?", tunnelID, item.NodeID, item.Port).Count(&count).Error; err != nil {
return err
}
if count > 0 {
ownedTunnel = tunnelID
}
}
}
used, err := r.usedPortSetTx(tx, item.NodeID, 0, ownedTunnel, item.ID)
if err != nil {
return err
}
if used[item.Port] {
return errors.New("端口已占用")
}
return nil
}
@@ -1,326 +0,0 @@
package repo
import (
"database/sql"
"fmt"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"go-backend/internal/store/model"
"gorm.io/gorm"
)
func portTestCreate(r *Repository, port int, nodes ...int64) (int64, error) {
return r.CreateForwardTx(1, "admin", "concurrent", 1, "127.0.0.1:80", "fifo", time.Now().UnixMilli(), 0, nodes, port, "", nil, 0, 0, nil, 0, 0, 0, true)
}
func TestAtomicPortAllocationAcrossRepositories(t *testing.T) {
path := filepath.Join(t.TempDir(), "ports.db")
a, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer a.Close()
b, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer b.Close()
runConcurrentPortAllocation(t, a, b)
}
func runConcurrentPortAllocation(t *testing.T, a, b *Repository) {
for _, id := range []int64{1, 2} {
if err := a.db.Create(&model.Node{ID: id, Name: fmt.Sprint(id), Port: "20000-20031"}).Error; err != nil {
t.Fatal(err)
}
}
const count = 16
start := make(chan struct{})
errs := make(chan error, count)
var wg sync.WaitGroup
for i := 0; i < count; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
<-start
r := a
if i%2 == 1 {
r = b
}
_, err := portTestCreate(r, 0, 1, 2)
errs <- err
}(i)
}
close(start)
wg.Wait()
close(errs)
for err := range errs {
if err != nil {
t.Fatal(err)
}
}
var rows []model.ForwardPort
if err := a.db.Order("port").Find(&rows).Error; err != nil {
t.Fatal(err)
}
if len(rows) != count*2 {
t.Fatalf("got %d reservations", len(rows))
}
seen := map[string]bool{}
for _, row := range rows {
k := fmt.Sprintf("%d:%d", row.NodeID, row.Port)
if seen[k] {
t.Fatalf("duplicate %s", k)
}
seen[k] = true
}
explicitStart := make(chan struct{})
explicitResults := make(chan error, 2)
for _, r := range []*Repository{a, b} {
go func(r *Repository) { <-explicitStart; _, err := portTestCreate(r, 20031, 1, 2); explicitResults <- err }(r)
}
close(explicitStart)
success := 0
for i := 0; i < 2; i++ {
if <-explicitResults == nil {
success++
}
}
if success != 1 {
t.Fatalf("explicit port race: %d successes, want exactly 1", success)
}
for p := 20000; p < 20000+count; p++ {
for _, n := range []int{1, 2} {
if !seen[fmt.Sprintf("%d:%d", n, p)] {
t.Fatalf("gap at %d:%d", n, p)
}
}
}
}
func TestAtomicPortAllocationRejectsConflictsAndExhaustion(t *testing.T) {
r, err := Open(":memory:")
if err != nil {
t.Fatal(err)
}
defer r.Close()
if err := r.db.Create(&model.Node{ID: 1, Port: "21000-21001"}).Error; err != nil {
t.Fatal(err)
}
id, err := portTestCreate(r, 21000, 1)
if err != nil {
t.Fatal(err)
}
if _, err := portTestCreate(r, 21000, 1); err == nil {
t.Fatal("explicit collision accepted")
}
if err := r.db.Transaction(func(tx *gorm.DB) error {
return r.CreateChainTunnelTx(tx, 2, "2", 1, sql.NullInt64{Int64: 21000, Valid: true}, "", 0, "", "")
}); err == nil {
t.Fatal("chain collision accepted")
}
if _, err := portTestCreate(r, 0, 1); err != nil {
t.Fatal(err)
}
if _, err := portTestCreate(r, 0, 1); err == nil {
t.Fatal("exhausted range accepted")
}
entries := []struct {
NodeID int64
Port int
InIP string
}{{1, 21001, ""}}
if err := r.ReplaceForwardPorts(id, entries, true); err == nil {
t.Fatal("replacement collision accepted")
}
var old model.ForwardPort
if err := r.db.Where("forward_id = ?", id).First(&old).Error; err != nil {
t.Fatal(err)
}
if old.Port != 21000 {
t.Fatal("failed replacement lost original reservation")
}
}
func TestAtomicPortAllocationPostgresAcrossRepositories(t *testing.T) {
dsn := os.Getenv("FLVX_POSTGRES_TEST_DSN")
if dsn == "" {
t.Skip("set FLVX_POSTGRES_TEST_DSN for isolated PostgreSQL allocation test")
}
admin, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
schema := fmt.Sprintf("port_allocation_%d", time.Now().UnixNano())
if _, err := admin.Exec("CREATE SCHEMA " + schema); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { admin.Exec("DROP SCHEMA " + schema + " CASCADE"); admin.Close() })
scoped := dsn + " search_path=" + schema
if strings.Contains(dsn, "://") {
u, err := url.Parse(dsn)
if err != nil {
t.Fatal(err)
}
q := u.Query()
q.Set("search_path", schema)
u.RawQuery = q.Encode()
scoped = u.String()
}
a, err := OpenPostgres(scoped)
if err != nil {
t.Fatal(err)
}
defer a.Close()
b, err := OpenPostgres(scoped)
if err != nil {
t.Fatal(err)
}
defer b.Close()
runConcurrentPortAllocation(t, a, b)
}
func TestAtomicPortAllocationRespectsRangesAndPendingCleanup(t *testing.T) {
r, err := Open(":memory:")
if err != nil {
t.Fatal(err)
}
defer r.Close()
nodes := []model.Node{{ID: 1, Port: "23004,23000-23002", IsRemote: 1, RemoteConfig: sql.NullString{String: `{"portRangeStart":23001,"portRangeEnd":23004}`, Valid: true}}, {ID: 2, Port: "23001-23004"}}
if err := r.db.Create(&nodes).Error; err != nil {
t.Fatal(err)
}
if err := r.db.Create(&model.TunnelRuntimeCleanup{TunnelID: 2, NodeID: 2, Kind: "service", Port: 23001}).Error; err != nil {
t.Fatal(err)
}
id, err := portTestCreate(r, 0, 1, 2)
if err != nil {
t.Fatal(err)
}
if got := r.GetMinForwardPort(id).Int64; got != 23002 {
t.Fatalf("got %d, want23002", got)
}
id2, err := portTestCreate(r, 0, 1, 2)
if err != nil {
t.Fatal(err)
}
if got := r.GetMinForwardPort(id2).Int64; got != 23004 {
t.Fatalf("got %d, want23004", got)
}
if err := r.DeleteForwardCascade(id); err != nil {
t.Fatal(err)
}
id3, err := portTestCreate(r, 0, 1, 2)
if err != nil {
t.Fatal(err)
}
if got := r.GetMinForwardPort(id3).Int64; got != 23002 {
t.Fatalf("released gap not reused: %d", got)
}
}
func TestAtomicPortAllocationIndependentNewEntries(t *testing.T) {
r, err := Open(":memory:")
if err != nil {
t.Fatal(err)
}
defer r.Close()
if err := r.db.Create(&[]model.Node{{ID: 1, Port: "24000-24001"}, {ID: 2, Port: "25000-25001"}}).Error; err != nil {
t.Fatal(err)
}
entries := []struct {
NodeID int64
Port int
InIP string
}{{1, 0, ""}, {2, 0, ""}}
if err := r.ReplaceForwardPortsIndividually(1, entries, true); err != nil {
t.Fatal(err)
}
var rows []model.ForwardPort
if err := r.db.Order("node_id").Find(&rows).Error; err != nil {
t.Fatal(err)
}
if len(rows) != 2 || rows[0].Port != 24000 || rows[1].Port != 25000 {
t.Fatalf("unexpected independent allocation: %+v", rows)
}
if _, err := r.CreateFederationTunnel("conflict", 1, "tcp", 0, 1, 24000); err == nil {
t.Fatal("federation collision accepted")
}
}
func TestAtomicPortPeerRuntimeConflicts(t *testing.T) {
path := filepath.Join(t.TempDir(), "mixed.db")
a, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer a.Close()
b, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer b.Close()
if err := a.db.Create(&model.Node{ID: 1, Port: "25000-25010"}).Error; err != nil {
t.Fatal(err)
}
runtime := func(key string, port int) *model.PeerShareRuntime {
return &model.PeerShareRuntime{ShareID: 1, NodeID: 1, Port: port, ResourceKey: key, ReservationID: key, Status: 1}
}
start := make(chan struct{})
results := make(chan error, 2)
go func() { <-start; _, err := portTestCreate(a, 25000, 1); results <- err }()
go func() { <-start; results <- b.CreatePeerShareRuntime(runtime("peer", 25000)) }()
close(start)
success := 0
for i := 0; i < 2; i++ {
if <-results == nil {
success++
}
}
if success != 1 {
t.Fatalf("mixed reservation race succeeded %d times", success)
}
first := runtime("first", 25001)
if err := a.CreatePeerShareRuntime(first); err != nil {
t.Fatal(err)
}
if err := b.CreatePeerShareRuntime(runtime("second", 25001)); err == nil {
t.Fatal("duplicate peer port accepted")
}
first.Role = "middle"
first.Applied = 1
if err := a.UpdatePeerShareRuntime(first); err != nil {
t.Fatalf("own metadata update: %v", err)
}
owned := runtime("federation-forward-1-22-25002", 25002)
owned.Role = "forward"
if err := a.db.Transaction(func(tx *gorm.DB) error {
return a.CreateChainTunnelTx(tx, 22, "1", 1, sql.NullInt64{Int64: 25002, Valid: true}, "fifo", 0, "tcp", "")
}); err != nil {
t.Fatal(err)
}
if err := a.CreatePeerShareRuntime(runtime("federation-forward-1-22-25002", 25002)); err == nil {
t.Fatal("generic spoof of ownership accepted")
}
if err := a.CreatePeerShareRuntime(owned); err != nil {
t.Fatalf("valid attachment rejected: %v", err)
}
other := runtime("other-forward", 25002)
other.Role = "forward"
if err := b.CreatePeerShareRuntime(other); err == nil {
t.Fatal("unowned forward attachment accepted")
}
pending := runtime("pending", 25003)
pending.Status = 0
pending.ReleasePending = 1
if err := a.db.Create(pending).Error; err != nil {
t.Fatal(err)
}
if _, err := portTestCreate(b, 25003, 1); err == nil {
t.Fatal("pending runtime reservation reused")
}
}
@@ -2,8 +2,6 @@ package repo
import (
"errors"
"strconv"
"go-backend/internal/relaysecurity"
"go-backend/internal/store/model"
"gorm.io/gorm"
@@ -24,8 +22,7 @@ func (r *Repository) RelayEndpointCredentials(tx *gorm.DB, tunnelID, nodeID int6
err := find()
if errors.Is(err, gorm.ErrRecordNotFound) && create {
var existing int64
// chain_tunnel stores roles as text; relay_endpoint_auth uses integers.
if e := db.Model(&model.ChainTunnel{}).Where("tunnel_id = ? AND node_id = ? AND chain_type = ?", tunnelID, nodeID, strconv.Itoa(role)).Count(&existing).Error; e != nil {
if e := db.Model(&model.ChainTunnel{}).Where("tunnel_id = ? AND node_id = ? AND chain_type = ?", tunnelID, nodeID, role).Count(&existing).Error; e != nil {
return nil, e
}
if existing > 0 {
@@ -1,98 +0,0 @@
package repo
import (
"fmt"
"path/filepath"
"strconv"
"strings"
"testing"
"github.com/jackc/pgx/v5/pgtype"
"gorm.io/gorm"
"go-backend/internal/relaysecurity"
"go-backend/internal/store/model"
)
func TestRelayEndpointCredentialsBindsLegacyChainTypeAsText(t *testing.T) {
for _, role := range []int{2, 3} {
t.Run(strconv.Itoa(role), func(t *testing.T) {
r, err := Open(filepath.Join(t.TempDir(), "relay.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = r.Close() })
// SQLite coerces integer parameters for this legacy text column.
// Check the actual repository query with pgx's text encoder as well,
// so the PostgreSQL regression is caught without a running server.
checked := 0
if err := r.DB().Callback().Query().After("gorm:query").Register("test:relay_chain_text_parameter", func(db *gorm.DB) {
if db.Statement.Table != "chain_tunnel" {
return
}
checked++
if len(db.Statement.Vars) != 3 {
db.AddError(fmt.Errorf("expected three chain lookup arguments, got %d", len(db.Statement.Vars)))
return
}
encoded, err := pgtype.NewMap().Encode(pgtype.TextOID, pgtype.TextFormatCode, db.Statement.Vars[2], nil)
if err != nil {
db.AddError(fmt.Errorf("encode chain_type for PostgreSQL: %w", err))
} else if string(encoded) != strconv.Itoa(role) {
db.AddError(fmt.Errorf("unexpected chain_type argument: %q", encoded))
}
}); err != nil {
t.Fatal(err)
}
tunnel := model.Tunnel{Name: "relay", Type: 2, Flow: 1, RelayAuthMode: relaysecurity.Required}
if err := r.DB().Create(&tunnel).Error; err != nil {
t.Fatal(err)
}
const nodeID = int64(7)
if err := r.DB().Transaction(func(tx *gorm.DB) error {
created, err := r.RelayEndpointCredentials(tx, tunnel.ID, nodeID, role, true)
if err != nil {
return err
}
for _, create := range []bool{false, true} {
loaded, err := r.RelayEndpointCredentials(tx, tunnel.ID, nodeID, role, create)
if err != nil {
return err
}
if *created != *loaded {
return fmt.Errorf("reloading endpoint changed credentials")
}
}
return nil
}); err != nil {
t.Fatalf("create and reload endpoint: %v", err)
}
if checked != 1 {
t.Fatalf("expected one chain lookup for a new endpoint, got %d", checked)
}
chain := model.ChainTunnel{TunnelID: tunnel.ID, NodeID: nodeID, ChainType: strconv.Itoa(role)}
if err := r.DB().Create(&chain).Error; err != nil {
t.Fatal(err)
}
if err := r.DB().Where("tunnel_id = ?", tunnel.ID).Delete(&model.RelayEndpointAuth{}).Error; err != nil {
t.Fatal(err)
}
if _, err := r.RelayEndpointCredentials(nil, tunnel.ID, nodeID, role, true); err == nil || !strings.Contains(err.Error(), "refusing regeneration") {
t.Fatalf("missing protected credentials must fail closed, got %v", err)
}
if checked != 2 {
t.Fatalf("expected chain lookup before refusing regeneration, got %d", checked)
}
var count int64
if err := r.DB().Model(&model.RelayEndpointAuth{}).Count(&count).Error; err != nil {
t.Fatal(err)
}
if count != 0 {
t.Fatal("regenerated credentials for an existing protected endpoint")
}
})
}
}
@@ -7,9 +7,6 @@ import (
)
func (r *Repository) QueueTunnelRuntimeCleanupTx(tx *gorm.DB, items []model.TunnelRuntimeCleanup) error {
if err := lockPortAllocationTx(tx); err != nil {
return err
}
for _, item := range items {
var node model.Node
if err := tx.Select("id", "is_remote").Where("id = ?", item.NodeID).First(&node).Error; err != nil {
@@ -440,15 +440,13 @@ func TestFederationDualPanelRemoteEntryRuntimeContract(t *testing.T) {
func insertContractNode(t *testing.T, r *repo.Repository, name, ip, portRange, secret string, status int) int64 {
t.Helper()
now := time.Now().UnixMilli()
var id int64
if err := r.DB().Raw(`
if err := r.DB().Exec(`
INSERT INTO node(name, secret, server_ip, server_ip_v4, server_ip_v6, port, interface_name, version, http, tls, socks, created_time, updated_time, status, tcp_listen_addr, udp_listen_addr, inx)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
RETURNING id
`, name, secret, ip, ip, "", portRange, "", "v1", 1, 1, 1, now, now, status, "[::]", "[::]", 0).Row().Scan(&id); err != nil {
`, name, secret, ip, ip, "", portRange, "", "v1", 1, 1, 1, now, now, status, "[::]", "[::]", 0).Error; err != nil {
t.Fatalf("insert node %s: %v", name, err)
}
return id
return mustLastInsertID(t, r, name)
}
func insertPeerShare(t *testing.T, r *repo.Repository, share *repo.PeerShare) int64 {
@@ -190,7 +190,7 @@ func TestPostgresBackupImportAdvancesEveryExplicitIDTable(t *testing.T) {
{"tunnel", func() error { _, err := r.CreateTunnelTx(r.DB(), "new", 1, 1, 0, 0, 1, nil, 0, "", "", 0); return err }},
{"chain tunnel", func() error { return r.CreateChainTunnelTx(r.DB(), 1, "1", 2, sql.NullInt64{}, "", 1, "tls", "") }},
{"forward", func() error {
_, err := r.CreateForwardTx(1, "old", "new", 1, "127.0.0.1:80", "", 0, 0, []int64{1}, 12346, "", nil, 0, 0, nil, 0, 0, 0)
_, err := r.CreateForwardTx(1, "old", "new", 1, "127.0.0.1:80", "", 0, 0, nil, 0, "", nil, 0, 0, nil, 0, 0, 0)
return err
}},
{"user tunnel", func() error { return r.InsertUserTunnel(2, 1, nil, 0, 0, 0, 0, 1) }},
@@ -428,9 +428,6 @@ func TestPostgresBackupImportAvoidsCascadeDeleteDeadlock(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := r.DB().Create(&model.Node{ID: 1, Name: "entry", Port: "10000-20000"}).Error; err != nil {
t.Fatal(err)
}
forward, err := r.CreateForwardTx(user, "delete-me", "old", 1, "127.0.0.1:80", "", 0, 0, []int64{1}, 12345, "", nil, 0, 0, nil, 0, 0, 0)
if err != nil {
t.Fatal(err)
@@ -11,24 +11,11 @@ import (
"time"
"go-backend/internal/auth"
httpserver "go-backend/internal/http"
"go-backend/internal/http/handler"
"go-backend/internal/store/repo"
)
func TestNewRelayTunnelEmitsMatchingPrivateEndpointAuthentication(t *testing.T) {
router, r := setupContractRouter(t, "relay-auth-contract")
assertNewRelayTunnelEndpointAuthentication(t, router, r)
}
func TestPostgresNewRelayTunnelEmitsMatchingPrivateEndpointAuthentication(t *testing.T) {
r := ownerNamesRepository(t, "postgres")()
router := httpserver.NewRouter(handler.New(r, "relay-auth-contract"), "relay-auth-contract")
assertNewRelayTunnelEndpointAuthentication(t, router, r)
}
func assertNewRelayTunnelEndpointAuthentication(t *testing.T, router http.Handler, r *repo.Repository) {
t.Helper()
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "relay-auth-contract")
@@ -1,98 +0,0 @@
package contract_test
import (
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"go-backend/internal/auth"
)
func TestTunnelRedeployStreamContract(t *testing.T) {
const secret = "contract-jwt-secret"
router, _ := setupContractRouter(t, secret)
token, err := auth.GenerateToken(1, "admin_user", 0, secret)
if err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy/stream", strings.NewReader(`{"ids":[999998,999999]}`))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
if !strings.HasPrefix(res.Header().Get("Content-Type"), "application/x-ndjson") {
t.Fatalf("expected streamed progress, got %s: %s", res.Header().Get("Content-Type"), res.Body.String())
}
decoder := json.NewDecoder(res.Body)
for _, want := range []string{"start", "processing", "item", "processing", "item", "done"} {
var event struct {
Type string `json:"type"`
Data json.RawMessage `json:"data"`
}
if err := decoder.Decode(&event); err != nil {
t.Fatal(err)
}
if event.Type != want {
t.Fatalf("got %s, want %s", event.Type, want)
}
if want == "item" {
var data struct{ Result map[string]interface{} }
if err := json.Unmarshal(event.Data, &data); err != nil {
t.Fatal(err)
}
if _, ok := data.Result["name"].(string); !ok {
t.Fatalf("item name must be a string, including missing tunnels: %s", event.Data)
}
}
if want == "done" {
var data struct {
Progress struct{ Total, Completed, Success, Failed int }
Result struct {
SuccessCount, FailCount int
Failures []struct {
ID int64
Reason string
}
}
}
if err := json.Unmarshal(event.Data, &data); err != nil {
t.Fatal(err)
}
if data.Progress.Total != 2 || data.Progress.Completed != 2 || data.Progress.Failed != 2 || data.Progress.Success != 0 || data.Result.FailCount != 2 || len(data.Result.Failures) != 2 {
t.Fatalf("incorrect completion: %+v", data)
}
if data.Result.Failures[0].Reason == "" {
t.Fatal("missing failure detail")
}
}
}
if !res.Flushed {
t.Fatal("stream did not flush")
}
}
func TestTunnelRedeployStreamAuthorizationContract(t *testing.T) {
const secret = "contract-jwt-secret"
router, repository := setupContractRouter(t, secret)
seedLegacyUser(t, repository, 9111, "stream-normal-user", "password")
token, err := auth.GenerateToken(9111, "stream-normal-user", 1, secret)
if err != nil {
t.Fatal(err)
}
for _, tc := range []struct {
name, token string
code int
}{{"anonymous", "", 401}, {"non-admin", token, 403}} {
t.Run(tc.name, func(t *testing.T) {
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy/stream", strings.NewReader(`{"ids":[999999]}`))
req.Header.Set("Authorization", tc.token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, tc.code)
if strings.Contains(res.Body.String(), `"type":"start"`) {
t.Fatal("unauthorized request started stream")
}
})
}
}
-14
View File
@@ -71,20 +71,6 @@ http {
}
# API代理到后端
location = /api/v1/tunnel/batch-redeploy/stream {
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_http_version 1.1;
proxy_buffering off;
proxy_cache off;
chunked_transfer_encoding on;
proxy_read_timeout 120s;
proxy_send_timeout 120s;
proxy_pass http://backend:6365/api/v1/tunnel/batch-redeploy/stream;
}
location = /api/v1/tunnel/diagnose/stream {
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
@@ -1,287 +0,0 @@
import type { BatchOperationResult } from "@/api/types";
import axios from "axios";
import { clearSession, getToken } from "@/utils/session";
const STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1000;
const MAX_EVENT_LENGTH = 1024 * 1024;
const UNCERTAIN_RESULT =
"下发进度连接中断,部分配置可能已执行,结果尚未确认。请核对节点与隧道状态后再决定是否重新下发,系统不会自动重试。";
export interface TunnelRedeployProgress {
total: number;
completed: number;
success: number;
failed: number;
}
export interface TunnelRedeployProcessing {
id: number;
name: string;
progress: TunnelRedeployProgress;
}
export interface TunnelRedeployItem {
result: {
id: number;
name: string;
success: boolean;
reason?: string;
};
progress: TunnelRedeployProgress;
}
interface TunnelRedeployCallbacks {
onStart?: (progress: TunnelRedeployProgress) => void;
onProcessing?: (payload: TunnelRedeployProcessing) => void;
onItem?: (payload: TunnelRedeployItem) => void;
}
type RawObject = Record<string, unknown>;
class RequestRejectedError extends Error {}
const object = (value: unknown): RawObject => {
if (!value || typeof value !== "object" || Array.isArray(value)) {
throw new Error(UNCERTAIN_RESULT);
}
return value as RawObject;
};
const readProgress = (value: unknown): TunnelRedeployProgress => {
const candidate = object(value);
const { total, completed, success, failed } = candidate;
if (
![total, completed, success, failed].every(
(count) =>
typeof count === "number" && Number.isSafeInteger(count) && count >= 0,
) ||
(completed as number) > (total as number) ||
(success as number) + (failed as number) !== completed
) {
throw new Error(UNCERTAIN_RESULT);
}
return { total, completed, success, failed } as TunnelRedeployProgress;
};
const expireSession = () => {
clearSession();
if (window.location.pathname !== "/") window.location.href = "/";
};
/** A mutation stream must never be retried or replayed through the legacy API. */
export const batchRedeployTunnelsStream = async (
ids: number[],
callbacks: TunnelRedeployCallbacks,
signal?: AbortSignal,
): Promise<BatchOperationResult> => {
if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
if (!ids.length || ids.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
throw new Error("请选择有效的隧道");
}
if (typeof fetch !== "function" || typeof TextDecoder === "undefined") {
throw new Error("当前浏览器不支持实时下发进度,请使用支持流式响应的浏览器");
}
const requestedIds = new Set(ids);
const controller = new AbortController();
const abort = () => controller.abort();
let timer: ReturnType<typeof setTimeout> | undefined;
let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
const resetTimeout = () => {
clearTimeout(timer);
timer = setTimeout(abort, STREAM_IDLE_TIMEOUT_MS);
};
signal?.addEventListener("abort", abort, { once: true });
resetTimeout();
try {
const base = axios.defaults.baseURL || "/api/v1/";
const response = await fetch(
`${base.endsWith("/") ? base : `${base}/`}tunnel/batch-redeploy/stream`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
Accept: "application/x-ndjson, application/json",
Authorization: getToken() || "",
},
body: JSON.stringify({ ids: Array.from(requestedIds) }),
signal: controller.signal,
},
);
if (response.status === 401) {
expireSession();
throw new RequestRejectedError("登录已过期,请重新登录");
}
if (response.status === 404 || response.status === 405) {
throw new RequestRejectedError(
"后端尚不支持实时下发进度,请升级后端后再操作;未自动改用旧接口下发",
);
}
if (
!response.headers.get("content-type")?.includes("application/x-ndjson")
) {
let payload: RawObject | undefined;
try {
payload = object(await response.json());
} catch {
throw new Error(UNCERTAIN_RESULT);
}
if (payload.code === 401) {
expireSession();
throw new RequestRejectedError("登录已过期,请重新登录");
}
if (typeof payload.code === "number" && payload.code !== 0) {
throw new RequestRejectedError(
typeof payload.msg === "string" ? payload.msg : "下发请求失败",
);
}
throw new Error(UNCERTAIN_RESULT);
}
if (!response.ok || !response.body) throw new Error(UNCERTAIN_RESULT);
reader = response.body.getReader();
const decoder = new TextDecoder("utf-8", { fatal: true });
let buffer = "";
let progress: TunnelRedeployProgress | undefined;
let currentId: number | undefined;
const completedIds = new Set<number>();
let finalResult: BatchOperationResult | undefined;
const processLine = (line: string) => {
if (!line.trim()) return;
const event = object(JSON.parse(line));
const data = object(event.data);
const next = readProgress(event.type === "start" ? data : data.progress);
if (
next.total !== requestedIds.size ||
(progress &&
(next.success < progress.success || next.failed < progress.failed))
)
throw new Error(UNCERTAIN_RESULT);
if (event.type === "start") {
if (progress || next.completed !== 0) throw new Error(UNCERTAIN_RESULT);
progress = next;
callbacks.onStart?.(next);
return;
}
if (!progress) throw new Error(UNCERTAIN_RESULT);
if (event.type === "processing") {
if (
typeof data.id !== "number" ||
!requestedIds.has(data.id) ||
typeof data.name !== "string" ||
completedIds.has(data.id) ||
currentId !== undefined ||
next.completed !== progress.completed
)
throw new Error(UNCERTAIN_RESULT);
currentId = data.id;
callbacks.onProcessing?.({
id: data.id,
name: data.name,
progress: next,
});
} else if (event.type === "item") {
const result = object(data.result);
if (
result.id !== currentId ||
currentId === undefined ||
typeof result.name !== "string" ||
typeof result.success !== "boolean" ||
(result.reason !== undefined && typeof result.reason !== "string") ||
next.completed !== progress.completed + 1 ||
next.success !== progress.success + (result.success ? 1 : 0) ||
next.failed !== progress.failed + (result.success ? 0 : 1)
)
throw new Error(UNCERTAIN_RESULT);
completedIds.add(currentId);
currentId = undefined;
callbacks.onItem?.({
result: result as unknown as TunnelRedeployItem["result"],
progress: next,
});
} else if (event.type === "done") {
const result = object(data.result);
const failures = result.failures ?? [];
if (
currentId !== undefined ||
next.completed !== next.total ||
next.completed !== completedIds.size ||
next.completed !== progress.completed ||
result.successCount !== next.success ||
result.failCount !== next.failed ||
!Array.isArray(failures) ||
failures.length !== next.failed ||
failures.some((failure) => {
const item = object(failure);
return (
typeof item.id !== "number" ||
!completedIds.has(item.id) ||
typeof item.reason !== "string" ||
(item.name !== undefined && typeof item.name !== "string")
);
})
)
throw new Error(UNCERTAIN_RESULT);
finalResult = result as unknown as BatchOperationResult;
} else {
throw new Error(UNCERTAIN_RESULT);
}
progress = next;
};
while (!finalResult) {
const { value, done } = await reader.read();
if (done) {
buffer += decoder.decode();
if (buffer.trim()) processLine(buffer);
break;
}
resetTimeout();
buffer += decoder.decode(value, { stream: true });
let newline: number;
while ((newline = buffer.indexOf("\n")) >= 0) {
const line = buffer.slice(0, newline);
buffer = buffer.slice(newline + 1);
if (line.length > MAX_EVENT_LENGTH) throw new Error(UNCERTAIN_RESULT);
processLine(line);
if (finalResult) break;
}
if (buffer.length > MAX_EVENT_LENGTH) throw new Error(UNCERTAIN_RESULT);
}
if (!finalResult) throw new Error(UNCERTAIN_RESULT);
return finalResult;
} catch (error) {
if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
if (error instanceof RequestRejectedError) throw error;
throw new Error(UNCERTAIN_RESULT);
} finally {
clearTimeout(timer);
controller.abort();
signal?.removeEventListener("abort", abort);
if (reader) {
// Cancel only the response reader, never resend an interrupted mutation.
await reader.cancel().catch(() => undefined);
reader.releaseLock();
}
}
};
@@ -58,7 +58,7 @@ export function OrderItem({
{...attributes}
{...listeners}
aria-label={`拖动排序:${label}`}
className={`inline-flex items-center justify-center shrink-0 rounded text-default-500 hover:bg-default-100 focus-visible:outline focus-visible:outline-2 focus-visible:outline-primary disabled:opacity-40 disabled:cursor-not-allowed cursor-grab active:cursor-grabbing ${row ? "p-1" : "h-8 w-8 [@media(pointer:coarse)]:h-11 [@media(pointer:coarse)]:w-11"}`}
className="shrink-0 rounded p-1 text-default-500 hover:bg-default-100 focus-visible:outline focus-visible:outline-2 focus-visible:outline-primary disabled:opacity-40 disabled:cursor-not-allowed cursor-grab active:cursor-grabbing"
disabled={disabled}
style={{ touchAction: "none" }}
type="button"
-8
View File
@@ -231,13 +231,6 @@ const CONFIG_ITEMS: ConfigItem[] = [
"开启后,普通用户创建或编辑规则时可将目标地址指向 127.0.0.1、10.x.x.x、172.16-31.x.x、192.168.x.x 等本地或内网地址。默认关闭以降低开放代理风险。",
type: "switch",
},
{
key: "sequential_port_enabled",
label: "顺次分配入口端口",
description:
"开启后,创建规则时如果不指定入口端口,将从节点端口范围内按从小到大的顺序分配第一个空闲端口(例如范围 100-1000,已用 100、101、103,则下一个为 102,再下一个为 104)。关闭时为随机分配。",
type: "switch",
},
];
const BACKUP_TYPE_OPTIONS = [
@@ -281,7 +274,6 @@ const getInitialConfigs = (): Record<string, string> => {
"is_commercial",
"license_expiry",
"hide_footer_brand",
"sequential_port_enabled",
];
const initialConfigs: Record<string, string> = {};
+3 -7
View File
@@ -358,18 +358,14 @@ export default function LimitPage() {
>
<Card className="shadow-sm overflow-hidden h-full">
<CardHeader className="pb-2 md:pb-2">
<div className="flex items-center gap-2 w-full min-w-0">
<div className="flex items-center gap-1 flex-1 min-w-0">
<OrderHandle />
<h3
className="font-semibold text-foreground truncate"
title={rule.name}
>
<div className="flex justify-between items-start w-full">
<div>
<h3 className="font-semibold text-foreground">
{rule.name}
</h3>
</div>
<Chip
className="shrink-0"
color={rule.status === 1 ? "success" : "danger"}
size="sm"
variant="flat"
+14 -26
View File
@@ -45,6 +45,7 @@ import { Chip } from "@/shadcn-bridge/heroui/chip";
import { Switch } from "@/shadcn-bridge/heroui/switch";
import { Spinner } from "@/shadcn-bridge/heroui/spinner";
import { Alert } from "@/shadcn-bridge/heroui/alert";
import { Progress } from "@/shadcn-bridge/heroui/progress";
import { Accordion, AccordionItem } from "@/shadcn-bridge/heroui/accordion";
import { Select, SelectItem } from "@/shadcn-bridge/heroui/select";
import { Checkbox } from "@/shadcn-bridge/heroui/checkbox";
@@ -69,10 +70,6 @@ import {
getConnectionStatusMeta,
getRemoteSyncErrorMessage,
} from "@/pages/node/display";
import {
NodeUpgradeProgress,
type NodeUpgradeProgressState,
} from "@/pages/node/upgrade-progress";
import { tryCopyInstallCommand } from "@/pages/node/install-command";
import {
getNodeRenewalSnapshot,
@@ -425,7 +422,7 @@ export default function NodePage() {
const [selectedVersion, setSelectedVersion] = useState("");
const [batchUpgradeLoading, setBatchUpgradeLoading] = useState(false);
const [upgradeProgress, setUpgradeProgress] = useState<
Record<number, NodeUpgradeProgressState>
Record<number, { stage: string; percent: number; message: string }>
>({});
const [infoPopoverPlacement, setInfoPopoverPlacement] = useState<
@@ -1123,13 +1120,6 @@ export default function NodePage() {
const node = nodeList.find((n) => n.id === upgradeTargetNodeId);
if (!node) return;
setUpgradeProgress((prev) => {
const next = { ...prev };
delete next[upgradeTargetNodeId];
return next;
});
setNodeList((prev) =>
prev.map((n) =>
n.id === upgradeTargetNodeId ? { ...n, upgradeLoading: true } : n,
@@ -1170,13 +1160,6 @@ export default function NodePage() {
return;
}
setUpgradeProgress((prev) => {
const next = { ...prev };
selectedLocalIds.forEach((id) => delete next[id]);
return next;
});
setBatchUpgradeLoading(true);
setUpgradeModalOpen(false);
try {
@@ -1973,11 +1956,6 @@ export default function NodePage() {
<span className="text-sm text-default-500">
{node.version || "-"}
</span>
{!isRemoteNode && (
<NodeUpgradeProgress
progress={upgradeProgress[node.id]}
/>
)}
</TableCell>
<TableCell>
<div className="flex flex-wrap items-center gap-1.5 min-w-max">
@@ -2283,9 +2261,19 @@ export default function NodePage() {
{node.version || "未知"}
</span>
</div>
<NodeUpgradeProgress
progress={upgradeProgress[node.id]}
{upgradeProgress[node.id] &&
upgradeProgress[node.id].percent < 100 && (
<div className="mt-1">
<Progress
showValueLabel
aria-label="升级进度"
color="warning"
label={upgradeProgress[node.id].message}
size="sm"
value={upgradeProgress[node.id].percent}
/>
</div>
)}
<div className="flex justify-between text-sm">
<span className="text-default-600">
开机时间
@@ -1,46 +0,0 @@
import { Progress } from "@/shadcn-bridge/heroui/progress";
export interface NodeUpgradeProgressState {
stage: string;
percent: number;
message: string;
}
const STAGE_LABELS: Record<string, string> = {
downloading: "下载",
verifying: "校验",
installing: "安装 / 重启",
};
export function NodeUpgradeProgress({
progress,
}: {
progress?: NodeUpgradeProgressState;
}) {
// The final installing event means the agent is restarting, not a durable
// job state. Do not leave a stale "重启中 100%" banner after it reconnects.
if (
!progress ||
(progress.stage === "installing" && progress.percent >= 100)
) {
return null;
}
const percent = Number.isFinite(progress.percent)
? Math.min(100, Math.max(0, progress.percent))
: 0;
const stage = STAGE_LABELS[progress.stage];
return (
<div className="mt-2 min-w-40 max-w-xs break-words" role="status">
<Progress
showValueLabel
aria-label={stage ? `升级${stage}进度` : "升级进度"}
color="warning"
label={progress.message || (stage ? `正在${stage}` : "正在升级")}
size="sm"
value={percent}
/>
</div>
);
}
+27 -39
View File
@@ -64,6 +64,7 @@ import {
getNodeList,
diagnoseTunnel,
updateTunnelOrder,
batchRedeployTunnels,
previewBatchTunnelDelete,
previewTunnelDelete,
} from "@/api";
@@ -73,11 +74,6 @@ import {
getDiagnosisQualityDisplay,
type DiagnosisResult,
} from "@/pages/tunnel/diagnosis";
import { useTunnelRedeploy } from "@/pages/tunnel/use-tunnel-redeploy";
import {
TunnelRedeployStatus,
TunnelRedeploySummary,
} from "@/pages/tunnel/redeploy-progress";
import { diagnoseTunnelStream } from "@/api/diagnosis-stream";
import {
createTunnelFormDefaults,
@@ -459,7 +455,6 @@ export default function TunnelPage() {
number | null
>(null);
const [batchLoading, setBatchLoading] = useState(false);
const redeploy = useTunnelRedeploy();
const [batchProgress, setBatchProgress] = useState<BatchProgressState>({
active: false,
label: "",
@@ -1356,12 +1351,19 @@ export default function TunnelPage() {
};
const handleBatchRedeploy = async () => {
if (selectedIds.size === 0 || batchLoading || redeploy.state?.running)
return;
if (selectedIds.size === 0) return;
setBatchLoading(true);
setBatchProgress({
active: true,
label: `正在重新下发 ${selectedIds.size} 条隧道...`,
percent: 30,
});
try {
const result = await redeploy.run(Array.from(selectedIds));
const res = await batchRedeployTunnels(Array.from(selectedIds));
if (res.code === 0) {
const result = res.data;
if (!result) return;
if (result.failCount === 0) {
toast.success(`成功重新下发 ${result.successCount} 项`);
} else {
@@ -1384,11 +1386,20 @@ export default function TunnelPage() {
}
setSelectedIds(new Set());
setSelectMode(false);
setBatchProgress({
active: true,
label: `重新下发完成:成功 ${result.successCount} 项,正在刷新列表...`,
percent: 100,
});
await refreshTunnelList(false);
} else {
toast.error(res.msg || "下发失败");
}
} catch (error) {
toast.error(
extractApiErrorMessage(error, "下发进度中断,请检查结果后再重试"),
);
toast.error(extractApiErrorMessage(error, "下发失败"));
} finally {
setBatchProgress({ active: false, label: "", percent: 0 });
setBatchLoading(false);
}
};
@@ -1696,11 +1707,7 @@ export default function TunnelPage() {
</Button>
<Button
color="danger"
isDisabled={
selectedIds.size === 0 ||
batchLoading ||
redeploy.state?.running
}
isDisabled={selectedIds.size === 0}
size="sm"
variant="flat"
onPress={handleOpenBatchDeleteModal}
@@ -1709,12 +1716,8 @@ export default function TunnelPage() {
</Button>
<Button
color="primary"
isDisabled={
selectedIds.size === 0 ||
batchLoading ||
redeploy.state?.running
}
isLoading={batchLoading || redeploy.state?.running}
isDisabled={selectedIds.size === 0}
isLoading={batchLoading}
size="sm"
variant="flat"
onPress={handleBatchRedeploy}
@@ -1786,11 +1789,6 @@ export default function TunnelPage() {
</div>
)}
<TunnelRedeploySummary
state={redeploy.state}
onDismiss={redeploy.clear}
/>
{/* 隧道卡片网格 */}
{tunnels.length > 0 ? (
viewMode === "list" ? (
@@ -1862,9 +1860,6 @@ export default function TunnelPage() {
{tunnel.name}
</span>
</div>
<TunnelRedeployStatus
row={redeploy.state?.rows[tunnel.id]}
/>
</TableCell>
<TableCell>
<Chip
@@ -1923,7 +1918,6 @@ export default function TunnelPage() {
<div className="flex flex-wrap items-center gap-1.5 min-w-max">
<Button
className="h-6 px-2 min-w-0 text-xs bg-indigo-50 text-indigo-600 hover:bg-indigo-100 dark:bg-indigo-950/30 dark:text-indigo-400"
isDisabled={redeploy.state?.running}
size="sm"
variant="flat"
onPress={() => handleEdit(tunnel)}
@@ -1940,7 +1934,6 @@ export default function TunnelPage() {
</Button>
<Button
className="h-6 px-2 min-w-0 text-xs bg-rose-50 text-rose-600 hover:bg-rose-100 dark:bg-rose-950/30 dark:text-rose-400"
isDisabled={redeploy.state?.running}
size="sm"
variant="flat"
onPress={() => handleDelete(tunnel)}
@@ -2022,9 +2015,6 @@ export default function TunnelPage() {
</CardHeader>
<CardBody className="pt-0 pb-3 md:pt-0 md:pb-3">
<TunnelRedeployStatus
row={redeploy.state?.rows[tunnel.id]}
/>
<div className="space-y-3">
{/* 拓扑结构 */}
<div className="pt-2 border-t border-divider">
@@ -2170,7 +2160,6 @@ export default function TunnelPage() {
<Button
className="flex-1 min-h-8"
color="primary"
isDisabled={redeploy.state?.running}
size="sm"
startContent={
<svg
@@ -2213,7 +2202,6 @@ export default function TunnelPage() {
<Button
className="flex-1 min-h-8"
color="danger"
isDisabled={redeploy.state?.running}
size="sm"
startContent={
<svg
@@ -1,97 +0,0 @@
import type {
TunnelRedeployRow,
TunnelRedeployState,
} from "./use-tunnel-redeploy";
import { Button } from "@/shadcn-bridge/heroui/button";
import { Progress } from "@/shadcn-bridge/heroui/progress";
import { Spinner } from "@/shadcn-bridge/heroui/spinner";
export function TunnelRedeployStatus({ row }: { row?: TunnelRedeployRow }) {
if (!row) return null;
const text = {
queued: "等待下发",
running: "正在下发配置…",
success: "配置下发成功",
failed: "配置下发失败",
unknown: "下发结果未确认",
}[row.status];
const color =
row.status === "failed"
? "text-danger"
: row.status === "success"
? "text-success"
: row.status === "unknown"
? "text-warning"
: "text-default-500";
return (
<div className={`mt-1 flex items-start gap-1.5 text-xs ${color}`}>
{row.status === "running" && <Spinner size="sm" />}
<span className="max-w-xs break-words" title={row.reason}>
{text}
{row.reason ? `:${row.reason}` : ""}
</span>
</div>
);
}
export function TunnelRedeploySummary({
state,
onDismiss,
}: {
state: TunnelRedeployState | null;
onDismiss: () => void;
}) {
if (!state) return null;
const { progress, running, error, currentName } = state;
const label = `${error ? "已确认" : "已完成"} ${progress.completed}/${progress.total} 条,成功 ${progress.success} 条,失败 ${progress.failed} 条`;
const percent =
progress.total > 0 ? (progress.completed / progress.total) * 100 : 0;
return (
<div
className="mb-4 space-y-2 rounded-xl border border-divider bg-content1 p-3"
role="status"
>
<div className="flex items-start justify-between gap-3">
<div className="min-w-0 space-y-1 break-words text-sm">
<p className="font-medium">
{running
? "正在下发隧道配置"
: error
? "下发进度已中断"
: "隧道配置下发结束"}
</p>
<p className="text-default-500">{label}</p>
{currentName && <p>当前:{currentName}</p>}
{running && (
<p className="text-xs text-default-500">
进度按已完成的隧道统计,当前隧道内部步骤不计百分比。请保留此页面。
</p>
)}
{error && <p className="text-warning">{error}</p>}
</div>
{!running && (
<Button
aria-label="关闭下发结果"
size="sm"
variant="light"
onPress={onDismiss}
>
关闭
</Button>
)}
</div>
<Progress
showValueLabel
aria-label="隧道配置下发进度"
color={error || progress.failed > 0 ? "warning" : "primary"}
size="sm"
value={percent}
/>
</div>
);
}
@@ -1,118 +0,0 @@
import { useEffect, useRef, useState } from "react";
import {
batchRedeployTunnelsStream,
type TunnelRedeployProgress,
} from "@/api/tunnel-redeploy-stream";
import { extractApiErrorMessage } from "@/api/error-message";
export interface TunnelRedeployRow {
status: "queued" | "running" | "success" | "failed" | "unknown";
reason?: string;
}
export interface TunnelRedeployState {
running: boolean;
progress: TunnelRedeployProgress;
rows: Record<number, TunnelRedeployRow>;
currentName?: string;
error?: string;
}
export function useTunnelRedeploy() {
const [state, setState] = useState<TunnelRedeployState | null>(null);
const abortRef = useRef<AbortController | null>(null);
useEffect(() => () => abortRef.current?.abort(), []);
const run = async (ids: number[]) => {
// Guard synchronously, before React has rendered a disabled button.
if (abortRef.current || ids.length === 0) return null;
const controller = new AbortController();
abortRef.current = controller;
setState({
running: true,
progress: { total: ids.length, completed: 0, success: 0, failed: 0 },
rows: Object.fromEntries(ids.map((id) => [id, { status: "queued" }])),
});
try {
const result = await batchRedeployTunnelsStream(
ids,
{
onStart: (progress) => {
setState((prev) => prev && { ...prev, progress });
},
onProcessing: ({ id, name, progress }) => {
setState(
(prev) =>
prev && {
...prev,
progress,
currentName: name || `隧道 #${id}`,
rows: { ...prev.rows, [id]: { status: "running" } },
},
);
},
onItem: ({ result: item, progress }) => {
setState(
(prev) =>
prev && {
...prev,
progress,
currentName: undefined,
rows: {
...prev.rows,
[item.id]: {
status: item.success ? "success" : "failed",
reason: item.reason,
},
},
},
);
},
},
controller.signal,
);
if (controller.signal.aborted) return null;
setState(
(prev) => prev && { ...prev, running: false, currentName: undefined },
);
return result;
} catch (error) {
if (controller.signal.aborted) return null;
setState(
(prev) =>
prev && {
...prev,
running: false,
currentName: undefined,
error: extractApiErrorMessage(
error,
"下发进度中断,请检查未确认的结果后再重试",
),
rows: Object.fromEntries(
Object.entries(prev.rows).map(([id, row]) => [
id,
row.status === "queued" || row.status === "running"
? { status: "unknown" }
: row,
]),
),
},
);
throw error;
} finally {
if (abortRef.current === controller) abortRef.current = null;
}
};
const clear = () => {
if (!abortRef.current) setState(null);
};
return { state, run, clear };
}
+6 -11
View File
@@ -1316,30 +1316,25 @@ export default function UserPage() {
>
<Card className="overflow-hidden h-full">
<CardHeader className="pb-2 md:pb-2">
<div className="flex flex-wrap items-start gap-2 w-full">
<div className="flex items-center gap-3 grow basis-44 min-w-0">
<OrderHandle />
<div className="flex justify-between items-start w-full">
<div className="flex items-center gap-3 flex-1 min-w-0">
<div className="flex items-center justify-center shrink-0 w-10 h-10 rounded-full bg-primary text-white font-bold text-sm relative">
{(user.name || user.user).slice(0, 2).toUpperCase()}
<span
className={`absolute bottom-0 right-0 w-3 h-3 border-2 border-white dark:border-zinc-900 rounded-full ${userStatus.color === "success" ? "bg-success" : "bg-danger"}`}
/>
</div>
<div className="flex flex-col flex-1 min-w-0">
<div className="flex items-center gap-1 min-w-0">
<OrderHandle />
<h3
className="font-semibold text-foreground truncate text-sm"
title={user.name || user.user}
>
<div className="flex flex-col min-w-0">
<h3 className="font-semibold text-foreground truncate text-sm">
{user.name || user.user}
</h3>
</div>
<p className="text-xs text-default-500 truncate">
@{user.user}
</p>
</div>
</div>
<div className="flex flex-wrap items-center gap-1.5 ml-auto max-w-full shrink-0">
<div className="flex items-center gap-1.5 ml-2">
<Chip
className="text-xs"
color={userStatus.color}