fix(relay): authenticate endpoints and fail closed on missing routes (#569)

* fix(relay): authenticate endpoints and fail closed on missing routes

* fix(tunnel): retain chains until receiver replacement is acknowledged

* docs: record final relay security review and validation
This commit is contained in:
sagit
2026-11-08 23:46:18 +08:00
committed by GitHub
parent 46bfb86c1b
commit fadc2b6c12
51 changed files with 5562 additions and 277 deletions
@@ -0,0 +1,131 @@
package contract_test
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"go-backend/internal/auth"
)
func TestForwardEntryRequiresTunnelChainContract(t *testing.T) {
for _, tunnelType := range []int{1, 2} {
t.Run(fmt.Sprintf("type-%d", tunnelType), func(t *testing.T) {
secret := "contract-jwt-secret"
router, repo := setupContractRouter(t, secret)
server := httptest.NewServer(router)
defer server.Close()
adminToken, err := auth.GenerateToken(1, "admin_user", 0, secret)
if err != nil {
t.Fatalf("generate admin token: %v", err)
}
now := time.Now().UnixMilli()
if err := repo.DB().Exec(`
INSERT INTO user(id, user, pwd, role_id, exp_time, flow, in_flow, out_flow, flow_reset_time, num, created_time, updated_time, status)
VALUES(202, 'forward_bind_retry_user', 'pwd', 1, 2727251700000, 99999, 0, 0, 1, 99999, ?, ?, 1)
`, now, now).Error; err != nil {
t.Fatalf("insert user: %v", err)
}
if err := repo.DB().Exec(`
INSERT INTO tunnel(name, traffic_ratio, type, protocol, flow, created_time, updated_time, status, in_ip, inx)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, "forward-bind-retry-tunnel", 1.0, tunnelType, "tls", 99999, now, now, 1, nil, 0).Error; err != nil {
t.Fatalf("insert tunnel: %v", err)
}
tunnelID := mustLastInsertID(t, repo, "forward-bind-retry-tunnel")
if err := repo.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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, "forward-bind-retry-node", "forward-bind-retry-secret", "10.42.0.1", "10.42.0.1", "", "44000-44010", "", "v1", 1, 1, 1, now, now, 1, "10.42.0.9", "[::]", 0).Error; err != nil {
t.Fatalf("insert node: %v", err)
}
nodeID := mustLastInsertID(t, repo, "forward-bind-retry-node")
if err := repo.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 1, ?, 44001, 'round', 1, 'tls')
`, tunnelID, nodeID).Error; err != nil {
t.Fatalf("insert chain_tunnel: %v", err)
}
if tunnelType == 2 {
if err := repo.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 3, ?, 44002, 'round', 1, 'tls')
`, tunnelID, nodeID).Error; err != nil {
t.Fatalf("insert exit chain: %v", err)
}
}
if err := repo.DB().Exec(`
INSERT INTO user_tunnel(id, user_id, tunnel_id, speed_id, num, flow, in_flow, out_flow, flow_reset_time, exp_time, status)
VALUES(41, 202, ?, NULL, 999, 99999, 0, 0, 1, 2727251700000, 1)
`, tunnelID).Error; err != nil {
t.Fatalf("insert user_tunnel: %v", err)
}
createPayload := map[string]interface{}{
"name": "forward-bind-retry-target",
"tunnelId": tunnelID,
"remoteAddr": "1.1.1.1:443",
"strategy": "fifo",
}
createBody, err := json.Marshal(createPayload)
if err != nil {
t.Fatalf("marshal create payload: %v", err)
}
var mu sync.Mutex
var emitted []map[string]interface{}
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, "forward-bind-retry-secret", func(kind string, data json.RawMessage) (bool, string) {
if kind == "AddService" || kind == "UpdateService" {
var services []map[string]interface{}
if json.Unmarshal(data, &services) == nil {
mu.Lock()
emitted = append(emitted, services...)
mu.Unlock()
}
}
return false, ""
})
defer stop()
waitNodeStatus(t, repo, nodeID, 1)
req := httptest.NewRequest(http.MethodPost, "/api/v1/forward/create", bytes.NewReader(createBody))
req.Header.Set("Authorization", adminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
mu.Lock()
defer mu.Unlock()
found := 0
for _, svc := range emitted {
h, ok := svc["handler"].(map[string]interface{})
if !ok || (h["type"] != "tcp" && h["type"] != "udp") {
continue
}
found++
md, _ := h["metadata"].(map[string]interface{})
if tunnelType == 2 {
if h["chain"] != fmt.Sprintf("chains_%d", tunnelID) || md["chain.strict"] != true {
t.Fatalf("tunnel forward must require chain, got %v", h)
}
} else if md["chain.strict"] == true {
t.Fatal("direct forward cannot require a tunnel chain")
}
}
if found < 2 {
t.Fatalf("expected TCP and UDP forwarding commands, got %d", found)
}
})
}
}
@@ -0,0 +1,637 @@
package contract_test
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"go-backend/internal/auth"
"go-backend/internal/store/repo"
)
func TestNewRelayTunnelEmitsMatchingPrivateEndpointAuthentication(t *testing.T) {
router, r := setupContractRouter(t, "relay-auth-contract")
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "relay-auth-contract")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "auth-entry", "192.0.2.10", "41000-41010", "entry-management-secret", 1)
exit := insertContractNode(t, r, "auth-exit", "192.0.2.11", "42000-42010", "exit-management-secret", 1)
var mu sync.Mutex
var connector, receiver map[string]interface{}
reconnectEvents := make(chan string, 8)
watchReconnect := false
record := func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "AddChains" || kind == "UpdateChains" {
var c map[string]interface{}
_ = json.Unmarshal(data, &c)
if nested, ok := c["data"].(map[string]interface{}); ok {
c = nested
}
hops, _ := c["hops"].([]interface{})
if len(hops) > 0 {
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
connector, _ = nodes[0].(map[string]interface{})["connector"].(map[string]interface{})["auth"].(map[string]interface{})
}
}
if kind == "AddService" || kind == "UpdateService" {
var services []map[string]interface{}
_ = json.Unmarshal(data, &services)
if len(services) > 0 {
receiver, _ = services[0]["handler"].(map[string]interface{})["auth"].(map[string]interface{})
if watchReconnect {
p, _ := receiver["password"].(string)
select {
case reconnectEvents <- p:
default:
}
}
}
}
return false, ""
}
stopEntry := startMockNodeSessionWithCommandRecorder(t, server.URL, "entry-management-secret", record)
defer stopEntry()
stopExit := startMockNodeSessionWithCommandRecorder(t, server.URL, "exit-management-secret", record)
defer stopExit()
payload := map[string]interface{}{"name": "authenticated-new-tunnel", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}}
body, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(body))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
mu.Lock()
if connector == nil || receiver == nil {
t.Fatal("new relay tunnel emitted no endpoint authentication")
}
if connector["username"] == "" || connector["password"] == "" || connector["username"] != receiver["username"] || connector["password"] != receiver["password"] {
t.Fatal("relay endpoint credentials missing or mismatched")
}
if receiver["password"] == "entry-management-secret" || receiver["password"] == "exit-management-secret" {
t.Fatal("management secret reused for relay")
}
listReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/list", bytes.NewBufferString(`{}`))
listReq.Header.Set("Authorization", token)
listRes := httptest.NewRecorder()
router.ServeHTTP(listRes, listReq)
if !bytes.Contains(listRes.Body.Bytes(), []byte(`"relayAuthMode":"required"`)) {
t.Fatalf("tunnel list does not expose required authentication state: %s", listRes.Body.String())
}
password, _ := receiver["password"].(string)
if bytes.Contains(listRes.Body.Bytes(), []byte(password)) {
t.Fatal("tunnel list disclosed relay credential")
}
exportReq := httptest.NewRequest(http.MethodPost, "/api/v1/backup/export", bytes.NewBufferString(`{"types":["tunnels"]}`))
exportReq.Header.Set("Authorization", token)
exportRes := httptest.NewRecorder()
router.ServeHTTP(exportRes, exportReq)
if !bytes.Contains(exportRes.Body.Bytes(), []byte(`"relayAuthMode":"required"`)) {
t.Fatal("configuration export lost required authentication policy")
}
if bytes.Contains(exportRes.Body.Bytes(), []byte(password)) {
t.Fatal("configuration export disclosed private relay password")
}
originalPassword := password
mu.Unlock()
var listed struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listRes.Body.Bytes(), &listed); err != nil || len(listed.Data) != 1 {
t.Fatal("missing created tunnel in list")
}
payload["id"] = listed.Data[0].ID
body, _ = json.Marshal(payload)
updateReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(body))
updateReq.Header.Set("Authorization", token)
updateRes := httptest.NewRecorder()
router.ServeHTTP(updateRes, updateReq)
assertCode(t, updateRes, 0)
mu.Lock()
if connector == nil || receiver == nil || connector["password"] != originalPassword || receiver["password"] != originalPassword {
t.Fatal("topology reapply lost or changed persisted endpoint authentication")
}
watchReconnect = true
mu.Unlock()
stopExit()
stopReconnected := startMockNodeSessionWithCommandRecorder(t, server.URL, "exit-management-secret", record)
defer stopReconnected()
// Request reconciliation explicitly rather than waiting for the production
// reconnect debounce (30 seconds). This crosses the same HTTP/command seam.
redeployBody, _ := json.Marshal(map[string]interface{}{"ids": []int64{listed.Data[0].ID}})
redeployReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy", bytes.NewReader(redeployBody))
redeployReq.Header.Set("Authorization", token)
redeployRes := httptest.NewRecorder()
router.ServeHTTP(redeployRes, redeployReq)
assertCode(t, redeployRes, 0)
select {
case password := <-reconnectEvents:
if password != originalPassword {
t.Fatal("node reconnect lost persisted authentication")
}
case <-time.After(5 * time.Second):
t.Fatal("node reconnect did not reconcile relay service")
}
// Corrupt private desired state as a fault fixture. Reapply must stop rather
// than regenerating a password or emitting an anonymous listener.
if err := r.DB().Exec("DELETE FROM relay_endpoint_auth WHERE tunnel_id = ?", listed.Data[0].ID).Error; err != nil {
t.Fatal(err)
}
missingReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(body))
missingReq.Header.Set("Authorization", token)
missingRes := httptest.NewRecorder()
router.ServeHTTP(missingRes, missingReq)
var missing struct {
Code int `json:"code"`
}
_ = json.Unmarshal(missingRes.Body.Bytes(), &missing)
if missing.Code == 0 {
t.Fatal("missing required credentials silently regenerated or downgraded")
}
}
func TestFederatedRelayRequiresVersionedAuthAndRejectsDowngrade(t *testing.T) {
router, r := setupContractRouter(t, "provider-auth-contract")
server := httptest.NewServer(router)
defer server.Close()
node := insertContractNode(t, r, "provider-auth", "192.0.2.30", "45000-45010", "provider-management", 1)
insertPeerShare(t, r, &repo.PeerShare{Name: "auth-share", NodeID: node, Token: "auth-share-token", PortRangeStart: 45000, PortRangeEnd: 45010, IsActive: 1})
var mu sync.Mutex
var received map[string]interface{}
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, "provider-management", func(kind string, data json.RawMessage) (bool, string) {
if kind == "UpdateService" {
var services []map[string]interface{}
_ = json.Unmarshal(data, &services)
if len(services) > 0 {
mu.Lock()
received, _ = services[0]["handler"].(map[string]interface{})["auth"].(map[string]interface{})
mu.Unlock()
}
}
return false, ""
})
defer stop()
post := func(path string, payload interface{}) *httptest.ResponseRecorder {
b, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(b))
req.Header.Set("Authorization", "Bearer auth-share-token")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
reserve := post("/api/v1/federation/runtime/reserve-port", map[string]interface{}{"resourceKey": "auth-contract-endpoint", "protocol": "tls"})
var reservation struct {
Code int `json:"code"`
Data struct {
ReservationID string `json:"reservationId"`
RelayAuthVersion int `json:"relayAuthVersion"`
} `json:"data"`
}
if err := json.Unmarshal(reserve.Body.Bytes(), &reservation); err != nil || reservation.Code != 0 {
t.Fatal("reserve failed")
}
if reservation.Data.RelayAuthVersion != 1 {
t.Fatal("provider did not advertise relay authentication capability")
}
creds := map[string]interface{}{"version": 1, "username": "test-relay-user", "password": "test-only-relay-password-32-bytes-long"}
request := map[string]interface{}{"reservationId": reservation.Data.ReservationID, "resourceKey": "auth-contract-endpoint", "role": "exit", "protocol": "tls", "relayAuth": creds}
applied := post("/api/v1/federation/runtime/apply-role", request)
if !bytes.Contains(applied.Body.Bytes(), []byte(`"relayAuthVersion":1`)) {
t.Fatal("provider did not acknowledge authenticated runtime")
}
assertCode(t, applied, 0)
mu.Lock()
actual := received
mu.Unlock()
if actual == nil || actual["username"] != creds["username"] || actual["password"] != creds["password"] {
t.Fatal("provider omitted requested relay authentication")
}
delete(request, "relayAuth")
rejected := post("/api/v1/federation/runtime/apply-role", request)
var result struct {
Code int `json:"code"`
}
_ = json.Unmarshal(rejected.Body.Bytes(), &result)
if result.Code == 0 {
t.Fatal("provider silently downgraded authenticated runtime")
}
// Loss of private persisted state must not be mistaken for legacy mode.
if err := r.DB().Exec("UPDATE peer_share_runtime SET relay_auth = '' WHERE resource_key = ?", "auth-contract-endpoint").Error; err != nil {
t.Fatal(err)
}
request["relayAuth"] = creds
missing := post("/api/v1/federation/runtime/apply-role", request)
_ = json.Unmarshal(missing.Body.Bytes(), &result)
if result.Code == 0 {
t.Fatal("provider recreated missing protected state instead of failing closed")
}
}
func TestNewFederatedTunnelAuthenticatesEveryRelayHop(t *testing.T) {
providerSecret := "provider-contract-jwt"
providerRouter, providerRepo := setupContractRouter(t, providerSecret)
providerServer := httptest.NewServer(providerRouter)
defer providerServer.Close()
consumerSecret := "consumer-contract-jwt"
consumerRouter, consumerRepo := setupContractRouter(t, consumerSecret)
consumerAdminToken, err := auth.GenerateToken(1, "consumer-admin", 0, consumerSecret)
if err != nil {
t.Fatalf("generate consumer admin token: %v", err)
}
now := time.Now().UnixMilli()
providerEntryNodeID := insertContractNode(t, providerRepo, "provider-entry", "198.51.100.11", "43000-43010", "provider-entry-secret", 1)
providerMiddleNodeID := insertContractNode(t, providerRepo, "provider-middle", "198.51.100.12", "44000-44010", "provider-middle-secret", 1)
providerExitNodeID := insertContractNode(t, providerRepo, "provider-exit", "198.51.100.13", "45000-45010", "provider-exit-secret", 1)
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "entry-share",
NodeID: providerEntryNodeID,
Token: "share-entry-token",
PortRangeStart: 43000,
PortRangeEnd: 43010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "middle-share",
NodeID: providerMiddleNodeID,
Token: "share-middle-token",
PortRangeStart: 44000,
PortRangeEnd: 44010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "exit-share",
NodeID: providerExitNodeID,
Token: "share-exit-token",
PortRangeStart: 45000,
PortRangeEnd: 45010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-entry-token")
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-middle-token")
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-exit-token")
entryRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-entry-token")
middleRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-middle-token")
exitRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-exit-token")
var mu sync.Mutex
services := map[string]string{}
strictMiddle, strictExit := false, false
connectors := map[string]string{}
record := func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "UpdateService" || kind == "AddService" {
var items []map[string]interface{}
_ = json.Unmarshal(data, &items)
for _, item := range items {
handler, _ := item["handler"].(map[string]interface{})
if handler["type"] == "relay" {
md, _ := handler["metadata"].(map[string]interface{})
if handler["chain"] != nil {
strictMiddle, _ = md["chain.strict"].(bool)
} else {
strictExit, _ = md["chain.strict"].(bool)
}
a, _ := handler["auth"].(map[string]interface{})
if a != nil {
user, _ := a["username"].(string)
pass, _ := a["password"].(string)
services[user] = pass
}
}
}
}
if kind == "UpdateChains" || kind == "AddChains" {
var c map[string]interface{}
_ = json.Unmarshal(data, &c)
if d, ok := c["data"].(map[string]interface{}); ok {
c = d
}
hops, _ := c["hops"].([]interface{})
for _, hop := range hops {
nodes, _ := hop.(map[string]interface{})["nodes"].([]interface{})
for _, node := range nodes {
a, _ := node.(map[string]interface{})["connector"].(map[string]interface{})["auth"].(map[string]interface{})
if a != nil {
user, _ := a["username"].(string)
pass, _ := a["password"].(string)
connectors[user] = pass
}
}
}
}
return false, ""
}
stopEntry := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-entry-secret", record)
defer stopEntry()
stopMiddle := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-middle-secret", record)
defer stopMiddle()
stopExit := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-exit-secret", record)
defer stopExit()
createTunnel := func(name string) int64 {
payload := map[string]interface{}{
"name": name,
"type": 2,
"flow": 99999,
"status": 1,
"inNodeId": []map[string]interface{}{
{"nodeId": entryRemoteNodeID, "protocol": "tls", "strategy": "round"},
},
"chainNodes": [][]map[string]interface{}{
{{"nodeId": middleRemoteNodeID, "protocol": "tls", "strategy": "round"}},
},
"outNodeId": []map[string]interface{}{
{"nodeId": exitRemoteNodeID, "protocol": "tls", "strategy": "round"},
},
}
body, err := json.Marshal(payload)
if err != nil {
t.Fatalf("marshal create payload: %v", err)
}
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(body))
req.Header.Set("Authorization", consumerAdminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
consumerRouter.ServeHTTP(res, req)
assertCode(t, res, 0)
tunnelID := mustQueryInt64(t, consumerRepo, `SELECT id FROM tunnel WHERE name = ? ORDER BY id DESC LIMIT 1`, name)
if tunnelID <= 0 {
t.Fatalf("invalid tunnel id for %s", name)
}
return tunnelID
}
_ = createTunnel("dual-panel-middle-exit-1")
mu.Lock()
defer mu.Unlock()
if !strictMiddle || strictExit {
t.Fatal("middle must require its chain and exit must permit direct dialing")
}
if len(services) != 2 || len(connectors) != 2 {
t.Fatalf("expected two authenticated receivers and matching connectors, got %d and %d", len(services), len(connectors))
}
for user, pass := range services {
if pass == "" || connectors[user] != pass {
t.Fatal("federation relay credentials do not match")
}
}
}
func TestRelayAuthenticationSurvivesInsertingBeforeExistingMiddle(t *testing.T) {
router, r := setupContractRouter(t, "insert-auth-contract")
server := httptest.NewServer(router)
defer server.Close()
token, _ := auth.GenerateToken(1, "admin", 0, "insert-auth-contract")
ids := []int64{}
var mu sync.Mutex
received := map[string]string{}
for i, name := range []string{"entry-a", "middle-b", "middle-c", "exit-d"} {
id := insertContractNode(t, r, name, fmt.Sprintf("192.0.2.%d", 40+i), fmt.Sprintf("%d-%d", 46000+i*100, 46010+i*100), name+"-secret", 1)
ids = append(ids, id)
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, name+"-secret", func(kind string, data json.RawMessage) (bool, string) {
if kind == "AddService" || kind == "UpdateService" {
var items []map[string]interface{}
_ = json.Unmarshal(data, &items)
for _, item := range items {
handler, _ := item["handler"].(map[string]interface{})
if a, ok := handler["auth"].(map[string]interface{}); ok {
mu.Lock()
received[name], _ = a["password"].(string)
mu.Unlock()
}
}
}
return false, ""
})
defer stop()
}
node := func(id int64) map[string]interface{} { return map[string]interface{}{"nodeId": id, "protocol": "tls"} }
payload := map[string]interface{}{"name": "insert-auth", "type": 2, "inNodeId": []map[string]interface{}{node(ids[0])}, "chainNodes": [][]map[string]interface{}{{node(ids[1])}}, "outNodeId": []map[string]interface{}{node(ids[3])}}
post := func(path string) *httptest.ResponseRecorder {
b, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(b))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
assertCode(t, post("/api/v1/tunnel/create"), 0)
mu.Lock()
original := received["middle-b"]
mu.Unlock()
if original == "" {
t.Fatal("original middle missing auth")
}
payload["id"] = mustQueryInt64(t, r, "SELECT id FROM tunnel WHERE name = ?", "insert-auth")
payload["chainNodes"] = [][]map[string]interface{}{{node(ids[2])}, {node(ids[1])}}
assertCode(t, post("/api/v1/tunnel/update"), 0)
mu.Lock()
defer mu.Unlock()
if received["middle-b"] != original || received["middle-c"] == "" || received["middle-c"] == original {
t.Fatal("hop insertion changed existing receiver identity or reused another credential")
}
}
func TestConvertingDirectTunnelRequiresRelayAuthentication(t *testing.T) {
router, r := setupContractRouter(t, "relay-auth-contract")
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "relay-auth-contract")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "auth-entry", "192.0.2.10", "41000-41010", "entry-management-secret", 1)
exit := insertContractNode(t, r, "auth-exit", "192.0.2.11", "42000-42010", "exit-management-secret", 1)
var mu sync.Mutex
var connector, receiver map[string]interface{}
record := func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "AddChains" || kind == "UpdateChains" {
var c map[string]interface{}
_ = json.Unmarshal(data, &c)
if nested, ok := c["data"].(map[string]interface{}); ok {
c = nested
}
hops, _ := c["hops"].([]interface{})
if len(hops) > 0 {
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
connector, _ = nodes[0].(map[string]interface{})["connector"].(map[string]interface{})["auth"].(map[string]interface{})
}
}
if kind == "AddService" || kind == "UpdateService" {
var services []map[string]interface{}
_ = json.Unmarshal(data, &services)
if len(services) > 0 {
receiver, _ = services[0]["handler"].(map[string]interface{})["auth"].(map[string]interface{})
}
}
return false, ""
}
stopEntry := startMockNodeSessionWithCommandRecorder(t, server.URL, "entry-management-secret", record)
defer stopEntry()
stopExit := startMockNodeSessionWithCommandRecorder(t, server.URL, "exit-management-secret", record)
defer stopExit()
payload := map[string]interface{}{"name": "authenticated-new-tunnel", "type": 1, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}}
body, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(body))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
payload["type"] = 2
payload["id"] = mustQueryInt64(t, r, "SELECT id FROM tunnel WHERE name = ?", "authenticated-new-tunnel")
conversionBody, _ := json.Marshal(payload)
conversionReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(conversionBody))
conversionReq.Header.Set("Authorization", token)
conversionRes := httptest.NewRecorder()
router.ServeHTTP(conversionRes, conversionReq)
assertCode(t, conversionRes, 0)
mu.Lock()
if connector == nil || receiver == nil {
t.Fatal("new relay tunnel emitted no endpoint authentication")
}
if connector["username"] == "" || connector["password"] == "" || connector["username"] != receiver["username"] || connector["password"] != receiver["password"] {
t.Fatal("relay endpoint credentials missing or mismatched")
}
if receiver["password"] == "entry-management-secret" || receiver["password"] == "exit-management-secret" {
t.Fatal("management secret reused for relay")
}
listReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/list", bytes.NewBufferString(`{}`))
listReq.Header.Set("Authorization", token)
listRes := httptest.NewRecorder()
router.ServeHTTP(listRes, listReq)
if !bytes.Contains(listRes.Body.Bytes(), []byte(`"relayAuthMode":"required"`)) {
t.Fatalf("tunnel list does not expose required authentication state: %s", listRes.Body.String())
}
password, _ := receiver["password"].(string)
if bytes.Contains(listRes.Body.Bytes(), []byte(password)) {
t.Fatal("tunnel list disclosed relay credential")
}
originalPassword := password
mu.Unlock()
var listed struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listRes.Body.Bytes(), &listed); err != nil || len(listed.Data) != 1 {
t.Fatal("missing created tunnel in list")
}
payload["id"] = listed.Data[0].ID
body, _ = json.Marshal(payload)
updateReq := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(body))
updateReq.Header.Set("Authorization", token)
updateRes := httptest.NewRecorder()
router.ServeHTTP(updateRes, updateReq)
assertCode(t, updateRes, 0)
mu.Lock()
defer mu.Unlock()
if connector == nil || receiver == nil || connector["password"] != originalPassword || receiver["password"] != originalPassword {
t.Fatal("topology reapply lost or changed persisted endpoint authentication")
}
}
func TestBackupImportCannotSilentlyDowngradeRequiredRelay(t *testing.T) {
router, _ := setupContractRouter(t, "backup-relay-auth")
token, _ := auth.GenerateToken(1, "admin", 0, "backup-relay-auth")
request := httptest.NewRequest(http.MethodPost, "/api/v1/backup/import", bytes.NewBufferString(`{"version":"1","types":["tunnels"],"tunnels":[{"id":92,"name":"protected-backup","type":2,"protocol":"tls","flow":1,"trafficRatio":1,"createdTime":1000,"status":1,"relayAuthMode":"required"}]}`))
request.Header.Set("Authorization", token)
result := httptest.NewRecorder()
router.ServeHTTP(result, request)
var out struct {
Code int `json:"code"`
}
if err := json.Unmarshal(result.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code == 0 {
t.Fatal("configuration backup restored required relay without its private credentials")
}
}
func TestNewRelayTunnelRefusesLegacyFederationBeforeReservation(t *testing.T) {
var mu sync.Mutex
mutations := 0
oldPeer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
if req.URL.Path != "/api/v1/federation/connect" {
mu.Lock()
mutations++
mu.Unlock()
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"code":0,"data":{"shareId":1,"shareName":"legacy","nodeId":1,"nodeName":"legacy-exit","serverIp":"192.0.2.80","status":1,"portRangeStart":49000,"portRangeEnd":49010}}`))
}))
defer oldPeer.Close()
router, r := setupContractRouter(t, "legacy-peer-contract")
token, _ := auth.GenerateToken(1, "admin", 0, "legacy-peer-contract")
entry := insertContractNode(t, r, "legacy-test-entry", "192.0.2.79", "48000-48010", "legacy-test-entry-secret", 1)
importRemoteNodeForContract(t, router, token, oldPeer.URL, "legacy-share-token")
exit := queryRemoteNodeIDByToken(t, r, "legacy-share-token")
payload := map[string]interface{}{"name": "must-not-downgrade", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}}
b, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(b))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
var out struct {
Code int `json:"code"`
}
_ = json.Unmarshal(res.Body.Bytes(), &out)
if out.Code == 0 {
t.Fatal("new tunnel silently accepted legacy federation")
}
mu.Lock()
defer mu.Unlock()
if mutations != 0 {
t.Fatal("legacy peer was mutated before capability refusal")
}
}
func TestLegacyRelayStateRemainsExplicitInList(t *testing.T) {
router, r := setupContractRouter(t, "legacy-mode-contract")
token, _ := auth.GenerateToken(1, "admin", 0, "legacy-mode-contract")
if err := r.DB().Exec(`INSERT INTO tunnel(name,traffic_ratio,type,protocol,flow,created_time,updated_time,status,inx) VALUES('legacy-existing',1,2,'tls',1,1000,1000,1,0)`).Error; err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/list", nil)
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
if !bytes.Contains(res.Body.Bytes(), []byte(`"relayAuthMode":"legacy"`)) {
t.Fatal("legacy relay exposure is hidden from API clients")
}
}
@@ -0,0 +1,311 @@
package contract_test
import (
"bytes"
"encoding/json"
"go-backend/internal/auth"
"net/http"
"net/http/httptest"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
)
func TestTunnelDeleteWaitsForCreateRuntime(t *testing.T) {
router, r := setupContractRouter(t, "create-lifecycle")
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "create-lifecycle")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "create-entry", "192.0.2.10", "41000-41010", "create-entry-secret", 1)
exit := insertContractNode(t, r, "create-exit", "192.0.2.11", "42000-42010", "create-exit-secret", 1)
entered, release := make(chan struct{}), make(chan struct{})
var once, releaseOnce sync.Once
unblock := func() { releaseOnce.Do(func() { close(release) }) }
deleted := make(chan struct{}, 1)
stopEntry := startMockNodeSessionWithCommandRecorder(t, server.URL, "create-entry-secret", func(kind string, _ json.RawMessage) (bool, string) {
if kind == "DeleteChains" {
select {
case deleted <- struct{}{}:
default:
}
}
return false, ""
})
defer stopEntry()
stopExit := startMockNodeSessionWithCommandRecorder(t, server.URL, "create-exit-secret", func(kind string, _ json.RawMessage) (bool, string) {
if kind == "AddService" {
once.Do(func() { close(entered); <-release })
}
return false, ""
})
defer stopExit()
defer unblock()
post := func(path string, payload interface{}) *httptest.ResponseRecorder {
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
created := make(chan *httptest.ResponseRecorder, 1)
go func() {
created <- post("/api/v1/tunnel/create", map[string]interface{}{"name": "create-race", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}})
}()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("create did not reach runtime gate")
}
listed := post("/api/v1/tunnel/list", map[string]interface{}{})
var list struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 1 {
t.Fatal("committed create not listed")
}
deleteDone := make(chan *httptest.ResponseRecorder, 1)
go func() { deleteDone <- post("/api/v1/tunnel/delete", map[string]interface{}{"id": list.Data[0].ID}) }()
select {
case <-deleted:
t.Error("delete removed runtime while create was still applying")
case <-time.After(150 * time.Millisecond):
}
unblock()
for _, done := range []chan *httptest.ResponseRecorder{created, deleteDone} {
select {
case res := <-done:
assertCode(t, res, 0)
case <-time.After(5 * time.Second):
t.Fatal("lifecycle operation stuck")
}
}
listed = post("/api/v1/tunnel/list", map[string]interface{}{})
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 0 {
t.Fatal("deleted tunnel remains listed")
}
}
func TestOfflineTunnelCreateReportsPendingRuntime(t *testing.T) {
router, r := setupContractRouter(t, "pending-lifecycle")
token, err := auth.GenerateToken(1, "admin", 0, "pending-lifecycle")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "pending-entry", "192.0.2.10", "41000-41010", "pending-entry-secret", 1)
exit := insertContractNode(t, r, "pending-exit", "192.0.2.11", "42000-42010", "pending-exit-secret", 1)
payload := map[string]interface{}{"name": "pending-tunnel", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}}
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
var out struct {
Code int `json:"code"`
Msg string `json:"msg"`
Data struct {
RuntimeStatus string `json:"runtimeStatus"`
TunnelID int64 `json:"tunnelId"`
} `json:"data"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code != 0 || out.Data.RuntimeStatus != "pending" || out.Data.TunnelID <= 0 || out.Msg == "操作成功" {
t.Fatalf("offline create must preserve config but explicitly report pending: %s", res.Body.String())
}
payload["id"] = out.Data.TunnelID
raw, _ = json.Marshal(payload)
req = httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res = httptest.NewRecorder()
router.ServeHTTP(res, req)
out.Data.RuntimeStatus = ""
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code != 0 || out.Data.RuntimeStatus != "pending" {
t.Fatalf("offline update must report pending: %s", res.Body.String())
}
raw, _ = json.Marshal(map[string]interface{}{"ids": []int64{out.Data.TunnelID}})
req = httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy", bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res = httptest.NewRecorder()
router.ServeHTTP(res, req)
var batch struct {
Data struct {
SuccessCount int `json:"successCount"`
FailCount int `json:"failCount"`
} `json:"data"`
}
if err := json.Unmarshal(res.Body.Bytes(), &batch); err != nil {
t.Fatal(err)
}
if batch.Data.SuccessCount != 0 || batch.Data.FailCount != 1 {
t.Fatalf("pending redeploy must not count as success: %s", res.Body.String())
}
}
func TestPendingTunnelUpdateStillRemovesObsoleteRelay(t *testing.T) {
testPendingTunnelRemoval(t, false, false)
}
func TestFailedObsoleteRelayRemovalPreservesItsChain(t *testing.T) {
testPendingTunnelRemoval(t, true, false)
}
func TestRedesiredRelayKeepsOldPortReservedUntilReplacementAcknowledged(t *testing.T) {
testPendingTunnelRemoval(t, true, true)
}
func testPendingTunnelRemoval(t *testing.T, failCleanup, readd bool) {
router, r := setupContractRouter(t, "pending-removal")
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "pending-removal")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "removal-entry", "192.0.2.10", "41000-41010", "removal-entry-secret", 1)
middle := insertContractNode(t, r, "removal-middle", "192.0.2.20", "42000-42010", "removal-middle-secret", 1)
exit := insertContractNode(t, r, "removal-exit", "192.0.2.30", "43000-43010", "removal-exit-secret", 1)
var entryTimeout atomic.Bool
stopEntry := startMockNodeSessionWithCommandRecorder(t, server.URL, "removal-entry-secret", func(kind string, _ json.RawMessage) (bool, string) {
if entryTimeout.Load() && (kind == "AddChains" || kind == "UpdateChains") {
return true, "等待节点响应超时"
}
return false, ""
})
defer stopEntry()
var mu sync.Mutex
deleted := map[string]bool{}
var timeoutReplacement bool
stopMiddle := startMockNodeSessionWithCommandRecorder(t, server.URL, "removal-middle-secret", func(kind string, _ json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "DeleteService" || kind == "DeleteChains" {
deleted[kind] = true
}
if timeoutReplacement && kind == "UpdateService" {
return true, "等待节点响应超时"
}
if failCleanup && kind == "DeleteService" {
return true, "cleanup rejected"
}
return false, ""
})
defer stopMiddle()
stopExit := startMockNodeSession(t, server.URL, "removal-exit-secret")
defer stopExit()
post := func(path string, payload interface{}) *httptest.ResponseRecorder {
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
payload := map[string]interface{}{"name": "pending-removal", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "chainNodes": [][]map[string]interface{}{{{"nodeId": middle, "protocol": "tls", "port": 42000}}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls"}}}
assertCode(t, post("/api/v1/tunnel/create", payload), 0)
listed := post("/api/v1/tunnel/list", map[string]interface{}{})
var list struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 1 {
t.Fatal("missing tunnel")
}
if readd {
entryTimeout.Store(true)
} else {
stopEntry()
waitNodeStatus(t, r, entry, 0)
}
payload["id"] = list.Data[0].ID
payload["chainNodes"] = [][]map[string]interface{}{}
res := post("/api/v1/tunnel/update", payload)
var out struct {
Msg string `json:"msg"`
Code int `json:"code"`
Data struct {
RuntimeStatus string `json:"runtimeStatus"`
} `json:"data"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code != 0 || out.Data.RuntimeStatus != "pending" {
t.Fatalf("expected pending update: %s", res.Body.String())
}
mu.Lock()
defer mu.Unlock()
if failCleanup {
if !deleted["DeleteService"] || deleted["DeleteChains"] {
t.Fatalf("failed listener deletion must preserve its required chain: %v", deleted)
}
if !strings.Contains(out.Msg, "cleanup rejected") {
t.Fatalf("cleanup failure hidden: %s", out.Msg)
}
if readd {
deleted = map[string]bool{}
timeoutReplacement = true
mu.Unlock()
payload["chainNodes"] = [][]map[string]interface{}{{{"nodeId": middle, "protocol": "tls", "port": 42001}}}
changed := post("/api/v1/tunnel/update", payload)
if err := json.Unmarshal(changed.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code != 0 || out.Data.RuntimeStatus != "pending" {
t.Fatalf("expected pending replacement: %s", changed.Body.String())
}
contender := map[string]interface{}{"name": "old-port-contender", "type": 2, "inNodeId": payload["inNodeId"], "outNodeId": payload["outNodeId"], "chainNodes": [][]map[string]interface{}{{{"nodeId": middle, "protocol": "tls", "port": 42000}}}}
blocked := post("/api/v1/tunnel/create", contender)
if err := json.Unmarshal(blocked.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code == 0 || !strings.Contains(out.Msg, "旧运行时清理") {
t.Fatalf("unacknowledged old port was not reserved: %s", blocked.Body.String())
}
mu.Lock()
timeoutReplacement = false
mu.Unlock()
post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{list.Data[0].ID}})
accepted := post("/api/v1/tunnel/create", contender)
if err := json.Unmarshal(accepted.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code != 0 {
t.Fatalf("acknowledged replacement did not release old port: %s", accepted.Body.String())
}
mu.Lock()
if len(deleted) != 0 {
t.Fatalf("delayed cleanup deleted re-desired relay: %v", deleted)
}
return
}
failCleanup = false
deleted = map[string]bool{}
mu.Unlock()
post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{list.Data[0].ID}})
mu.Lock()
if !deleted["DeleteService"] || !deleted["DeleteChains"] {
t.Fatalf("redeploy lost obsolete cleanup ownership after failure: %v", deleted)
}
deleted = map[string]bool{}
mu.Unlock()
post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{list.Data[0].ID}})
mu.Lock()
if len(deleted) != 0 {
t.Fatalf("acknowledged cleanup repeated: %v", deleted)
}
} else if !deleted["DeleteService"] || !deleted["DeleteChains"] {
t.Fatalf("pending update left removed relay live: %v", deleted)
}
}
@@ -0,0 +1,92 @@
package contract_test
import (
"bytes"
"encoding/json"
"go-backend/internal/auth"
"go-backend/internal/store/repo"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
)
func TestConcurrentCreatesReserveLocalPortsBeforeFederationAcknowledgment(t *testing.T) {
provider, pr := setupContractRouter(t, "port-provider")
entered, release := make(chan struct{}), make(chan struct{})
var gateOnce, releaseOnce sync.Once
unblock := func() { releaseOnce.Do(func() { close(release) }) }
ps := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/api/v1/federation/runtime/apply-role" {
gateOnce.Do(func() { close(entered); <-release })
}
provider.ServeHTTP(w, r)
}))
defer ps.Close()
exit := insertContractNode(t, pr, "provider-port-exit", "192.0.2.30", "43000-43010", "provider-port-exit-secret", 1)
now := time.Now().UnixMilli()
insertPeerShare(t, pr, &repo.PeerShare{Name: "port-share", NodeID: exit, Token: "port-share-token", PortRangeStart: 43000, PortRangeEnd: 43010, IsActive: 1, CreatedTime: now, UpdatedTime: now})
stop := startMockNodeSession(t, ps.URL, "provider-port-exit-secret")
defer stop()
defer unblock()
consumer, cr := setupContractRouter(t, "port-consumer")
token, err := auth.GenerateToken(1, "admin", 0, "port-consumer")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, cr, "local-port-entry", "192.0.2.10", "41000-41010", "local-port-entry-secret", 1)
middle := insertContractNode(t, cr, "local-port-middle", "192.0.2.20", "42000", "local-port-middle-secret", 1)
importRemoteNodeForContract(t, consumer, token, ps.URL, "port-share-token")
remoteExit := queryRemoteNodeIDByToken(t, cr, "port-share-token")
create := func(name string) *httptest.ResponseRecorder {
payload := map[string]interface{}{"name": name, "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "chainNodes": [][]map[string]interface{}{{{"nodeId": middle, "protocol": "tls"}}}, "outNodeId": []map[string]interface{}{{"nodeId": remoteExit, "protocol": "tls"}}}
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
consumer.ServeHTTP(res, req)
return res
}
first := make(chan *httptest.ResponseRecorder, 1)
go func() { first <- create("port-owner") }()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("first create did not reach provider gate")
}
second := make(chan *httptest.ResponseRecorder, 1)
go func() { second <- create("port-contender") }()
secondCompleted := false
select {
case res := <-second:
secondCompleted = true
var out struct {
Code int `json:"code"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code == 0 {
t.Errorf("second create reused the only reserved local port: %s", res.Body.String())
}
case <-time.After(300 * time.Millisecond):
t.Error("second create did not reject the reserved local port before provider acknowledgment")
}
unblock()
select {
case res := <-first:
assertCode(t, res, 0)
case <-time.After(5 * time.Second):
t.Fatal("first create stuck")
}
// If the regression let the second request reach the gated provider, drain it
// before closing test servers; its success still cannot erase the failure above.
if !secondCompleted {
select {
case <-second:
case <-time.After(5 * time.Second):
t.Fatal("second create stuck after gate release")
}
}
}
@@ -0,0 +1,110 @@
package contract_test
import (
"bytes"
"encoding/json"
"go-backend/internal/auth"
httpserver "go-backend/internal/http"
"go-backend/internal/http/handler"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
)
func TestDeletedTunnelCleanupSurvivesHandlerReplacement(t *testing.T) {
const secret = "deleted-cleanup"
router, r := setupContractRouter(t, secret)
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, secret)
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "deleted-entry", "192.0.2.10", "41000-41010", "deleted-entry-secret", 1)
exit := insertContractNode(t, r, "deleted-exit", "192.0.2.20", "42000", "deleted-exit-secret", 1)
stopEntry := startMockNodeSession(t, server.URL, "deleted-entry-secret")
defer stopEntry()
var rejectDelete atomic.Bool
rejectDelete.Store(true)
stopExit := startMockNodeSessionWithCommandRecorder(t, server.URL, "deleted-exit-secret", func(kind string, _ json.RawMessage) (bool, string) {
if kind == "DeleteService" && rejectDelete.Load() {
return true, "cleanup rejected"
}
return false, ""
})
defer stopExit()
post := func(path string, payload interface{}) *httptest.ResponseRecorder {
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
payload := map[string]interface{}{"name": "deleted-owner", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls", "port": 42000}}}
assertCode(t, post("/api/v1/tunnel/create", payload), 0)
listed := post("/api/v1/tunnel/list", map[string]interface{}{})
var list struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 1 {
t.Fatal("missing tunnel")
}
id := list.Data[0].ID
res := post("/api/v1/tunnel/delete", map[string]interface{}{"id": id})
var out struct {
Code int `json:"code"`
Msg string `json:"msg"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code == 0 || !strings.Contains(out.Msg, "待重试") {
t.Fatalf("failed post-delete cleanup not reported: %s", res.Body.String())
}
listed = post("/api/v1/tunnel/list", map[string]interface{}{})
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 0 {
t.Fatal("desired tunnel not deleted")
}
payload["name"] = "deleted-port-contender"
res = post("/api/v1/tunnel/create", payload)
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Code == 0 || !strings.Contains(out.Msg, "旧运行时清理") {
t.Fatalf("deleted tunnel lost port ownership: %s", res.Body.String())
}
stopEntry()
stopExit()
waitNodeStatus(t, r, entry, 0)
waitNodeStatus(t, r, exit, 0)
// A fresh handler has no old in-memory topology, locks, or cleanup state.
router = httpserver.NewRouter(handler.New(r, secret), secret)
recoveredServer := httptest.NewServer(router)
defer recoveredServer.Close()
newEntry := startMockNodeSession(t, recoveredServer.URL, "deleted-entry-secret")
defer newEntry()
var deleted atomic.Int32
newExit := startMockNodeSessionWithCommandRecorder(t, recoveredServer.URL, "deleted-exit-secret", func(kind string, _ json.RawMessage) (bool, string) {
if kind == "DeleteService" {
deleted.Add(1)
}
return false, ""
})
defer newExit()
waitNodeStatus(t, r, entry, 1)
waitNodeStatus(t, r, exit, 1)
assertCode(t, post("/api/v1/tunnel/delete", map[string]interface{}{"id": id}), 0)
if deleted.Load() != 1 {
t.Fatalf("fresh handler did not recover obsolete listener ownership: %d", deleted.Load())
}
assertCode(t, post("/api/v1/tunnel/create", payload), 0)
post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{id}})
if deleted.Load() != 1 {
t.Fatal("acknowledged cleanup replayed against replacement tunnel")
}
}
@@ -0,0 +1,214 @@
package contract_test
import (
"bytes"
"encoding/json"
"go-backend/internal/auth"
"go-backend/internal/store/repo"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
)
func TestFederationRedeployPreservesExistingBindings(t *testing.T) {
testFederationRedeploy(t, false, false)
}
func TestFederationFailedRedeployPreservesExistingBindings(t *testing.T) {
testFederationRedeploy(t, true, false)
}
func TestFederationCreateDoesNotHoldDatabaseDuringAcknowledgment(t *testing.T) {
testFederationRedeploy(t, false, true)
}
func testFederationRedeploy(t *testing.T, failRedeploy, gateCreate bool) {
providerSecret := "provider-contract-jwt"
providerRouter, providerRepo := setupContractRouter(t, providerSecret)
entered, release := make(chan struct{}), make(chan struct{})
var gateOnce, releaseOnce sync.Once
unblock := func() { releaseOnce.Do(func() { close(release) }) }
providerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if gateCreate && r.URL.Path == "/api/v1/federation/runtime/apply-role" {
gateOnce.Do(func() { close(entered); <-release })
}
providerRouter.ServeHTTP(w, r)
}))
defer providerServer.Close()
consumerSecret := "consumer-contract-jwt"
consumerRouter, consumerRepo := setupContractRouter(t, consumerSecret)
consumerAdminToken, err := auth.GenerateToken(1, "consumer-admin", 0, consumerSecret)
if err != nil {
t.Fatalf("generate consumer admin token: %v", err)
}
now := time.Now().UnixMilli()
providerEntryNodeID := insertContractNode(t, providerRepo, "provider-entry", "198.51.100.11", "43000-43010", "provider-entry-secret", 1)
providerMiddleNodeID := insertContractNode(t, providerRepo, "provider-middle", "198.51.100.12", "44000-44010", "provider-middle-secret", 1)
providerExitNodeID := insertContractNode(t, providerRepo, "provider-exit", "198.51.100.13", "45000-45010", "provider-exit-secret", 1)
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "entry-share",
NodeID: providerEntryNodeID,
Token: "share-entry-token",
PortRangeStart: 43000,
PortRangeEnd: 43010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "middle-share",
NodeID: providerMiddleNodeID,
Token: "share-middle-token",
PortRangeStart: 44000,
PortRangeEnd: 44010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
_ = insertPeerShare(t, providerRepo, &repo.PeerShare{
Name: "exit-share",
NodeID: providerExitNodeID,
Token: "share-exit-token",
PortRangeStart: 45000,
PortRangeEnd: 45010,
IsActive: 1,
CreatedTime: now,
UpdatedTime: now,
})
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-entry-token")
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-middle-token")
importRemoteNodeForContract(t, consumerRouter, consumerAdminToken, providerServer.URL, "share-exit-token")
entryRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-entry-token")
middleRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-middle-token")
exitRemoteNodeID := queryRemoteNodeIDByToken(t, consumerRepo, "share-exit-token")
var mu sync.Mutex
var destructive []string
var armed bool
recorder := func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "DeleteService" || kind == "DeleteChains" {
destructive = append(destructive, kind)
}
if armed && failRedeploy && kind == "UpdateService" {
return true, "simulated node update failure"
}
return false, ""
}
stopEntry := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-entry-secret", recorder)
defer stopEntry()
stopMiddle := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-middle-secret", recorder)
defer stopMiddle()
stopExit := startMockNodeSessionWithCommandRecorder(t, providerServer.URL, "provider-exit-secret", recorder)
defer stopExit()
createTunnel := func(name string) int64 {
payload := map[string]interface{}{
"name": name,
"type": 2,
"flow": 99999,
"status": 1,
"inNodeId": []map[string]interface{}{
{"nodeId": entryRemoteNodeID, "protocol": "tls", "strategy": "round"},
},
"chainNodes": [][]map[string]interface{}{
{{"nodeId": middleRemoteNodeID, "protocol": "tls", "strategy": "round"}},
},
"outNodeId": []map[string]interface{}{
{"nodeId": exitRemoteNodeID, "protocol": "tls", "strategy": "round"},
},
}
body, err := json.Marshal(payload)
if err != nil {
t.Fatalf("marshal create payload: %v", err)
}
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/create", bytes.NewReader(body))
req.Header.Set("Authorization", consumerAdminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
consumerRouter.ServeHTTP(res, req)
assertCode(t, res, 0)
tunnelID := mustQueryInt64(t, consumerRepo, `SELECT id FROM tunnel WHERE name = ? ORDER BY id DESC LIMIT 1`, name)
if tunnelID <= 0 {
t.Fatalf("invalid tunnel id for %s", name)
}
return tunnelID
}
defer unblock()
var firstTunnelID int64
if gateCreate {
created := make(chan int64, 1)
go func() { created <- createTunnel("dual-panel-middle-exit-1") }()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("create did not reach federation gate")
}
listed := make(chan struct{})
go func() {
defer close(listed)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/list", bytes.NewBufferString("{}"))
req.Header.Set("Authorization", consumerAdminToken)
consumerRouter.ServeHTTP(httptest.NewRecorder(), req)
}()
select {
case <-listed:
case <-time.After(300 * time.Millisecond):
t.Error("federation create held database while waiting for acknowledgment")
}
unblock()
select {
case firstTunnelID = <-created:
case <-time.After(5 * time.Second):
t.Fatal("create stuck after release")
}
select {
case <-listed:
case <-time.After(5 * time.Second):
t.Fatal("list stuck after release")
}
return
}
firstTunnelID = createTunnel("dual-panel-middle-exit-1")
mu.Lock()
destructive = nil
armed = true
mu.Unlock()
body, _ := json.Marshal(map[string]interface{}{"ids": []int64{firstTunnelID}})
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy", bytes.NewReader(body))
req.Header.Set("Authorization", consumerAdminToken)
res := httptest.NewRecorder()
consumerRouter.ServeHTTP(res, req)
var out struct {
Code int `json:"code"`
Data struct {
SuccessCount int `json:"successCount"`
FailCount int `json:"failCount"`
} `json:"data"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
expectedSuccess, expectedFailure := 1, 0
if failRedeploy {
expectedSuccess, expectedFailure = 0, 1
}
if out.Code != 0 || out.Data.SuccessCount != expectedSuccess || out.Data.FailCount != expectedFailure {
t.Fatalf("redeploy failed: %s", res.Body.String())
}
mu.Lock()
defer mu.Unlock()
if len(destructive) > 0 {
t.Fatalf("redeploy destroyed existing federation runtime: %v", destructive)
}
}
@@ -0,0 +1,510 @@
package contract_test
import (
"bytes"
"encoding/json"
"fmt"
"go-backend/internal/auth"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
)
func TestTunnelInsertMiddleHopRecordedRuntimeContract(t *testing.T) {
secret := "contract-jwt-secret"
router, r := setupContractRouter(t, secret)
server := httptest.NewServer(router)
defer server.Close()
adminToken, err := auth.GenerateToken(1, "admin_user", 0, secret)
if err != nil {
t.Fatalf("generate admin token: %v", err)
}
now := time.Now().UnixMilli()
if err := r.DB().Exec(`
INSERT INTO user(id, user, pwd, role_id, exp_time, flow, in_flow, out_flow, flow_reset_time, num, created_time, updated_time, status)
VALUES(2, 'issue281_transition_user', 'pwd', 1, 2727251700000, 99999, 0, 0, 1, 99999, ?, ?, 1)
`, now, now).Error; err != nil {
t.Fatalf("insert user: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO tunnel(name, traffic_ratio, type, protocol, flow, created_time, updated_time, status, in_ip, inx)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, "issue281-transition-tunnel", 1.0, 2, "tls", 99999, now, now, 1, nil, 0).Error; err != nil {
t.Fatalf("insert tunnel: %v", err)
}
tunnelID := mustLastInsertID(t, r, "issue281-transition-tunnel")
insertNode := func(name, secretValue, ip, portRange string, inx int) int64 {
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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, name, secretValue, ip, ip, "", portRange, "", "v1", 1, 1, 1, now, now, 1, "[::]", "[::]", inx).Error; err != nil {
t.Fatalf("insert node %s: %v", name, err)
}
return mustLastInsertID(t, r, name)
}
entryA := insertNode("issue281-transition-entry-a", "issue281-transition-entry-a-secret", "10.52.0.1", "54000-54010", 0)
entryB := insertNode("issue281-transition-entry-b", "issue281-transition-entry-b-secret", "10.52.0.2", "54000-54010", 1)
entryC := insertNode("issue281-transition-entry-c", "issue281-transition-entry-c-secret", "10.52.0.3", "54000-54010", 2)
exitNodeID := insertNode("issue281-transition-exit", "issue281-transition-exit-secret", "10.52.0.4", "57000-57010", 3)
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 1, ?, 54001, 'round', 1, 'tls')
`, tunnelID, entryA).Error; err != nil {
t.Fatalf("insert initial entry chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 3, ?, 57001, 'round', 1, 'tls')
`, tunnelID, exitNodeID).Error; err != nil {
t.Fatalf("insert exit chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO user_tunnel(id, user_id, tunnel_id, speed_id, num, flow, in_flow, out_flow, flow_reset_time, exp_time, status)
VALUES(282, 2, ?, NULL, 999, 99999, 0, 0, 1, 2727251700000, 1)
`, tunnelID).Error; err != nil {
t.Fatalf("insert user_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO forward(user_id, user_name, name, tunnel_id, remote_addr, strategy, in_flow, out_flow, created_time, updated_time, status, inx)
VALUES(2, 'issue281_transition_user', 'issue281-transition-forward', ?, '1.1.1.1:443', 'fifo', 0, 0, ?, ?, 1, 0)
`, tunnelID, now, now).Error; err != nil {
t.Fatalf("insert forward: %v", err)
}
forwardID := mustLastInsertID(t, r, "issue281-transition-forward")
if err := r.DB().Exec(`INSERT INTO forward_port(forward_id, node_id, port) VALUES(?, ?, ?)`, forwardID, entryA, 54001).Error; err != nil {
t.Fatalf("insert forward_port: %v", err)
}
// This mock records control-plane commands only; it does not forward traffic.
type command struct {
node, kind string
data json.RawMessage
}
var mu sync.Mutex
var commands []command
for _, n := range []struct {
name, secret string
id int64
}{
{"A", "issue281-transition-entry-a-secret", entryA},
{"B", "issue281-transition-entry-b-secret", entryB},
{"C", "issue281-transition-entry-c-secret", entryC},
{"D", "issue281-transition-exit-secret", exitNodeID},
} {
name := n.name
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, n.secret, func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
commands = append(commands, command{name, kind, append(json.RawMessage(nil), data...)})
return false, ""
})
defer stop()
waitNodeStatus(t, r, n.id, 1)
}
// Let initial mock-node reconnect reconciliation finish before the topology edit.
time.Sleep(time.Second)
node := func(id int64) map[string]interface{} {
return map[string]interface{}{"nodeId": id, "protocol": "tls", "strategy": "round"}
}
update := func(hops [][]map[string]interface{}) {
mu.Lock()
commands = nil
mu.Unlock()
payload := map[string]interface{}{"id": tunnelID, "name": "issue281-transition-tunnel", "type": 2, "flow": 99999, "trafficRatio": 1.0, "status": 1,
"inNodeId": []map[string]interface{}{node(entryA)}, "chainNodes": hops,
"outNodeId": []map[string]interface{}{{"nodeId": exitNodeID, "protocol": "tls", "strategy": "round", "port": 57001}}}
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(raw))
req.Header.Set("Authorization", adminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
}
check := func(edges map[string]int64) {
mu.Lock()
defer mu.Unlock()
expectedChain := fmt.Sprintf("chains_%d", tunnelID)
got := map[string]bool{}
services := map[string]bool{}
lastChains := map[string]int{}
lastServices := map[string]int{}
for i, c := range commands {
if c.kind == "UpdateChains" || c.kind == "AddChains" {
lastChains[c.node] = i
}
if c.kind == "UpdateService" || c.kind == "AddService" {
lastServices[c.node] = i
}
}
for i, c := range commands {
if c.kind == "DeleteChains" {
t.Fatalf("unexpected chain deletion on %s: %s", c.node, c.data)
}
if c.kind == "UpdateChains" || c.kind == "AddChains" {
if lastChains[c.node] != i {
continue
}
var raw map[string]interface{}
if err := json.Unmarshal(c.data, &raw); err != nil {
t.Fatal(err)
}
if nested, ok := raw["data"].(map[string]interface{}); ok {
raw = nested
}
target, ok := edges[c.node]
if !ok {
t.Fatalf("unexpected chain owner %s", c.node)
}
port := mustQueryInt(t, r, `SELECT port FROM chain_tunnel WHERE tunnel_id = ? AND node_id = ? LIMIT 1`, tunnelID, target)
ip := map[int64]string{entryB: "10.52.0.2", entryC: "10.52.0.3", exitNodeID: "10.52.0.4"}[target]
hops := raw["hops"].([]interface{})
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
addr := nodes[0].(map[string]interface{})["addr"]
if len(hops) != 1 || len(nodes) != 1 || addr != fmt.Sprintf("%s:%d", ip, port) {
t.Fatalf("bad edge %s: %s", c.node, c.data)
}
got[c.node] = true
t.Logf("%s -> %s via %s", c.node, ip, addr)
}
if strings.EqualFold(c.kind, "UpdateService") || strings.EqualFold(c.kind, "AddService") {
if lastServices[c.node] != i {
continue
}
var ss []map[string]interface{}
if err := json.Unmarshal(c.data, &ss); err != nil {
t.Fatal(err)
}
for _, s := range ss {
if s["name"] != fmt.Sprintf("tunnel_%d", tunnelID) {
continue
}
h := s["handler"].(map[string]interface{})
if c.node == "B" || c.node == "C" {
if h["chain"] != expectedChain {
t.Fatalf("missing chain on %s: %s", c.node, c.data)
}
}
if c.node == "D" && h["chain"] != nil {
t.Fatalf("exit has unexpected chain")
}
services[c.node] = true
}
}
}
for owner := range edges {
if !got[owner] {
t.Errorf("no chain update for %s", owner)
}
if owner != "A" && !services[owner] {
t.Errorf("no relay service for %s", owner)
}
}
if !services["D"] {
t.Error("no exit relay service")
}
}
update([][]map[string]interface{}{{node(entryB)}})
check(map[string]int64{"A": entryB, "B": exitNodeID})
update([][]map[string]interface{}{{node(entryB)}, {node(entryC)}})
check(map[string]int64{"A": entryB, "B": entryC, "C": exitNodeID})
// A remains the entry and the user's forward remains bound there.
after, _ := mustQueryInt64Int(t, r, `SELECT node_id,port FROM forward_port WHERE forward_id = ? LIMIT 1`, forwardID)
if after != entryA {
t.Fatalf("forward entry changed: %d", after)
}
}
func TestTunnelRedeployEditMissingChainWindowInvestigation(t *testing.T) {
t.Skip("Pre-repair characterization; preserved in plans/evidence/070-tunnel-insert-middle-hop-investigation.go.txt. Replaced by TestTunnelRedeployPreservesLiveRoutes and TestTunnelEditWaitsForRedeploy.")
secret := "contract-jwt-secret"
router, r := setupContractRouter(t, secret)
server := httptest.NewServer(router)
defer server.Close()
adminToken, err := auth.GenerateToken(1, "admin_user", 0, secret)
if err != nil {
t.Fatalf("generate admin token: %v", err)
}
now := time.Now().UnixMilli()
if err := r.DB().Exec(`
INSERT INTO user(id, user, pwd, role_id, exp_time, flow, in_flow, out_flow, flow_reset_time, num, created_time, updated_time, status)
VALUES(2, 'issue281_transition_user', 'pwd', 1, 2727251700000, 99999, 0, 0, 1, 99999, ?, ?, 1)
`, now, now).Error; err != nil {
t.Fatalf("insert user: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO tunnel(name, traffic_ratio, type, protocol, flow, created_time, updated_time, status, in_ip, inx)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, "issue281-transition-tunnel", 1.0, 2, "tls", 99999, now, now, 1, nil, 0).Error; err != nil {
t.Fatalf("insert tunnel: %v", err)
}
tunnelID := mustLastInsertID(t, r, "issue281-transition-tunnel")
insertNode := func(name, secretValue, ip, portRange string, inx int) int64 {
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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, name, secretValue, ip, ip, "", portRange, "", "v1", 1, 1, 1, now, now, 1, "[::]", "[::]", inx).Error; err != nil {
t.Fatalf("insert node %s: %v", name, err)
}
return mustLastInsertID(t, r, name)
}
entryA := insertNode("issue281-transition-entry-a", "issue281-transition-entry-a-secret", "10.52.0.1", "54000-54010", 0)
entryB := insertNode("issue281-transition-entry-b", "issue281-transition-entry-b-secret", "10.52.0.2", "54000-54010", 1)
entryC := insertNode("issue281-transition-entry-c", "issue281-transition-entry-c-secret", "10.52.0.3", "54000-54010", 2)
exitNodeID := insertNode("issue281-transition-exit", "issue281-transition-exit-secret", "10.52.0.4", "57000-57010", 3)
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 1, ?, 54001, 'round', 1, 'tls')
`, tunnelID, entryA).Error; err != nil {
t.Fatalf("insert initial entry chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 3, ?, 57001, 'round', 1, 'tls')
`, tunnelID, exitNodeID).Error; err != nil {
t.Fatalf("insert exit chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO user_tunnel(id, user_id, tunnel_id, speed_id, num, flow, in_flow, out_flow, flow_reset_time, exp_time, status)
VALUES(282, 2, ?, NULL, 999, 99999, 0, 0, 1, 2727251700000, 1)
`, tunnelID).Error; err != nil {
t.Fatalf("insert user_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO forward(user_id, user_name, name, tunnel_id, remote_addr, strategy, in_flow, out_flow, created_time, updated_time, status, inx)
VALUES(2, 'issue281_transition_user', 'issue281-transition-forward', ?, '1.1.1.1:443', 'fifo', 0, 0, ?, ?, 1, 0)
`, tunnelID, now, now).Error; err != nil {
t.Fatalf("insert forward: %v", err)
}
forwardID := mustLastInsertID(t, r, "issue281-transition-forward")
if err := r.DB().Exec(`INSERT INTO forward_port(forward_id, node_id, port) VALUES(?, ?, ?)`, forwardID, entryA, 54001).Error; err != nil {
t.Fatalf("insert forward_port: %v", err)
}
// This mock records control-plane commands only; it does not forward traffic.
type command struct {
node, kind string
data json.RawMessage
}
var mu sync.Mutex
var commands []command
armed := false
chainPresent, servicePresent := map[string]bool{}, map[string]bool{}
atDeleteService, releaseDeleteService, editReachedA := make(chan struct{}), make(chan struct{}), make(chan struct{}, 1)
var gateOnce, releaseOnce sync.Once
release := func() { releaseOnce.Do(func() { close(releaseDeleteService) }) }
defer release()
for _, n := range []struct {
name, secret string
id int64
}{
{"A", "issue281-transition-entry-a-secret", entryA},
{"B", "issue281-transition-entry-b-secret", entryB},
{"C", "issue281-transition-entry-c-secret", entryC},
{"D", "issue281-transition-exit-secret", exitNodeID},
} {
name := n.name
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, n.secret, func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
active := armed
shouldGate := active && name == "B" && kind == "DeleteService"
if active && name == "A" && kind == "UpdateChains" {
select {
case editReachedA <- struct{}{}:
default:
}
}
mu.Unlock()
if shouldGate {
gateOnce.Do(func() { close(atDeleteService); <-releaseDeleteService })
}
mu.Lock()
defer mu.Unlock()
if kind == "DeleteChains" {
chainPresent[name] = false
}
if kind == "AddChains" || kind == "UpdateChains" {
chainPresent[name] = true
}
if kind == "DeleteService" {
servicePresent[name] = false
}
if kind == "AddService" || kind == "UpdateService" {
servicePresent[name] = true
}
commands = append(commands, command{name, kind, append(json.RawMessage(nil), data...)})
return false, ""
})
defer stop()
waitNodeStatus(t, r, n.id, 1)
}
// Let initial mock-node reconnect reconciliation finish before the topology edit.
time.Sleep(time.Second)
node := func(id int64) map[string]interface{} {
return map[string]interface{}{"nodeId": id, "protocol": "tls", "strategy": "round"}
}
update := func(hops [][]map[string]interface{}) {
mu.Lock()
commands = nil
mu.Unlock()
payload := map[string]interface{}{"id": tunnelID, "name": "issue281-transition-tunnel", "type": 2, "flow": 99999, "trafficRatio": 1.0, "status": 1,
"inNodeId": []map[string]interface{}{node(entryA)}, "chainNodes": hops,
"outNodeId": []map[string]interface{}{{"nodeId": exitNodeID, "protocol": "tls", "strategy": "round", "port": 57001}}}
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(raw))
req.Header.Set("Authorization", adminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
}
check := func(edges map[string]int64) {
mu.Lock()
defer mu.Unlock()
expectedChain := fmt.Sprintf("chains_%d", tunnelID)
got := map[string]bool{}
services := map[string]bool{}
lastChains := map[string]int{}
lastServices := map[string]int{}
for i, c := range commands {
if c.kind == "UpdateChains" || c.kind == "AddChains" {
lastChains[c.node] = i
}
if c.kind == "UpdateService" || c.kind == "AddService" {
lastServices[c.node] = i
}
}
for i, c := range commands {
if c.kind == "DeleteChains" {
t.Fatalf("unexpected chain deletion on %s: %s", c.node, c.data)
}
if c.kind == "UpdateChains" || c.kind == "AddChains" {
if lastChains[c.node] != i {
continue
}
var raw map[string]interface{}
if err := json.Unmarshal(c.data, &raw); err != nil {
t.Fatal(err)
}
if nested, ok := raw["data"].(map[string]interface{}); ok {
raw = nested
}
target, ok := edges[c.node]
if !ok {
t.Fatalf("unexpected chain owner %s", c.node)
}
port := mustQueryInt(t, r, `SELECT port FROM chain_tunnel WHERE tunnel_id = ? AND node_id = ? LIMIT 1`, tunnelID, target)
ip := map[int64]string{entryB: "10.52.0.2", entryC: "10.52.0.3", exitNodeID: "10.52.0.4"}[target]
hops := raw["hops"].([]interface{})
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
addr := nodes[0].(map[string]interface{})["addr"]
if len(hops) != 1 || len(nodes) != 1 || addr != fmt.Sprintf("%s:%d", ip, port) {
t.Fatalf("bad edge %s: %s", c.node, c.data)
}
got[c.node] = true
t.Logf("%s -> %s via %s", c.node, ip, addr)
}
if strings.EqualFold(c.kind, "UpdateService") || strings.EqualFold(c.kind, "AddService") {
if lastServices[c.node] != i {
continue
}
var ss []map[string]interface{}
if err := json.Unmarshal(c.data, &ss); err != nil {
t.Fatal(err)
}
for _, s := range ss {
if s["name"] != fmt.Sprintf("tunnel_%d", tunnelID) {
continue
}
h := s["handler"].(map[string]interface{})
if c.node == "B" || c.node == "C" {
if h["chain"] != expectedChain {
t.Fatalf("missing chain on %s: %s", c.node, c.data)
}
}
if c.node == "D" && h["chain"] != nil {
t.Fatalf("exit has unexpected chain")
}
services[c.node] = true
}
}
}
for owner := range edges {
if !got[owner] {
t.Errorf("no chain update for %s", owner)
}
if owner != "A" && !services[owner] {
t.Errorf("no relay service for %s", owner)
}
}
if !services["D"] {
t.Error("no exit relay service")
}
}
update([][]map[string]interface{}{{node(entryB)}})
check(map[string]int64{"A": entryB, "B": exitNodeID})
mu.Lock()
armed = true
mu.Unlock()
redeployDone := make(chan struct{})
go func() {
defer close(redeployDone)
raw, _ := json.Marshal(map[string]interface{}{"ids": []int64{tunnelID}})
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy", bytes.NewReader(raw))
req.Header.Set("Authorization", adminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
t.Logf("redeploy response: %s", res.Body.String())
}()
await := func(ch <-chan struct{}, label string) {
t.Helper()
select {
case <-ch:
case <-time.After(10 * time.Second):
release()
t.Fatalf("timeout waiting for %s", label)
}
}
await(atDeleteService, "B DeleteService gate")
editDone := make(chan struct{})
go func() { defer close(editDone); update([][]map[string]interface{}{{node(entryB)}, {node(entryC)}}) }()
await(editReachedA, "edit UpdateChains on A")
mu.Lock()
missing, live := !chainPresent["B"], servicePresent["B"]
mu.Unlock()
if !missing || !live {
release()
t.Fatalf("expected B live service with missing chain during overlap, missing=%v live=%v", missing, live)
}
t.Log("Deterministic overlap confirmed: edit reached A while redeploy had deleted B chain but had not deleted B relay service")
release()
await(editDone, "edit completion")
await(redeployDone, "redeploy completion")
mu.Lock()
defer mu.Unlock()
t.Logf("final mock runtime chain presence: A=%v B=%v C=%v; services B=%v C=%v D=%v", chainPresent["A"], chainPresent["B"], chainPresent["C"], servicePresent["B"], servicePresent["C"], servicePresent["D"])
}
@@ -0,0 +1,363 @@
package contract_test
import (
"bytes"
"encoding/json"
"fmt"
"go-backend/internal/auth"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
)
func TestTunnelRedeployPreservesLiveRoutes(t *testing.T) {
testTunnelLifecycle(t, false, false, false)
}
func TestTunnelEditWaitsForRedeploy(t *testing.T) {
testTunnelLifecycle(t, true, false, false)
}
func TestTunnelFailedRedeployPreservesLiveRoutes(t *testing.T) {
testTunnelLifecycle(t, false, true, false)
}
func TestTunnelDeleteWaitsForRedeploy(t *testing.T) { testTunnelLifecycle(t, true, false, true) }
func testTunnelLifecycle(t *testing.T, concurrentEdit, failRedeploy, concurrentDelete bool) {
secret := "contract-jwt-secret"
router, r := setupContractRouter(t, secret)
server := httptest.NewServer(router)
defer server.Close()
adminToken, err := auth.GenerateToken(1, "admin_user", 0, secret)
if err != nil {
t.Fatalf("generate admin token: %v", err)
}
now := time.Now().UnixMilli()
if err := r.DB().Exec(`
INSERT INTO user(id, user, pwd, role_id, exp_time, flow, in_flow, out_flow, flow_reset_time, num, created_time, updated_time, status)
VALUES(2, 'issue281_transition_user', 'pwd', 1, 2727251700000, 99999, 0, 0, 1, 99999, ?, ?, 1)
`, now, now).Error; err != nil {
t.Fatalf("insert user: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO tunnel(name, traffic_ratio, type, protocol, flow, created_time, updated_time, status, in_ip, inx)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, "issue281-transition-tunnel", 1.0, 2, "tls", 99999, now, now, 1, nil, 0).Error; err != nil {
t.Fatalf("insert tunnel: %v", err)
}
tunnelID := mustLastInsertID(t, r, "issue281-transition-tunnel")
insertNode := func(name, secretValue, ip, portRange string, inx int) int64 {
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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, name, secretValue, ip, ip, "", portRange, "", "v1", 1, 1, 1, now, now, 1, "[::]", "[::]", inx).Error; err != nil {
t.Fatalf("insert node %s: %v", name, err)
}
return mustLastInsertID(t, r, name)
}
entryA := insertNode("issue281-transition-entry-a", "issue281-transition-entry-a-secret", "10.52.0.1", "54000-54010", 0)
entryB := insertNode("issue281-transition-entry-b", "issue281-transition-entry-b-secret", "10.52.0.2", "54000-54010", 1)
entryC := insertNode("issue281-transition-entry-c", "issue281-transition-entry-c-secret", "10.52.0.3", "54000-54010", 2)
exitNodeID := insertNode("issue281-transition-exit", "issue281-transition-exit-secret", "10.52.0.4", "57000-57010", 3)
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 1, ?, 54001, 'round', 1, 'tls')
`, tunnelID, entryA).Error; err != nil {
t.Fatalf("insert initial entry chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO chain_tunnel(tunnel_id, chain_type, node_id, port, strategy, inx, protocol)
VALUES(?, 3, ?, 57001, 'round', 1, 'tls')
`, tunnelID, exitNodeID).Error; err != nil {
t.Fatalf("insert exit chain_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO user_tunnel(id, user_id, tunnel_id, speed_id, num, flow, in_flow, out_flow, flow_reset_time, exp_time, status)
VALUES(282, 2, ?, NULL, 999, 99999, 0, 0, 1, 2727251700000, 1)
`, tunnelID).Error; err != nil {
t.Fatalf("insert user_tunnel: %v", err)
}
if err := r.DB().Exec(`
INSERT INTO forward(user_id, user_name, name, tunnel_id, remote_addr, strategy, in_flow, out_flow, created_time, updated_time, status, inx)
VALUES(2, 'issue281_transition_user', 'issue281-transition-forward', ?, '1.1.1.1:443', 'fifo', 0, 0, ?, ?, 1, 0)
`, tunnelID, now, now).Error; err != nil {
t.Fatalf("insert forward: %v", err)
}
forwardID := mustLastInsertID(t, r, "issue281-transition-forward")
if err := r.DB().Exec(`INSERT INTO forward_port(forward_id, node_id, port) VALUES(?, ?, ?)`, forwardID, entryA, 54001).Error; err != nil {
t.Fatalf("insert forward_port: %v", err)
}
// This mock records control-plane commands only; it does not forward traffic.
type command struct {
node, kind string
data json.RawMessage
}
var mu sync.Mutex
var commands []command
var armed, gateClaimed bool
entered := make(chan struct{})
release := make(chan struct{})
var gateOnce, releaseOnce sync.Once
unblock := func() { releaseOnce.Do(func() { close(release) }) }
defer unblock()
editApplied := make(chan struct{}, 1)
for _, n := range []struct {
name, secret string
id int64
}{
{"A", "issue281-transition-entry-a-secret", entryA},
{"B", "issue281-transition-entry-b-secret", entryB},
{"C", "issue281-transition-entry-c-secret", entryC},
{"D", "issue281-transition-exit-secret", exitNodeID},
} {
name := n.name
stop := startMockNodeSessionWithCommandRecorder(t, server.URL, n.secret, func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
gate := armed && !gateClaimed && name == "D" && kind == "UpdateService"
if gate {
gateClaimed = true
}
if armed && ((name == "C" && (kind == "UpdateChains" || kind == "AddChains")) || (concurrentDelete && kind == "DeleteChains")) {
select {
case editApplied <- struct{}{}:
default:
}
}
mu.Unlock()
if gate {
gateOnce.Do(func() { close(entered); <-release })
}
mu.Lock()
defer mu.Unlock()
commands = append(commands, command{name, kind, append(json.RawMessage(nil), data...)})
if armed && failRedeploy && name == "B" && kind == "UpdateService" {
return true, "bind: address already in use"
}
return false, ""
})
defer stop()
waitNodeStatus(t, r, n.id, 1)
}
// Let initial mock-node reconnect reconciliation finish before the topology edit.
time.Sleep(time.Second)
node := func(id int64) map[string]interface{} {
return map[string]interface{}{"nodeId": id, "protocol": "tls", "strategy": "round", "port": 54002}
}
update := func(hops [][]map[string]interface{}) {
mu.Lock()
commands = nil
mu.Unlock()
payload := map[string]interface{}{"id": tunnelID, "name": "issue281-transition-tunnel", "type": 2, "flow": 99999, "trafficRatio": 1.0, "status": 1,
"inNodeId": []map[string]interface{}{node(entryA)}, "chainNodes": hops,
"outNodeId": []map[string]interface{}{{"nodeId": exitNodeID, "protocol": "tls", "strategy": "round", "port": 57001}}}
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/update", bytes.NewReader(raw))
req.Header.Set("Authorization", adminToken)
req.Header.Set("Content-Type", "application/json")
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
}
check := func(edges map[string]int64) {
mu.Lock()
defer mu.Unlock()
expectedChain := fmt.Sprintf("chains_%d", tunnelID)
got := map[string]bool{}
services := map[string]bool{}
lastChains := map[string]int{}
lastServices := map[string]int{}
for i, c := range commands {
if c.kind == "UpdateChains" || c.kind == "AddChains" {
lastChains[c.node] = i
}
if c.kind == "UpdateService" || c.kind == "AddService" {
lastServices[c.node] = i
}
}
for i, c := range commands {
if c.kind == "DeleteChains" {
t.Fatalf("unexpected chain deletion on %s: %s", c.node, c.data)
}
if c.kind == "UpdateChains" || c.kind == "AddChains" {
if lastChains[c.node] != i {
continue
}
var raw map[string]interface{}
if err := json.Unmarshal(c.data, &raw); err != nil {
t.Fatal(err)
}
if nested, ok := raw["data"].(map[string]interface{}); ok {
raw = nested
}
target, ok := edges[c.node]
if !ok {
t.Fatalf("unexpected chain owner %s", c.node)
}
port := 54002
if target == exitNodeID {
port = 57001
}
ip := map[int64]string{entryB: "10.52.0.2", entryC: "10.52.0.3", exitNodeID: "10.52.0.4"}[target]
hops := raw["hops"].([]interface{})
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
addr := nodes[0].(map[string]interface{})["addr"]
if len(hops) != 1 || len(nodes) != 1 || addr != fmt.Sprintf("%s:%d", ip, port) {
t.Fatalf("bad edge %s: %s", c.node, c.data)
}
got[c.node] = true
t.Logf("%s -> %s via %s", c.node, ip, addr)
}
if strings.EqualFold(c.kind, "UpdateService") || strings.EqualFold(c.kind, "AddService") {
if lastServices[c.node] != i {
continue
}
var ss []map[string]interface{}
if err := json.Unmarshal(c.data, &ss); err != nil {
t.Fatal(err)
}
for _, s := range ss {
if s["name"] != fmt.Sprintf("tunnel_%d", tunnelID) {
continue
}
h := s["handler"].(map[string]interface{})
if c.node == "B" || c.node == "C" {
if h["chain"] != expectedChain {
t.Fatalf("missing chain on %s: %s", c.node, c.data)
}
}
if c.node == "D" && h["chain"] != nil {
t.Fatalf("exit has unexpected chain")
}
services[c.node] = true
}
}
}
for owner := range edges {
if !got[owner] {
t.Errorf("no chain update for %s", owner)
}
if owner != "A" && !services[owner] {
t.Errorf("no relay service for %s", owner)
}
}
if !services["D"] {
t.Error("no exit relay service")
}
}
update([][]map[string]interface{}{{node(entryB)}})
check(map[string]int64{"A": entryB, "B": exitNodeID})
mu.Lock()
commands = nil
mu.Unlock()
raw, _ := json.Marshal(map[string]interface{}{"ids": []int64{tunnelID}})
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/batch-redeploy", bytes.NewReader(raw))
req.Header.Set("Authorization", adminToken)
res := httptest.NewRecorder()
if !concurrentEdit {
mu.Lock()
armed = failRedeploy
mu.Unlock()
router.ServeHTTP(res, req)
if failRedeploy {
var out struct {
Data struct {
FailCount int `json:"failCount"`
SuccessCount int `json:"successCount"`
} `json:"data"`
}
if err := json.Unmarshal(res.Body.Bytes(), &out); err != nil {
t.Fatal(err)
}
if out.Data.FailCount != 1 || out.Data.SuccessCount != 0 {
t.Fatalf("expected redeploy failure: %s", res.Body.String())
}
mu.Lock()
defer mu.Unlock()
for _, c := range commands {
if c.kind == "DeleteService" || c.kind == "DeleteChains" {
t.Errorf("failed redeploy removed existing runtime: %s on %s", c.kind, c.node)
}
}
} else {
assertCode(t, res, 0)
check(map[string]int64{"A": entryB, "B": exitNodeID})
}
return
}
mu.Lock()
armed = true
mu.Unlock()
redeployDone := make(chan struct{})
go func() { defer close(redeployDone); router.ServeHTTP(res, req) }()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("redeploy did not reach command gate")
}
editDone := make(chan struct{})
go func() {
defer close(editDone)
if concurrentDelete {
body, _ := json.Marshal(map[string]interface{}{"id": tunnelID})
req := httptest.NewRequest(http.MethodPost, "/api/v1/tunnel/delete", bytes.NewReader(body))
req.Header.Set("Authorization", adminToken)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
assertCode(t, res, 0)
} else {
update([][]map[string]interface{}{{node(entryB)}, {node(entryC)}})
}
}()
select {
case <-editApplied:
t.Error("concurrent mutation changed runtime before redeploy finished")
case <-time.After(150 * time.Millisecond):
}
unblock()
for _, done := range []chan struct{}{redeployDone, editDone} {
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("lifecycle operation did not complete")
}
}
assertCode(t, res, 0)
if !concurrentDelete {
mu.Lock()
defer mu.Unlock()
latest := map[string]string{}
for _, c := range commands {
if c.kind != "UpdateChains" && c.kind != "AddChains" {
continue
}
var raw map[string]interface{}
if err := json.Unmarshal(c.data, &raw); err != nil {
t.Fatal(err)
}
if nested, ok := raw["data"].(map[string]interface{}); ok {
raw = nested
}
hops := raw["hops"].([]interface{})
nodes := hops[0].(map[string]interface{})["nodes"].([]interface{})
latest[c.node] = nodes[0].(map[string]interface{})["addr"].(string)
}
if latest["B"] != "10.52.0.3:54002" {
t.Fatalf("stale redeploy overwrote edit: B targets %s", latest["B"])
}
}
}
@@ -0,0 +1,117 @@
package contract_test
import (
"bytes"
"encoding/json"
"fmt"
"go-backend/internal/auth"
"net/http"
"net/http/httptest"
"sync"
"testing"
)
func TestMiddleToExitKeepsChainUntilReceiverReplacementAcknowledged(t *testing.T) {
for _, port := range []int{42000, 42001} {
for _, failure := range []string{"等待节点响应超时", "replacement rejected"} {
t.Run(fmt.Sprintf("port=%d/failure=%s", port, failure), func(t *testing.T) {
router, r := setupContractRouter(t, "role-transition")
server := httptest.NewServer(router)
defer server.Close()
token, err := auth.GenerateToken(1, "admin", 0, "role-transition")
if err != nil {
t.Fatal(err)
}
entry := insertContractNode(t, r, "role-entry", "192.0.2.10", "41000-41010", "role-entry-secret", 1)
middle := insertContractNode(t, r, "role-middle", "192.0.2.20", "42000-42010", "role-middle-secret", 1)
exit := insertContractNode(t, r, "role-exit", "192.0.2.30", "43000-43010", "role-exit-secret", 1)
stopEntry := startMockNodeSession(t, server.URL, "role-entry-secret")
defer stopEntry()
var mu sync.Mutex
failReplacement := false
replacementAccepted := false
unsafeDeletion := false
chainDeletes := 0
stopMiddle := startMockNodeSessionWithCommandRecorder(t, server.URL, "role-middle-secret", func(kind string, data json.RawMessage) (bool, string) {
mu.Lock()
defer mu.Unlock()
if kind == "UpdateService" {
if failReplacement {
return true, failure
}
var services []struct {
Handler struct {
Chain string `json:"chain"`
} `json:"handler"`
}
if err := json.Unmarshal(data, &services); err == nil && len(services) > 0 && services[0].Handler.Chain == "" {
replacementAccepted = true
}
}
if kind == "DeleteChains" {
chainDeletes++
if !replacementAccepted {
unsafeDeletion = true
}
}
return false, ""
})
defer stopMiddle()
stopExit := startMockNodeSession(t, server.URL, "role-exit-secret")
defer stopExit()
post := func(path string, payload interface{}) *httptest.ResponseRecorder {
raw, _ := json.Marshal(payload)
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
req.Header.Set("Authorization", token)
res := httptest.NewRecorder()
router.ServeHTTP(res, req)
return res
}
payload := map[string]interface{}{"name": "role-transition", "type": 2, "inNodeId": []map[string]interface{}{{"nodeId": entry, "protocol": "tls"}}, "chainNodes": [][]map[string]interface{}{{{"nodeId": middle, "protocol": "tls", "port": 42000}}}, "outNodeId": []map[string]interface{}{{"nodeId": exit, "protocol": "tls", "port": 43000}}}
assertCode(t, post("/api/v1/tunnel/create", payload), 0)
listed := post("/api/v1/tunnel/list", map[string]interface{}{})
var list struct {
Data []struct {
ID int64 `json:"id"`
} `json:"data"`
}
if err := json.Unmarshal(listed.Body.Bytes(), &list); err != nil || len(list.Data) != 1 {
t.Fatal("missing tunnel")
}
id := list.Data[0].ID
mu.Lock()
failReplacement = true
mu.Unlock()
payload["id"] = id
payload["chainNodes"] = [][]map[string]interface{}{}
payload["outNodeId"] = []map[string]interface{}{{"nodeId": middle, "protocol": "tls", "port": port}}
post("/api/v1/tunnel/update", payload)
post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{id}})
mu.Lock()
if chainDeletes != 0 || unsafeDeletion {
t.Errorf("old middle chain removed before receiver replacement ACK: deletes=%d unsafe=%v", chainDeletes, unsafeDeletion)
}
failReplacement = false
mu.Unlock()
recovered := post("/api/v1/tunnel/batch-redeploy", map[string]interface{}{"ids": []int64{id}})
var result struct {
Data struct {
SuccessCount int `json:"successCount"`
FailCount int `json:"failCount"`
} `json:"data"`
}
if err := json.Unmarshal(recovered.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Data.SuccessCount != 1 || result.Data.FailCount != 0 {
t.Fatalf("replacement retry failed: %s", recovered.Body.String())
}
mu.Lock()
defer mu.Unlock()
if !replacementAccepted || chainDeletes != 1 || unsafeDeletion {
t.Fatalf("obsolete chain must be removed exactly after successful exit replacement: accepted=%v deletes=%d unsafe=%v", replacementAccepted, chainDeletes, unsafeDeletion)
}
})
}
}
}