- server: add, delete and set-default node endpoints writing cluster.json with validation - deploy: grant ads-server write access to /etc/ads - flutter: relay node page with admin token plumbing, stop reconnecting devices removed from device list - flutter: fixed header heights and strut so tab switching never shifts refresh/notice
464 lines
12 KiB
Go
464 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/subtle"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/coder/websocket"
|
|
)
|
|
|
|
type agent struct {
|
|
id string
|
|
ws *websocket.Conn
|
|
v2 bool
|
|
}
|
|
type lease struct {
|
|
id string
|
|
device string
|
|
ws *websocket.Conn
|
|
}
|
|
type session struct {
|
|
id string
|
|
agent *agent
|
|
lease *lease
|
|
ready chan *websocket.Conn
|
|
ctx context.Context
|
|
cancel context.CancelFunc
|
|
claimed bool
|
|
v2 bool
|
|
signalKey string
|
|
}
|
|
type broker struct {
|
|
mu sync.Mutex
|
|
agents map[string]*agent
|
|
leases map[string]*lease // indexed by device, one owner per device
|
|
sessions map[string]*session
|
|
agentToken, clientToken string
|
|
adminToken string
|
|
managers map[string]*manager
|
|
ctx context.Context
|
|
cluster *cluster
|
|
}
|
|
|
|
func newBroker(ctx context.Context, agentToken, clientToken string) *broker {
|
|
return &broker{agents: make(map[string]*agent), leases: make(map[string]*lease),
|
|
sessions: make(map[string]*session), managers: make(map[string]*manager), agentToken: agentToken, clientToken: clientToken, ctx: ctx}
|
|
}
|
|
func newID() string {
|
|
var data [24]byte
|
|
if _, err := rand.Read(data[:]); err != nil {
|
|
panic(err)
|
|
}
|
|
return hex.EncodeToString(data[:])
|
|
}
|
|
func validID(id string) bool {
|
|
if len(id) < 1 || len(id) > 128 {
|
|
return false
|
|
}
|
|
for _, c := range id {
|
|
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("-_.", c)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
func (b *broker) auth(token string, handler http.HandlerFunc) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if subtle.ConstantTimeCompare([]byte(r.Header.Get("Authorization")), []byte("Bearer "+token)) != 1 {
|
|
http.Error(w, "unauthorized", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
handler(w, r)
|
|
}
|
|
}
|
|
func accept(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
|
|
conn, err := websocket.Accept(w, r, nil)
|
|
if err == nil {
|
|
conn.SetReadLimit(128 * 1024)
|
|
}
|
|
return conn, err
|
|
}
|
|
func writeJSON(ctx context.Context, ws *websocket.Conn, value any) error {
|
|
data, err := json.Marshal(value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
|
defer cancel()
|
|
return ws.Write(ctx, websocket.MessageText, data)
|
|
}
|
|
|
|
// A reader must be running while Ping waits for a pong.
|
|
func hold(ctx context.Context, ws *websocket.Conn) {
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
defer cancel()
|
|
go func() {
|
|
ticker := time.NewTicker(20 * time.Second)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
pingCtx, stop := context.WithTimeout(ctx, 10*time.Second)
|
|
err := ws.Ping(pingCtx)
|
|
stop()
|
|
if err != nil {
|
|
cancel()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
for {
|
|
if _, _, err := ws.Read(ctx); err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func (b *broker) agentEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
id := r.URL.Query().Get("device")
|
|
if !validID(id) {
|
|
http.Error(w, "invalid device ID", 400)
|
|
return
|
|
}
|
|
// Reserve before upgrading, so duplicate agents never replace an existing one.
|
|
a := &agent{id: id, v2: r.URL.Query().Get("v") == "2"}
|
|
b.mu.Lock()
|
|
if b.agents[id] != nil {
|
|
b.mu.Unlock()
|
|
http.Error(w, "device already registered", 409)
|
|
return
|
|
}
|
|
b.agents[id] = a
|
|
b.mu.Unlock()
|
|
defer func() {
|
|
b.mu.Lock()
|
|
if b.agents[id] == a {
|
|
delete(b.agents, id)
|
|
}
|
|
for _, s := range b.sessions {
|
|
if s.agent == a {
|
|
s.cancel()
|
|
}
|
|
}
|
|
l := b.leases[id]
|
|
var leaseConn *websocket.Conn
|
|
if l != nil {
|
|
leaseConn = l.ws
|
|
}
|
|
b.mu.Unlock()
|
|
if leaseConn != nil {
|
|
leaseConn.CloseNow()
|
|
}
|
|
}()
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
b.mu.Lock()
|
|
a.ws = ws
|
|
b.mu.Unlock()
|
|
registered := map[string]any{"type": "registered", "device": id}
|
|
if a.v2 {
|
|
registered["protocol"] = 2
|
|
}
|
|
if err := writeJSON(b.ctx, ws, registered); err != nil {
|
|
return
|
|
}
|
|
log.Printf("agent online: %s", id)
|
|
hold(b.ctx, ws)
|
|
log.Printf("agent offline: %s", id)
|
|
}
|
|
func (b *broker) devicesEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
type device struct {
|
|
ID string `json:"id"`
|
|
Busy bool `json:"busy"`
|
|
AgentID string `json:"agent_id,omitempty"`
|
|
ComputerName string `json:"computer_name,omitempty"`
|
|
}
|
|
devices := []device{}
|
|
b.mu.Lock()
|
|
for id, a := range b.agents {
|
|
if a.ws != nil {
|
|
item := device{ID: id, Busy: b.leases[id] != nil}
|
|
for agentID, m := range b.managers {
|
|
if m.ws == nil {
|
|
continue
|
|
}
|
|
for _, phone := range m.status.Devices {
|
|
if phone.ID == id {
|
|
item.AgentID = agentID
|
|
item.ComputerName = m.status.Name
|
|
if item.ComputerName == "" {
|
|
item.ComputerName = m.status.Hostname
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if item.AgentID != "" {
|
|
break
|
|
}
|
|
}
|
|
devices = append(devices, item)
|
|
}
|
|
}
|
|
b.mu.Unlock()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(devices)
|
|
}
|
|
func (b *broker) leaseEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
id := r.URL.Query().Get("device")
|
|
b.mu.Lock()
|
|
a := b.agents[id]
|
|
if a == nil || a.ws == nil {
|
|
b.mu.Unlock()
|
|
http.Error(w, "device offline", 404)
|
|
return
|
|
}
|
|
if b.leases[id] != nil {
|
|
b.mu.Unlock()
|
|
http.Error(w, "device busy", 409)
|
|
return
|
|
}
|
|
l := &lease{id: newID(), device: id}
|
|
b.leases[id] = l
|
|
b.mu.Unlock()
|
|
defer func() {
|
|
b.mu.Lock()
|
|
if b.leases[id] == l {
|
|
delete(b.leases, id)
|
|
}
|
|
for _, s := range b.sessions {
|
|
if s.lease == l {
|
|
s.cancel()
|
|
}
|
|
}
|
|
b.mu.Unlock()
|
|
b.cluster.revoke(l.id)
|
|
}()
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
b.mu.Lock()
|
|
if b.agents[id] != a {
|
|
b.mu.Unlock()
|
|
return
|
|
}
|
|
l.ws = ws
|
|
b.mu.Unlock()
|
|
protocol := 1
|
|
if b.cluster != nil && a.v2 && r.URL.Query().Get("v") == "2" {
|
|
protocol = 2
|
|
}
|
|
leased := map[string]any{"type": "leased", "lease": l.id}
|
|
if r.URL.Query().Get("v") == "2" {
|
|
leased["protocol"] = protocol
|
|
}
|
|
if err := writeJSON(b.ctx, ws, leased); err != nil {
|
|
return
|
|
}
|
|
hold(b.ctx, ws)
|
|
}
|
|
func (b *broker) connectEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
id, leaseID := r.URL.Query().Get("device"), r.URL.Query().Get("lease")
|
|
b.mu.Lock()
|
|
a, l := b.agents[id], b.leases[id]
|
|
if a == nil || a.ws == nil || l == nil || l.ws == nil || l.id != leaseID {
|
|
b.mu.Unlock()
|
|
http.Error(w, "no active lease", 409)
|
|
return
|
|
}
|
|
// Bound pending and active streams for each device.
|
|
count := 0
|
|
for _, s := range b.sessions {
|
|
if s.agent == a {
|
|
count++
|
|
}
|
|
}
|
|
if count >= 32 {
|
|
b.mu.Unlock()
|
|
http.Error(w, "stream limit reached", 429)
|
|
return
|
|
}
|
|
ctx, cancel := context.WithCancel(b.ctx)
|
|
s := &session{id: newID(), agent: a, lease: l, ready: make(chan *websocket.Conn, 1), ctx: ctx, cancel: cancel}
|
|
b.sessions[s.id] = s
|
|
b.mu.Unlock()
|
|
defer func() { s.cancel(); b.mu.Lock(); delete(b.sessions, s.id); b.mu.Unlock() }()
|
|
client, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer client.CloseNow()
|
|
if err := writeJSON(ctx, a.ws, map[string]string{"type": "open", "session": s.id}); err != nil {
|
|
return
|
|
}
|
|
timer := time.NewTimer(15 * time.Second)
|
|
defer timer.Stop()
|
|
select {
|
|
case upstream := <-s.ready:
|
|
defer upstream.CloseNow()
|
|
bridgeWebSockets(ctx, client, upstream)
|
|
case <-timer.C:
|
|
client.Close(websocket.StatusTryAgainLater, "device connection timed out")
|
|
case <-ctx.Done():
|
|
}
|
|
}
|
|
func (b *broker) dataEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
ticket, id := r.URL.Query().Get("session"), r.URL.Query().Get("device")
|
|
b.mu.Lock()
|
|
s := b.sessions[ticket]
|
|
if s == nil || s.v2 || s.agent.id != id || b.agents[id] != s.agent || s.claimed || s.ctx.Err() != nil {
|
|
b.mu.Unlock()
|
|
http.Error(w, "invalid or expired session", 404)
|
|
return
|
|
}
|
|
s.claimed = true
|
|
b.mu.Unlock()
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
s.cancel()
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
select {
|
|
case s.ready <- ws:
|
|
case <-s.ctx.Done():
|
|
return
|
|
}
|
|
<-s.ctx.Done()
|
|
}
|
|
func bridgeWebSockets(ctx context.Context, left, right *websocket.Conn) {
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
defer cancel()
|
|
copyMessages := func(dst, src *websocket.Conn) {
|
|
defer cancel()
|
|
for {
|
|
typ, data, err := src.Read(ctx)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if typ != websocket.MessageBinary {
|
|
return
|
|
}
|
|
writeCtx, stop := context.WithTimeout(ctx, 30*time.Second)
|
|
err = dst.Write(writeCtx, typ, data)
|
|
stop()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
go func() { defer wg.Done(); copyMessages(left, right) }()
|
|
go func() { defer wg.Done(); copyMessages(right, left) }()
|
|
wg.Wait()
|
|
}
|
|
func (b *broker) handler() http.Handler {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("GET /v3/agents/register", b.auth(b.agentToken, b.managerRegister))
|
|
mux.HandleFunc("GET /v3/agents", b.managementAuth(b.managersEndpoint))
|
|
mux.HandleFunc("/v3/rpc", b.managementAuth(b.managerRPCEndpoint))
|
|
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "ok\n") })
|
|
mux.HandleFunc("GET /v1/agent", b.auth(b.agentToken, b.agentEndpoint))
|
|
mux.HandleFunc("GET /v1/data", b.auth(b.agentToken, b.dataEndpoint))
|
|
mux.HandleFunc("GET /v1/devices", b.auth(b.clientToken, b.devicesEndpoint))
|
|
mux.HandleFunc("GET /v1/lease", b.auth(b.clientToken, b.leaseEndpoint))
|
|
mux.HandleFunc("GET /v1/connect", b.auth(b.clientToken, b.connectEndpoint))
|
|
mux.HandleFunc("GET /v2/nodes", b.auth(b.clientToken, b.nodesEndpoint))
|
|
mux.HandleFunc("POST /v2/nodes", b.managementAuth(b.addNodeEndpoint))
|
|
mux.HandleFunc("DELETE /v2/nodes/{id}", b.managementAuth(b.deleteNodeEndpoint))
|
|
mux.HandleFunc("POST /v2/nodes/default", b.managementAuth(b.defaultNodeEndpoint))
|
|
mux.HandleFunc("GET /v2/connect", b.auth(b.clientToken, b.clusterConnectEndpoint))
|
|
mux.HandleFunc("GET /v2/signal", b.auth(b.agentToken, b.signalEndpoint))
|
|
return mux
|
|
}
|
|
func main() {
|
|
listen := flag.String("listen", "127.0.0.1:8080", "HTTP listen address (use a TLS reverse proxy for public access)")
|
|
cert := flag.String("tls-cert", "", "TLS certificate PEM path")
|
|
key := flag.String("tls-key", "", "TLS private key PEM path")
|
|
clusterFile := flag.String("cluster-config", "", "Cluster configuration JSON; empty preserves standalone v1 mode")
|
|
insecureNodes := flag.Bool("allow-insecure-nodes", false, "Allow ws relay URLs for isolated integration tests")
|
|
flag.Parse()
|
|
agentToken, clientToken := os.Getenv("ADS_AGENT_TOKEN"), os.Getenv("ADS_CLIENT_TOKEN")
|
|
if len(agentToken) < 32 || len(clientToken) < 32 || agentToken == clientToken {
|
|
log.Fatal("set distinct ADS_AGENT_TOKEN and ADS_CLIENT_TOKEN, at least 32 characters each")
|
|
}
|
|
if (*cert == "") != (*key == "") {
|
|
log.Fatal("provide both --tls-cert and --tls-key")
|
|
}
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
b := newBroker(ctx, agentToken, clientToken)
|
|
b.adminToken = os.Getenv("ADS_ADMIN_TOKEN")
|
|
if b.adminToken != "" && (len(b.adminToken) < 32 || b.adminToken == agentToken || b.adminToken == clientToken) {
|
|
log.Fatal("ADS_ADMIN_TOKEN must be distinct and at least 32 characters")
|
|
}
|
|
if *clusterFile != "" {
|
|
configured, err := loadCluster(*clusterFile, os.Getenv("ADS_RELAY_SECRET"), *insecureNodes)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
b.cluster = configured
|
|
go configured.monitor(ctx)
|
|
}
|
|
server := &http.Server{Addr: *listen, Handler: b.handler(), ReadHeaderTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 * 1024}
|
|
go func() {
|
|
<-ctx.Done()
|
|
b.mu.Lock()
|
|
for _, m := range b.managers {
|
|
m.cancel()
|
|
if m.ws != nil {
|
|
m.ws.CloseNow()
|
|
}
|
|
}
|
|
for _, a := range b.agents {
|
|
if a.ws != nil {
|
|
a.ws.CloseNow()
|
|
}
|
|
}
|
|
for _, l := range b.leases {
|
|
if l.ws != nil {
|
|
l.ws.CloseNow()
|
|
}
|
|
}
|
|
for _, s := range b.sessions {
|
|
s.cancel()
|
|
}
|
|
b.mu.Unlock()
|
|
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
server.Shutdown(shutdownCtx)
|
|
}()
|
|
log.Printf("ADS relay listening on %s", *listen)
|
|
var err error
|
|
if *cert != "" {
|
|
err = server.ListenAndServeTLS(*cert, *key)
|
|
} else {
|
|
err = server.ListenAndServe()
|
|
}
|
|
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
log.Fatal(fmt.Errorf("server: %w", err))
|
|
}
|
|
}
|