2022-09-01 01:09:44 +00:00
|
|
|
package tailnet
|
|
|
|
|
|
|
|
import (
|
2022-10-17 23:36:23 +00:00
|
|
|
"context"
|
2022-09-01 01:09:44 +00:00
|
|
|
"encoding/json"
|
|
|
|
"errors"
|
2023-01-25 21:27:36 +00:00
|
|
|
"fmt"
|
2022-09-01 01:09:44 +00:00
|
|
|
"io"
|
|
|
|
"net"
|
2023-01-25 21:27:36 +00:00
|
|
|
"net/http"
|
2022-09-01 01:09:44 +00:00
|
|
|
"net/netip"
|
|
|
|
"sync"
|
2023-01-25 21:27:36 +00:00
|
|
|
"sync/atomic"
|
2022-10-17 13:43:30 +00:00
|
|
|
"time"
|
2022-09-01 01:09:44 +00:00
|
|
|
|
|
|
|
"github.com/google/uuid"
|
2023-01-26 03:23:14 +00:00
|
|
|
lru "github.com/hashicorp/golang-lru/v2"
|
2023-01-26 00:29:51 +00:00
|
|
|
"golang.org/x/exp/slices"
|
2022-09-01 01:09:44 +00:00
|
|
|
"golang.org/x/xerrors"
|
|
|
|
"tailscale.com/tailcfg"
|
|
|
|
"tailscale.com/types/key"
|
|
|
|
)
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
// Coordinator exchanges nodes with agents to establish connections.
|
|
|
|
// ┌──────────────────┐ ┌────────────────────┐ ┌───────────────────┐ ┌──────────────────┐
|
|
|
|
// │tailnet.Coordinate├──►│tailnet.AcceptClient│◄─►│tailnet.AcceptAgent│◄──┤tailnet.Coordinate│
|
|
|
|
// └──────────────────┘ └────────────────────┘ └───────────────────┘ └──────────────────┘
|
|
|
|
// Coordinators have different guarantees for HA support.
|
|
|
|
type Coordinator interface {
|
2023-01-25 21:27:36 +00:00
|
|
|
// ServeHTTPDebug serves a debug webpage that shows the internal state of
|
|
|
|
// the coordinator.
|
|
|
|
ServeHTTPDebug(w http.ResponseWriter, r *http.Request)
|
2022-10-17 13:43:30 +00:00
|
|
|
// Node returns an in-memory node by ID.
|
|
|
|
Node(id uuid.UUID) *Node
|
|
|
|
// ServeClient accepts a WebSocket connection that wants to connect to an agent
|
|
|
|
// with the specified ID.
|
|
|
|
ServeClient(conn net.Conn, id uuid.UUID, agent uuid.UUID) error
|
|
|
|
// ServeAgent accepts a WebSocket connection to an agent that listens to
|
|
|
|
// incoming connections and publishes node updates.
|
2023-01-25 21:27:36 +00:00
|
|
|
// Name is just used for debug information. It can be left blank.
|
|
|
|
ServeAgent(conn net.Conn, id uuid.UUID, name string) error
|
2022-10-17 13:43:30 +00:00
|
|
|
// Close closes the coordinator.
|
|
|
|
Close() error
|
|
|
|
}
|
|
|
|
|
2022-09-01 01:09:44 +00:00
|
|
|
// Node represents a node in the network.
|
|
|
|
type Node struct {
|
2022-09-28 16:04:10 +00:00
|
|
|
// ID is used to identify the connection.
|
|
|
|
ID tailcfg.NodeID `json:"id"`
|
2022-10-17 13:43:30 +00:00
|
|
|
// AsOf is the time the node was created.
|
|
|
|
AsOf time.Time `json:"as_of"`
|
2022-09-28 16:04:10 +00:00
|
|
|
// Key is the Wireguard public key of the node.
|
|
|
|
Key key.NodePublic `json:"key"`
|
|
|
|
// DiscoKey is used for discovery messages over DERP to establish peer-to-peer connections.
|
|
|
|
DiscoKey key.DiscoPublic `json:"disco"`
|
|
|
|
// PreferredDERP is the DERP server that peered connections
|
|
|
|
// should meet at to establish.
|
|
|
|
PreferredDERP int `json:"preferred_derp"`
|
|
|
|
// DERPLatency is the latency in seconds to each DERP server.
|
|
|
|
DERPLatency map[string]float64 `json:"derp_latency"`
|
|
|
|
// Addresses are the IP address ranges this connection exposes.
|
|
|
|
Addresses []netip.Prefix `json:"addresses"`
|
|
|
|
// AllowedIPs specify what addresses can dial the connection.
|
|
|
|
// We allow all by default.
|
|
|
|
AllowedIPs []netip.Prefix `json:"allowed_ips"`
|
|
|
|
// Endpoints are ip:port combinations that can be used to establish
|
|
|
|
// peer-to-peer connections.
|
|
|
|
Endpoints []string `json:"endpoints"`
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ServeCoordinator matches the RW structure of a coordinator to exchange node messages.
|
|
|
|
func ServeCoordinator(conn net.Conn, updateNodes func(node []*Node) error) (func(node *Node), <-chan error) {
|
2022-09-01 16:41:47 +00:00
|
|
|
errChan := make(chan error, 1)
|
|
|
|
sendErr := func(err error) {
|
|
|
|
select {
|
|
|
|
case errChan <- err:
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
2022-09-01 01:09:44 +00:00
|
|
|
go func() {
|
|
|
|
decoder := json.NewDecoder(conn)
|
|
|
|
for {
|
|
|
|
var nodes []*Node
|
|
|
|
err := decoder.Decode(&nodes)
|
|
|
|
if err != nil {
|
2022-09-01 16:41:47 +00:00
|
|
|
sendErr(xerrors.Errorf("read: %w", err))
|
2022-09-01 01:09:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
err = updateNodes(nodes)
|
|
|
|
if err != nil {
|
2022-09-01 16:41:47 +00:00
|
|
|
sendErr(xerrors.Errorf("update nodes: %w", err))
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
return func(node *Node) {
|
|
|
|
data, err := json.Marshal(node)
|
|
|
|
if err != nil {
|
2022-09-01 16:41:47 +00:00
|
|
|
sendErr(xerrors.Errorf("marshal node: %w", err))
|
2022-09-01 01:09:44 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
_, err = conn.Write(data)
|
|
|
|
if err != nil {
|
2022-09-01 16:41:47 +00:00
|
|
|
sendErr(xerrors.Errorf("write: %w", err))
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
}, errChan
|
|
|
|
}
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
// NewCoordinator constructs a new in-memory connection coordinator. This
|
|
|
|
// coordinator is incompatible with multiple Coder replicas as all node data is
|
|
|
|
// in-memory.
|
|
|
|
func NewCoordinator() Coordinator {
|
2023-01-26 22:32:38 +00:00
|
|
|
nameCache, err := lru.New[uuid.UUID, string](512)
|
2023-01-26 03:23:14 +00:00
|
|
|
if err != nil {
|
|
|
|
panic("make lru cache: " + err.Error())
|
|
|
|
}
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
return &coordinator{
|
|
|
|
closed: false,
|
2022-09-01 01:09:44 +00:00
|
|
|
nodes: map[uuid.UUID]*Node{},
|
2023-01-26 22:32:38 +00:00
|
|
|
agentSockets: map[uuid.UUID]*TrackedConn{},
|
|
|
|
agentToConnectionSockets: map[uuid.UUID]map[uuid.UUID]*TrackedConn{},
|
|
|
|
agentNameCache: nameCache,
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
// coordinator exchanges nodes with agents to establish connections entirely in-memory.
|
|
|
|
// The Enterprise implementation provides this for high-availability.
|
2022-09-01 01:09:44 +00:00
|
|
|
// ┌──────────────────┐ ┌────────────────────┐ ┌───────────────────┐ ┌──────────────────┐
|
|
|
|
// │tailnet.Coordinate├──►│tailnet.AcceptClient│◄─►│tailnet.AcceptAgent│◄──┤tailnet.Coordinate│
|
|
|
|
// └──────────────────┘ └────────────────────┘ └───────────────────┘ └──────────────────┘
|
|
|
|
// This coordinator is incompatible with multiple Coder
|
|
|
|
// replicas as all node data is in-memory.
|
2022-10-17 13:43:30 +00:00
|
|
|
type coordinator struct {
|
2023-01-25 21:27:36 +00:00
|
|
|
mutex sync.RWMutex
|
2022-10-17 13:43:30 +00:00
|
|
|
closed bool
|
2022-09-01 01:09:44 +00:00
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
// nodes maps agent and connection IDs their respective node.
|
2022-09-01 01:09:44 +00:00
|
|
|
nodes map[uuid.UUID]*Node
|
2022-10-17 13:43:30 +00:00
|
|
|
// agentSockets maps agent IDs to their open websocket.
|
2023-01-26 22:32:38 +00:00
|
|
|
agentSockets map[uuid.UUID]*TrackedConn
|
2022-10-17 13:43:30 +00:00
|
|
|
// agentToConnectionSockets maps agent IDs to connection IDs of conns that
|
|
|
|
// are subscribed to updates for that agent.
|
2023-01-26 22:32:38 +00:00
|
|
|
agentToConnectionSockets map[uuid.UUID]map[uuid.UUID]*TrackedConn
|
2023-01-26 03:23:14 +00:00
|
|
|
|
|
|
|
// agentNameCache holds a cache of agent names. If one of them disappears,
|
|
|
|
// it's helpful to have a name cached for debugging.
|
|
|
|
agentNameCache *lru.Cache[uuid.UUID, string]
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
type TrackedConn struct {
|
2023-01-25 21:27:36 +00:00
|
|
|
net.Conn
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
// ID is an ephemeral UUID used to uniquely identify the owner of the
|
2023-01-23 23:22:34 +00:00
|
|
|
// connection.
|
2023-01-26 22:32:38 +00:00
|
|
|
ID uuid.UUID
|
2023-01-25 21:27:36 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
Name string
|
|
|
|
Start int64
|
|
|
|
LastWrite int64
|
|
|
|
Overwrites int64
|
2023-01-25 21:27:36 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
func (t *TrackedConn) Write(b []byte) (n int, err error) {
|
|
|
|
atomic.StoreInt64(&t.LastWrite, time.Now().Unix())
|
2023-01-25 21:27:36 +00:00
|
|
|
return t.Conn.Write(b)
|
2023-01-23 23:22:34 +00:00
|
|
|
}
|
|
|
|
|
2022-09-01 01:09:44 +00:00
|
|
|
// Node returns an in-memory node by ID.
|
2022-10-17 13:43:30 +00:00
|
|
|
// If the node does not exist, nil is returned.
|
|
|
|
func (c *coordinator) Node(id uuid.UUID) *Node {
|
2022-09-01 01:09:44 +00:00
|
|
|
c.mutex.Lock()
|
|
|
|
defer c.mutex.Unlock()
|
2022-10-17 13:43:30 +00:00
|
|
|
return c.nodes[id]
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 23:22:34 +00:00
|
|
|
func (c *coordinator) NodeCount() int {
|
|
|
|
c.mutex.Lock()
|
|
|
|
defer c.mutex.Unlock()
|
|
|
|
return len(c.nodes)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *coordinator) AgentCount() int {
|
|
|
|
c.mutex.Lock()
|
|
|
|
defer c.mutex.Unlock()
|
|
|
|
return len(c.agentSockets)
|
|
|
|
}
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
// ServeClient accepts a WebSocket connection that wants to connect to an agent
|
|
|
|
// with the specified ID.
|
|
|
|
func (c *coordinator) ServeClient(conn net.Conn, id uuid.UUID, agent uuid.UUID) error {
|
2022-09-01 01:09:44 +00:00
|
|
|
c.mutex.Lock()
|
2022-10-17 13:43:30 +00:00
|
|
|
if c.closed {
|
|
|
|
c.mutex.Unlock()
|
|
|
|
return xerrors.New("coordinator is closed")
|
|
|
|
}
|
|
|
|
|
2022-09-01 01:09:44 +00:00
|
|
|
// When a new connection is requested, we update it with the latest
|
|
|
|
// node of the agent. This allows the connection to establish.
|
|
|
|
node, ok := c.nodes[agent]
|
2022-10-17 13:43:30 +00:00
|
|
|
c.mutex.Unlock()
|
2022-09-01 01:09:44 +00:00
|
|
|
if ok {
|
|
|
|
data, err := json.Marshal([]*Node{node})
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("marshal node: %w", err)
|
|
|
|
}
|
|
|
|
_, err = conn.Write(data)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("write nodes: %w", err)
|
|
|
|
}
|
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
c.mutex.Lock()
|
2022-09-01 01:09:44 +00:00
|
|
|
connectionSockets, ok := c.agentToConnectionSockets[agent]
|
|
|
|
if !ok {
|
2023-01-26 22:32:38 +00:00
|
|
|
connectionSockets = map[uuid.UUID]*TrackedConn{}
|
2022-09-01 01:09:44 +00:00
|
|
|
c.agentToConnectionSockets[agent] = connectionSockets
|
|
|
|
}
|
2023-01-25 21:27:36 +00:00
|
|
|
|
|
|
|
now := time.Now().Unix()
|
2022-09-01 01:09:44 +00:00
|
|
|
// Insert this connection into a map so the agent
|
|
|
|
// can publish node updates.
|
2023-01-26 22:32:38 +00:00
|
|
|
connectionSockets[id] = &TrackedConn{
|
2023-01-25 21:27:36 +00:00
|
|
|
Conn: conn,
|
2023-01-26 22:32:38 +00:00
|
|
|
Start: now,
|
|
|
|
LastWrite: now,
|
2023-01-25 21:27:36 +00:00
|
|
|
}
|
2022-09-01 01:09:44 +00:00
|
|
|
c.mutex.Unlock()
|
|
|
|
defer func() {
|
|
|
|
c.mutex.Lock()
|
|
|
|
defer c.mutex.Unlock()
|
|
|
|
// Clean all traces of this connection from the map.
|
|
|
|
delete(c.nodes, id)
|
|
|
|
connectionSockets, ok := c.agentToConnectionSockets[agent]
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
delete(connectionSockets, id)
|
|
|
|
if len(connectionSockets) != 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
delete(c.agentToConnectionSockets, agent)
|
|
|
|
}()
|
|
|
|
|
|
|
|
decoder := json.NewDecoder(conn)
|
|
|
|
for {
|
2022-10-17 13:43:30 +00:00
|
|
|
err := c.handleNextClientMessage(id, agent, decoder)
|
2022-09-01 01:09:44 +00:00
|
|
|
if err != nil {
|
2022-10-17 13:43:30 +00:00
|
|
|
if errors.Is(err, io.EOF) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return xerrors.Errorf("handle next client message: %w", err)
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *coordinator) handleNextClientMessage(id, agent uuid.UUID, decoder *json.Decoder) error {
|
|
|
|
var node Node
|
|
|
|
err := decoder.Decode(&node)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("read json: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
c.mutex.Lock()
|
|
|
|
// Update the node of this client in our in-memory map. If an agent entirely
|
|
|
|
// shuts down and reconnects, it needs to be aware of all clients attempting
|
|
|
|
// to establish connections.
|
|
|
|
c.nodes[id] = &node
|
|
|
|
|
|
|
|
agentSocket, ok := c.agentSockets[agent]
|
|
|
|
if !ok {
|
2022-09-26 15:16:04 +00:00
|
|
|
c.mutex.Unlock()
|
2022-10-17 13:43:30 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
c.mutex.Unlock()
|
|
|
|
|
|
|
|
// Write the new node from this client to the actively connected agent.
|
|
|
|
data, err := json.Marshal([]*Node{&node})
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("marshal nodes: %w", err)
|
|
|
|
}
|
|
|
|
|
2023-01-25 21:27:36 +00:00
|
|
|
_, err = agentSocket.Write(data)
|
2022-10-17 13:43:30 +00:00
|
|
|
if err != nil {
|
2023-01-23 23:22:34 +00:00
|
|
|
if errors.Is(err, io.EOF) || errors.Is(err, io.ErrClosedPipe) || errors.Is(err, context.Canceled) {
|
2022-09-01 01:09:44 +00:00
|
|
|
return nil
|
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
return xerrors.Errorf("write json: %w", err)
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
|
|
|
|
return nil
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ServeAgent accepts a WebSocket connection to an agent that
|
|
|
|
// listens to incoming connections and publishes node updates.
|
2023-01-25 21:27:36 +00:00
|
|
|
func (c *coordinator) ServeAgent(conn net.Conn, id uuid.UUID, name string) error {
|
2022-09-01 01:09:44 +00:00
|
|
|
c.mutex.Lock()
|
2022-10-17 13:43:30 +00:00
|
|
|
if c.closed {
|
|
|
|
c.mutex.Unlock()
|
|
|
|
return xerrors.New("coordinator is closed")
|
|
|
|
}
|
|
|
|
|
2023-01-26 03:23:14 +00:00
|
|
|
c.agentNameCache.Add(id, name)
|
|
|
|
|
2022-09-01 01:09:44 +00:00
|
|
|
sockets, ok := c.agentToConnectionSockets[id]
|
|
|
|
if ok {
|
|
|
|
// Publish all nodes that want to connect to the
|
|
|
|
// desired agent ID.
|
|
|
|
nodes := make([]*Node, 0, len(sockets))
|
|
|
|
for targetID := range sockets {
|
|
|
|
node, ok := c.nodes[targetID]
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
nodes = append(nodes, node)
|
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
c.mutex.Unlock()
|
2022-09-01 01:09:44 +00:00
|
|
|
data, err := json.Marshal(nodes)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("marshal json: %w", err)
|
|
|
|
}
|
|
|
|
_, err = conn.Write(data)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("write nodes: %w", err)
|
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
c.mutex.Lock()
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 23:22:34 +00:00
|
|
|
// This uniquely identifies a connection that belongs to this goroutine.
|
|
|
|
unique := uuid.New()
|
2023-01-25 21:27:36 +00:00
|
|
|
now := time.Now().Unix()
|
|
|
|
overwrites := int64(0)
|
2023-01-23 23:22:34 +00:00
|
|
|
|
|
|
|
// If an old agent socket is connected, we close it to avoid any leaks. This
|
|
|
|
// shouldn't ever occur because we expect one agent to be running, but it's
|
|
|
|
// possible for a race condition to happen when an agent is disconnected and
|
|
|
|
// attempts to reconnect before the server realizes the old connection is
|
|
|
|
// dead.
|
2022-09-01 01:09:44 +00:00
|
|
|
oldAgentSocket, ok := c.agentSockets[id]
|
|
|
|
if ok {
|
2023-01-26 22:32:38 +00:00
|
|
|
overwrites = oldAgentSocket.Overwrites + 1
|
2023-01-25 21:27:36 +00:00
|
|
|
_ = oldAgentSocket.Close()
|
2023-01-23 23:22:34 +00:00
|
|
|
}
|
2023-01-26 22:32:38 +00:00
|
|
|
c.agentSockets[id] = &TrackedConn{
|
|
|
|
ID: unique,
|
2023-01-25 21:27:36 +00:00
|
|
|
Conn: conn,
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
Name: name,
|
|
|
|
Start: now,
|
|
|
|
LastWrite: now,
|
|
|
|
Overwrites: overwrites,
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
2023-01-23 23:22:34 +00:00
|
|
|
|
2022-09-01 01:09:44 +00:00
|
|
|
c.mutex.Unlock()
|
|
|
|
defer func() {
|
|
|
|
c.mutex.Lock()
|
|
|
|
defer c.mutex.Unlock()
|
2023-01-23 23:22:34 +00:00
|
|
|
|
|
|
|
// Only delete the connection if it's ours. It could have been
|
|
|
|
// overwritten.
|
2023-01-26 22:32:38 +00:00
|
|
|
if idConn, ok := c.agentSockets[id]; ok && idConn.ID == unique {
|
2023-01-23 23:22:34 +00:00
|
|
|
delete(c.agentSockets, id)
|
|
|
|
delete(c.nodes, id)
|
|
|
|
}
|
2022-09-01 01:09:44 +00:00
|
|
|
}()
|
|
|
|
|
|
|
|
decoder := json.NewDecoder(conn)
|
|
|
|
for {
|
2022-10-17 13:43:30 +00:00
|
|
|
err := c.handleNextAgentMessage(id, decoder)
|
2022-09-01 01:09:44 +00:00
|
|
|
if err != nil {
|
2023-01-23 23:22:34 +00:00
|
|
|
if errors.Is(err, io.EOF) || errors.Is(err, io.ErrClosedPipe) || errors.Is(err, context.Canceled) {
|
2022-10-17 13:43:30 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return xerrors.Errorf("handle next agent message: %w", err)
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *coordinator) handleNextAgentMessage(id uuid.UUID, decoder *json.Decoder) error {
|
|
|
|
var node Node
|
|
|
|
err := decoder.Decode(&node)
|
|
|
|
if err != nil {
|
|
|
|
return xerrors.Errorf("read json: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
c.mutex.Lock()
|
|
|
|
c.nodes[id] = &node
|
|
|
|
connectionSockets, ok := c.agentToConnectionSockets[id]
|
|
|
|
if !ok {
|
|
|
|
c.mutex.Unlock()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
data, err := json.Marshal([]*Node{&node})
|
|
|
|
if err != nil {
|
2022-10-17 20:46:19 +00:00
|
|
|
c.mutex.Unlock()
|
2022-10-17 13:43:30 +00:00
|
|
|
return xerrors.Errorf("marshal nodes: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Publish the new node to every listening socket.
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
wg.Add(len(connectionSockets))
|
|
|
|
for _, connectionSocket := range connectionSockets {
|
|
|
|
connectionSocket := connectionSocket
|
|
|
|
go func() {
|
|
|
|
_ = connectionSocket.SetWriteDeadline(time.Now().Add(5 * time.Second))
|
|
|
|
_, _ = connectionSocket.Write(data)
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
c.mutex.Unlock()
|
|
|
|
wg.Wait()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close closes all of the open connections in the coordinator and stops the
|
|
|
|
// coordinator from accepting new connections.
|
|
|
|
func (c *coordinator) Close() error {
|
|
|
|
c.mutex.Lock()
|
|
|
|
if c.closed {
|
2022-10-17 16:47:45 +00:00
|
|
|
c.mutex.Unlock()
|
2022-10-17 13:43:30 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
c.closed = true
|
|
|
|
|
|
|
|
wg := sync.WaitGroup{}
|
|
|
|
|
|
|
|
wg.Add(len(c.agentSockets))
|
|
|
|
for _, socket := range c.agentSockets {
|
|
|
|
socket := socket
|
|
|
|
go func() {
|
2023-01-25 21:27:36 +00:00
|
|
|
_ = socket.Close()
|
2022-10-17 13:43:30 +00:00
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, connMap := range c.agentToConnectionSockets {
|
|
|
|
wg.Add(len(connMap))
|
|
|
|
for _, socket := range connMap {
|
|
|
|
socket := socket
|
2022-09-01 01:09:44 +00:00
|
|
|
go func() {
|
2022-10-17 13:43:30 +00:00
|
|
|
_ = socket.Close()
|
2022-09-01 01:09:44 +00:00
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
}
|
2022-10-17 13:43:30 +00:00
|
|
|
|
2022-10-17 16:47:45 +00:00
|
|
|
c.mutex.Unlock()
|
|
|
|
|
2022-10-17 13:43:30 +00:00
|
|
|
wg.Wait()
|
|
|
|
return nil
|
2022-09-01 01:09:44 +00:00
|
|
|
}
|
2023-01-25 21:27:36 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
func (c *coordinator) ServeHTTPDebug(w http.ResponseWriter, r *http.Request) {
|
2023-01-25 21:27:36 +00:00
|
|
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
|
|
|
|
|
|
c.mutex.RLock()
|
|
|
|
defer c.mutex.RUnlock()
|
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "<h1>in-memory wireguard coordinator debug</h1>")
|
2023-01-26 00:29:51 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
CoordinatorHTTPDebug(c.agentSockets, c.agentToConnectionSockets, c.agentNameCache)(w, r)
|
|
|
|
}
|
2023-01-26 00:29:51 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
func CoordinatorHTTPDebug(
|
|
|
|
agentSocketsMap map[uuid.UUID]*TrackedConn,
|
|
|
|
agentToConnectionSocketsMap map[uuid.UUID]map[uuid.UUID]*TrackedConn,
|
|
|
|
agentNameCache *lru.Cache[uuid.UUID, string],
|
|
|
|
) func(w http.ResponseWriter, _ *http.Request) {
|
|
|
|
return func(w http.ResponseWriter, _ *http.Request) {
|
|
|
|
now := time.Now()
|
|
|
|
|
|
|
|
type idConn struct {
|
|
|
|
id uuid.UUID
|
|
|
|
conn *TrackedConn
|
2023-01-25 21:27:36 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
{
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<h2 id=agents><a href=#agents>#</a> agents: total %d</h2>\n", len(agentSocketsMap))
|
|
|
|
_, _ = fmt.Fprintln(w, "<ul>")
|
2023-01-26 22:32:38 +00:00
|
|
|
agentSockets := make([]idConn, 0, len(agentSocketsMap))
|
2023-01-26 00:29:51 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
for id, conn := range agentSocketsMap {
|
|
|
|
agentSockets = append(agentSockets, idConn{id, conn})
|
2023-01-26 00:29:51 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
slices.SortFunc(agentSockets, func(a, b idConn) bool {
|
|
|
|
return a.conn.Name < b.conn.Name
|
|
|
|
})
|
|
|
|
|
|
|
|
for _, agent := range agentSockets {
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<li style=\"margin-top:4px\"><b>%s</b> (<code>%s</code>): created %v ago, write %v ago, overwrites %d </li>\n",
|
2023-01-26 22:32:38 +00:00
|
|
|
agent.conn.Name,
|
|
|
|
agent.id.String(),
|
|
|
|
now.Sub(time.Unix(agent.conn.Start, 0)).Round(time.Second),
|
|
|
|
now.Sub(time.Unix(agent.conn.LastWrite, 0)).Round(time.Second),
|
|
|
|
agent.conn.Overwrites,
|
|
|
|
)
|
2023-01-25 21:27:36 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
if conns := agentToConnectionSocketsMap[agent.id]; len(conns) > 0 {
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<h3 style=\"margin:0px;font-size:16px;font-weight:400\">connections: total %d</h3>\n", len(conns))
|
2023-01-26 22:32:38 +00:00
|
|
|
|
|
|
|
connSockets := make([]idConn, 0, len(conns))
|
|
|
|
for id, conn := range conns {
|
|
|
|
connSockets = append(connSockets, idConn{id, conn})
|
|
|
|
}
|
|
|
|
slices.SortFunc(connSockets, func(a, b idConn) bool {
|
|
|
|
return a.id.String() < b.id.String()
|
|
|
|
})
|
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "<ul>")
|
2023-01-26 22:32:38 +00:00
|
|
|
for _, connSocket := range connSockets {
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<li><b>%s</b> (<code>%s</code>): created %v ago, write %v ago </li>\n",
|
2023-01-26 22:32:38 +00:00
|
|
|
connSocket.conn.Name,
|
|
|
|
connSocket.id.String(),
|
|
|
|
now.Sub(time.Unix(connSocket.conn.Start, 0)).Round(time.Second),
|
|
|
|
now.Sub(time.Unix(connSocket.conn.LastWrite, 0)).Round(time.Second),
|
|
|
|
)
|
|
|
|
}
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "</ul>")
|
2023-01-26 22:32:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "</ul>")
|
2023-01-26 00:29:51 +00:00
|
|
|
}
|
2023-01-25 21:27:36 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
{
|
|
|
|
type agentConns struct {
|
|
|
|
id uuid.UUID
|
|
|
|
conns []idConn
|
2023-01-26 00:29:51 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
missingAgents := []agentConns{}
|
|
|
|
for agentID, conns := range agentToConnectionSocketsMap {
|
|
|
|
if len(conns) == 0 {
|
|
|
|
continue
|
2023-01-26 00:29:51 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
if _, ok := agentSocketsMap[agentID]; !ok {
|
|
|
|
connsSlice := make([]idConn, 0, len(conns))
|
|
|
|
for id, conn := range conns {
|
|
|
|
connsSlice = append(connsSlice, idConn{id, conn})
|
|
|
|
}
|
|
|
|
slices.SortFunc(connsSlice, func(a, b idConn) bool {
|
|
|
|
return a.id.String() < b.id.String()
|
|
|
|
})
|
2023-01-26 00:29:51 +00:00
|
|
|
|
2023-01-26 22:32:38 +00:00
|
|
|
missingAgents = append(missingAgents, agentConns{agentID, connsSlice})
|
|
|
|
}
|
2023-01-26 03:23:14 +00:00
|
|
|
}
|
2023-01-26 22:32:38 +00:00
|
|
|
slices.SortFunc(missingAgents, func(a, b agentConns) bool {
|
|
|
|
return a.id.String() < b.id.String()
|
|
|
|
})
|
2023-01-26 03:23:14 +00:00
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<h2 id=missing-agents><a href=#missing-agents>#</a> missing agents: total %d</h2>\n", len(missingAgents))
|
|
|
|
_, _ = fmt.Fprintln(w, "<ul>")
|
2023-01-26 22:32:38 +00:00
|
|
|
|
|
|
|
for _, agentConns := range missingAgents {
|
|
|
|
agentName, ok := agentNameCache.Get(agentConns.id)
|
|
|
|
if !ok {
|
|
|
|
agentName = "unknown"
|
|
|
|
}
|
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<li style=\"margin-top:4px\"><b>%s</b> (<code>%s</code>): created ? ago, write ? ago, overwrites ? </li>\n",
|
2023-01-26 22:32:38 +00:00
|
|
|
agentName,
|
|
|
|
agentConns.id.String(),
|
2023-01-26 00:29:51 +00:00
|
|
|
)
|
2023-01-26 22:32:38 +00:00
|
|
|
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<h3 style=\"margin:0px;font-size:16px;font-weight:400\">connections: total %d</h3>\n", len(agentConns.conns))
|
|
|
|
_, _ = fmt.Fprintln(w, "<ul>")
|
2023-01-26 22:32:38 +00:00
|
|
|
for _, agentConn := range agentConns.conns {
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintf(w, "<li><b>%s</b> (<code>%s</code>): created %v ago, write %v ago </li>\n",
|
2023-01-26 22:32:38 +00:00
|
|
|
agentConn.conn.Name,
|
|
|
|
agentConn.id.String(),
|
|
|
|
now.Sub(time.Unix(agentConn.conn.Start, 0)).Round(time.Second),
|
|
|
|
now.Sub(time.Unix(agentConn.conn.LastWrite, 0)).Round(time.Second),
|
|
|
|
)
|
|
|
|
}
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "</ul>")
|
2023-01-26 00:29:51 +00:00
|
|
|
}
|
2023-02-02 18:36:27 +00:00
|
|
|
_, _ = fmt.Fprintln(w, "</ul>")
|
2023-01-25 21:27:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|