toki
92042bb2a3
- Refactor edge node registry and store for improved management - Update opsconsole console, events, and status components - Enhance edge service and transport layers - Improve CLI persistent adapter and output filter - Update e2e smoke test script - Update project and testing domain rules - Update Makefile and documentation
136 lines
2.6 KiB
Go
136 lines
2.6 KiB
Go
package node
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
|
|
toki "git.toki-labs.com/toki/common-proto-socket/go"
|
|
)
|
|
|
|
// NodeEntry represents one connected node.
|
|
type NodeEntry struct {
|
|
NodeID string
|
|
Alias string
|
|
Client *toki.TcpClient
|
|
Index int
|
|
HasIndex bool
|
|
}
|
|
|
|
// Registry manages all nodes connected to edge.
|
|
type Registry struct {
|
|
mu sync.RWMutex
|
|
byID map[string]*NodeEntry
|
|
byAlias map[string]*NodeEntry
|
|
indexByID map[string]int
|
|
nextIndex int
|
|
}
|
|
|
|
func NewRegistry() *Registry {
|
|
return &Registry{
|
|
byID: make(map[string]*NodeEntry),
|
|
byAlias: make(map[string]*NodeEntry),
|
|
indexByID: make(map[string]int),
|
|
}
|
|
}
|
|
|
|
func (r *Registry) Register(entry *NodeEntry) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if idx, ok := r.indexByID[entry.NodeID]; ok {
|
|
entry.Index = idx
|
|
entry.HasIndex = true
|
|
} else {
|
|
if !entry.HasIndex {
|
|
entry.Index = r.nextIndex
|
|
}
|
|
entry.HasIndex = true
|
|
r.indexByID[entry.NodeID] = entry.Index
|
|
if entry.Index >= r.nextIndex {
|
|
r.nextIndex = entry.Index + 1
|
|
}
|
|
}
|
|
r.byID[entry.NodeID] = entry
|
|
if entry.Alias != "" {
|
|
r.byAlias[entry.Alias] = entry
|
|
}
|
|
}
|
|
|
|
func (e *NodeEntry) DisplayLabel() string {
|
|
if e == nil {
|
|
return "unknown"
|
|
}
|
|
if e.HasIndex {
|
|
return fmt.Sprintf("node%d", e.Index)
|
|
}
|
|
if e.Alias != "" {
|
|
return e.Alias
|
|
}
|
|
if e.NodeID != "" {
|
|
return e.NodeID
|
|
}
|
|
return "unknown"
|
|
}
|
|
|
|
func (r *Registry) Unregister(nodeID string) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if entry, ok := r.byID[nodeID]; ok {
|
|
if entry.Alias != "" {
|
|
delete(r.byAlias, entry.Alias)
|
|
}
|
|
delete(r.byID, nodeID)
|
|
}
|
|
}
|
|
|
|
func (r *Registry) Get(nodeID string) (*NodeEntry, bool) {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
e, ok := r.byID[nodeID]
|
|
return e, ok
|
|
}
|
|
|
|
func (r *Registry) Resolve(ref string) (*NodeEntry, error) {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
if ref != "" {
|
|
if entry, ok := r.byID[ref]; ok {
|
|
return entry, nil
|
|
}
|
|
if entry, ok := r.byAlias[ref]; ok {
|
|
return entry, nil
|
|
}
|
|
return nil, fmt.Errorf("node %q not found", ref)
|
|
}
|
|
|
|
if len(r.byID) == 1 {
|
|
for _, entry := range r.byID {
|
|
return entry, nil
|
|
}
|
|
}
|
|
if len(r.byID) == 0 {
|
|
return nil, fmt.Errorf("no nodes connected")
|
|
}
|
|
return nil, fmt.Errorf("multiple nodes connected; select one with /node <id|alias>")
|
|
}
|
|
|
|
func (r *Registry) All() []*NodeEntry {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
out := make([]*NodeEntry, 0, len(r.byID))
|
|
for _, e := range r.byID {
|
|
out = append(out, e)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (r *Registry) Count() int {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
return len(r.byID)
|
|
}
|
|
|
|
// Pick is deprecated: use Resolve("") instead for single-node fallback, or Resolve(ref) for explicit selection.
|
|
func (r *Registry) Pick() (*NodeEntry, error) {
|
|
return r.Resolve("")
|
|
}
|