mirror of
https://github.com/Sagit-chu/flvx.git
synced 2026-11-16 17:34:23 +08:00
fix(relay): authenticate endpoints and fail closed on missing routes
This commit is contained in:
@@ -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"])
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user