feat: add control center, multiple relay nodes and P2P-first transport

This commit is contained in:
tongtong committed 2026-11-12 16:56:06 +08:00
1 parent 0988e9c363
commit 2abfb63da9
44 files changed
+3477 -67

No files matched your search

+144
View File
@@ -0,0 +1,144 @@
package relay
import (
"bytes"
"context"
"encoding/json"
"github.com/coder/websocket"
"github.com/pion/stun/v3"
"net"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
)
const secret = "test-cluster-secret-at-least-thirty-two-bytes"
func TestTicketScope(t *testing.T) {
now := time.Now()
good := Ticket{"s", "l", "n", "client", now.Add(time.Minute).Unix()}
encoded := Sign(secret, good)
if _, err := Verify(secret, encoded, "n", now); err != nil {
t.Fatal(err)
}
cases := []struct {
token, node string
when time.Time
}{{encoded, "other", now}, {encoded, "n", now.Add(2 * time.Minute)}, {encoded + "x", "n", now}, {Sign(secret, Ticket{"s", "l", "n", "admin", good.Expires}), "n", now}, {Sign(secret, Ticket{"s", "l", "n", "agent", now.Add(time.Hour).Unix()}), "n", now}}
for _, c := range cases {
if _, err := Verify(secret, c.token, c.node, c.when); err == nil {
t.Fatal("accepted invalid ticket")
}
}
}
func TestNodePairReplayAndRevocation(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
n := NewNode(ctx, "n", secret, 2)
defer n.Close()
s := httptest.NewServer(n.Handler())
defer s.Close()
ticket := func(side string) string {
return Sign(secret, Ticket{"s", "l", "n", side, time.Now().Add(time.Minute).Unix()})
}
dial := func(token string) (*websocket.Conn, *http.Response, error) {
return websocket.Dial(ctx, strings.Replace(s.URL, "http:", "ws:", 1)+"/v2/tunnel", &websocket.DialOptions{HTTPHeader: http.Header{"Authorization": []string{"Bearer " + token}}})
}
if c, r, e := dial(secret); e == nil {
c.CloseNow()
t.Fatal("accepted master secret as ticket")
} else if r.StatusCode != 401 {
t.Fatal(r.StatusCode)
}
a, _, err := dial(ticket("agent"))
if err != nil {
t.Fatal(err)
}
defer a.CloseNow()
c, _, err := dial(ticket("client"))
if err != nil {
t.Fatal(err)
}
defer c.CloseNow()
if other, r, e := dial(ticket("client")); e == nil {
other.CloseNow()
t.Fatal("replay accepted")
} else if r.StatusCode != 409 {
t.Fatal(r.StatusCode)
}
if err = c.Write(ctx, websocket.MessageBinary, []byte("adb")); err != nil {
t.Fatal(err)
}
kind, data, err := a.Read(ctx)
if err != nil || kind != websocket.MessageBinary || string(data) != "adb" {
t.Fatal(kind, string(data), err)
}
req, _ := http.NewRequest("POST", s.URL+"/internal/revoke", bytes.NewBufferString(`{"lease":"l"}`))
req.Header.Set("Authorization", "Bearer "+secret)
response, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
response.Body.Close()
if response.StatusCode != 204 {
t.Fatal(response.StatusCode)
}
if _, _, err := c.Read(ctx); err == nil {
t.Fatal("revocation did not close stream")
}
if other, r, e := dial(ticket("agent")); e == nil {
other.CloseNow()
t.Fatal("revoked ticket accepted")
} else if r.StatusCode != 409 {
t.Fatal(r.StatusCode)
}
}
func TestFailedUpgradeReleasesCapacity(t *testing.T) {
n := NewNode(context.Background(), "n", secret, 1)
defer n.Close()
req := httptest.NewRequest("GET", "/v2/tunnel", nil)
req.Header.Set("Authorization", "Bearer "+Sign(secret, Ticket{"s", "l", "n", "agent", time.Now().Add(time.Minute).Unix()}))
n.Handler().ServeHTTP(httptest.NewRecorder(), req)
recorder := httptest.NewRecorder()
n.Handler().ServeHTTP(recorder, httptest.NewRequest("GET", "/healthz", nil))
var value struct{ Sessions int }
json.Unmarshal(recorder.Body.Bytes(), &value)
if value.Sessions != 0 {
t.Fatal(value)
}
}
func TestSTUNBinding(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1)})
if err != nil {
t.Fatal(err)
}
go ServeSTUN(ctx, conn)
client, err := net.DialUDP("udp", nil, conn.LocalAddr().(*net.UDPAddr))
if err != nil {
t.Fatal(err)
}
defer client.Close()
client.SetDeadline(time.Now().Add(time.Second))
request := stun.MustBuild(stun.TransactionID, stun.BindingRequest)
client.Write(request.Raw)
buffer := make([]byte, 1500)
size, err := client.Read(buffer)
if err != nil {
t.Fatal(err)
}
response := &stun.Message{Raw: buffer[:size]}
if err = response.Decode(); err != nil {
t.Fatal(err)
}
var mapped stun.XORMappedAddress
if err = mapped.GetFrom(response); err != nil {
t.Fatal(err)
}
if mapped.Port != client.LocalAddr().(*net.UDPAddr).Port || !mapped.IP.Equal(net.IPv4(127, 0, 0, 1)) || response.TransactionID != request.TransactionID {
t.Fatal(mapped)
}
}