Files

285 lines
7.7 KiB
Go

package main
import (
"context"
"encoding/json"
"github.com/coder/websocket"
"io"
"net/http"
"sort"
"strings"
"time"
)
type managedDevice struct {
ID string `json:"id"`
Target *string `json:"target,omitempty"`
ADBSerial *string `json:"adb_serial,omitempty"`
ADBServer *string `json:"adb_server,omitempty"`
DevicePort uint16 `json:"device_port"`
Enabled bool `json:"enabled"`
Connected bool `json:"connected"`
LastError *string `json:"last_error"`
}
type managedStatus struct {
ID string `json:"id"`
Name string `json:"name"`
Hostname string `json:"hostname"`
OS string `json:"os"`
Arch string `json:"arch"`
Version string `json:"version"`
PID uint32 `json:"pid"`
Uptime uint64 `json:"uptime_seconds"`
Supervised bool `json:"supervised"`
Revision uint64 `json:"revision"`
Instance string `json:"instance"`
Devices []managedDevice `json:"devices"`
}
type manager struct {
id string
ws *websocket.Conn
status managedStatus
lastSeen int64
ctx context.Context
cancel context.CancelFunc
pending map[string]chan json.RawMessage
}
func (b *broker) managementAuth(handler http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if len(b.adminToken) < 32 {
http.Error(w, "management admin token is not configured", 503)
return
}
b.auth(b.adminToken, handler)(w, r)
}
}
func (b *broker) redactManagement(data []byte) []byte {
text := string(data)
for _, secret := range []string{b.agentToken, b.clientToken, b.adminToken} {
if secret != "" {
text = strings.ReplaceAll(text, secret, "[REDACTED]")
}
}
return []byte(text)
}
func (b *broker) managerRegister(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("agent")
if !validID(id) {
http.Error(w, "invalid agent ID", 400)
return
}
b.mu.Lock()
if old := b.managers[id]; old != nil && old.ctx.Err() == nil {
b.mu.Unlock()
http.Error(w, "agent already registered", 409)
return
}
if b.managers[id] == nil && len(b.managers) >= 128 {
b.mu.Unlock()
http.Error(w, "agent registry full", 429)
return
}
ctx, cancel := context.WithCancel(b.ctx)
m := &manager{id: id, ctx: ctx, cancel: cancel, pending: map[string]chan json.RawMessage{}, status: managedStatus{ID: id, Devices: []managedDevice{}}, lastSeen: time.Now().Unix()}
b.managers[id] = m
b.mu.Unlock()
defer func() { cancel(); b.mu.Lock(); m.ws = nil; b.mu.Unlock() }()
ws, err := accept(w, r)
if err != nil {
return
}
defer ws.CloseNow()
b.mu.Lock()
m.ws = ws
b.mu.Unlock()
if writeJSON(ctx, ws, map[string]string{"type": "registered", "agent": id}) != nil {
return
}
go func() {
ticker := time.NewTicker(20 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
deadline, stop := context.WithTimeout(ctx, 10*time.Second)
err := ws.Ping(deadline)
stop()
if err != nil {
cancel()
return
}
}
}
}()
for {
typ, data, err := ws.Read(ctx)
if err != nil || typ != websocket.MessageText {
return
}
var message struct {
Type string `json:"type"`
RequestID string `json:"request_id"`
Status managedStatus `json:"status"`
Response json.RawMessage `json:"response"`
}
if json.Unmarshal(b.redactManagement(data), &message) != nil {
return
}
switch message.Type {
case "status":
s := message.Status
if s.ID != id || len(s.Name) > 128 || len(s.Hostname) > 256 || len(s.OS) > 64 || len(s.Arch) > 64 || len(s.Version) > 64 || len(s.Instance) > 128 || len(s.Devices) > 128 {
return
}
for _, d := range s.Devices {
if !validID(d.ID) || (d.Target != nil && len(*d.Target) > 256) || (d.ADBSerial != nil && len(*d.ADBSerial) > 256) || (d.LastError != nil && len(*d.LastError) > 2048) {
return
}
}
if s.Devices == nil {
s.Devices = []managedDevice{}
}
b.mu.Lock()
m.status = s
m.lastSeen = time.Now().Unix()
b.mu.Unlock()
case "result":
if len(message.Response) == 0 {
return
}
var check struct {
OK bool `json:"ok"`
}
if json.Unmarshal(message.Response, &check) != nil {
return
}
b.mu.Lock()
ch := m.pending[message.RequestID]
b.mu.Unlock()
if ch != nil {
select {
case ch <- message.Response:
default:
}
}
default:
return
}
}
}
func isWebSocket(r *http.Request) bool {
return strings.EqualFold(r.Header.Get("Upgrade"), "websocket")
}
func (b *broker) managersEndpoint(w http.ResponseWriter, r *http.Request) {
type record struct {
ID string `json:"id"`
Online bool `json:"online"`
LastSeen int64 `json:"last_seen"`
Status managedStatus `json:"status"`
}
b.mu.Lock()
records := []record{}
for _, m := range b.managers {
records = append(records, record{m.id, m.ws != nil, m.lastSeen, m.status})
}
b.mu.Unlock()
sort.Slice(records, func(i, j int) bool { return records[i].ID < records[j].ID })
if isWebSocket(r) {
ws, err := accept(w, r)
if err != nil {
return
}
defer ws.CloseNow()
writeJSON(r.Context(), ws, records)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(records)
}
func validManagementRequest(raw []byte) bool {
var request struct {
Op string `json:"op"`
}
if json.Unmarshal(raw, &request) != nil {
return false
}
switch request.Op {
case "status", "devices_list", "devices_discover", "device_add", "device_remove", "device_enable", "config_get", "config_set", "logs", "restart":
return true
}
return false
}
func (b *broker) managerRPC(ctx context.Context, id string, request json.RawMessage) json.RawMessage {
failure := func(reason string) json.RawMessage {
data, _ := json.Marshal(map[string]any{"ok": false, "error": reason})
return data
}
if !validID(id) || !validManagementRequest(request) {
return failure("invalid management request")
}
b.mu.Lock()
m := b.managers[id]
if m == nil || m.ws == nil {
b.mu.Unlock()
return failure("agent is offline")
}
if len(m.pending) >= 16 {
b.mu.Unlock()
return failure("agent management request limit reached")
}
requestID := newID()
response := make(chan json.RawMessage, 1)
m.pending[requestID] = response
ws := m.ws
b.mu.Unlock()
defer func() { b.mu.Lock(); delete(m.pending, requestID); b.mu.Unlock() }()
deadline, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
if writeJSON(deadline, ws, map[string]any{"type": "request", "request_id": requestID, "request": request}) != nil {
return failure("cannot reach agent")
}
select {
case data := <-response:
return data
case <-m.ctx.Done():
return failure("agent disconnected")
case <-deadline.Done():
return failure("agent management request timed out")
}
}
func (b *broker) managerRPCEndpoint(w http.ResponseWriter, r *http.Request) {
var request []byte
if isWebSocket(r) {
ws, err := accept(w, r)
if err != nil {
return
}
defer ws.CloseNow()
deadline, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
typ, data, err := ws.Read(deadline)
if err != nil || typ != websocket.MessageText || len(data) > 64*1024 {
return
}
response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), data)
writeJSON(r.Context(), ws, json.RawMessage(response))
return
}
if r.Method != "POST" {
http.Error(w, "POST required", 405)
return
}
var err error
request, err = io.ReadAll(http.MaxBytesReader(w, r.Body, 64*1024))
if err != nil {
http.Error(w, "request too large", 413)
return
}
response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), request)
w.Header().Set("Content-Type", "application/json")
w.Write(response)
}