Every cluster, array and VM host now names what it runs on: OpenShift, OKD, Kubernetes, VMware vSphere, Nutanix, Proxmox VE, Hyper-V, KVM, Pure FlashArray, Pure FlashBlade, IBM i, IBM Power, Vault or OpenBao. It's a label on the Clusters cards, the Workloads Where column and cluster picker, a host's VM line and the network map's cluster boxes, and Workloads filters by it with a count on each platform. OpenShift's name is read from its cluster version, where the watcher puts it. The service map names vCenter, Prism Central and the HMC with their vendor (VMware vCenter, Nutanix Prism Central, IBM Power HMC).
919 lines
26 KiB
Go
919 lines
26 KiB
Go
package server
|
|
|
|
// The maps' API: one level at a time, already grouped, so a view never
|
|
// sends more than mapMaxBoxes boxes (docs/maps.md, Drawing it at scale).
|
|
//
|
|
// GET /api/v1/map/network sites, clusters, remote hosts, the Internet
|
|
// GET /api/v1/map/network?focus=site:<id> a site's hosts (grouped past mapSiteCards)
|
|
// GET /api/v1/map/network?focus=group:<id> one group of a site's hosts
|
|
// GET /api/v1/map/network?focus=host:<name> a host and what it's linked to
|
|
// GET /api/v1/map/services every service (grouped past mapServiceCards)
|
|
// GET /api/v1/map/services?focus=group:<id> one group of services
|
|
// GET /api/v1/map/services?focus=svc:<id>&steps=3
|
|
// a service, what it needs and what needs it
|
|
|
|
import (
|
|
"cmp"
|
|
"fmt"
|
|
"net/http"
|
|
"regexp"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/cairnobs/cairnobs/internal/mapgraph"
|
|
)
|
|
|
|
const (
|
|
mapMaxBoxes = 300
|
|
mapMaxLines = 1000
|
|
mapSiteCards = 60 // hosts drawn one by one in a site before grouping
|
|
mapServiceCards = 150 // services drawn one by one before grouping
|
|
mapGroupSize = 50 // hosts per group when nothing else splits them
|
|
mapDetailList = 25 // parts and hosts listed in a box's detail
|
|
)
|
|
|
|
// MapBox is one box on a map.
|
|
type MapBox struct {
|
|
ID string `json:"id"`
|
|
Kind string `json:"kind"` // internet, site, cluster, host, group, service
|
|
Name string `json:"name"`
|
|
Sub string `json:"sub,omitempty"`
|
|
Status string `json:"status"` // good, warning, critical, waiting
|
|
Count int `json:"count,omitempty"`
|
|
Problems []string `json:"problems,omitempty"` // names of the members in trouble, a few
|
|
Ports []int `json:"ports,omitempty"`
|
|
Open bool `json:"open,omitempty"` // a focus exists for it
|
|
Tier string `json:"tier,omitempty"`
|
|
Layer int `json:"layer"`
|
|
Site string `json:"site,omitempty"`
|
|
Via string `json:"via,omitempty"`
|
|
Detail any `json:"detail,omitempty"`
|
|
}
|
|
|
|
// MapLine is one line between two boxes.
|
|
type MapLine struct {
|
|
A string `json:"a"`
|
|
B string `json:"b"`
|
|
Kind string `json:"kind"` // wireguard, traffic, internet, needs
|
|
Up bool `json:"up"`
|
|
Ports []int `json:"ports,omitempty"`
|
|
Count int `json:"count,omitempty"` // links or edges folded into it
|
|
Stage string `json:"stage,omitempty"` // needs: declared, seen, steady, fading
|
|
}
|
|
|
|
// MapView is one level of a map.
|
|
type MapView struct {
|
|
Built time.Time `json:"built"`
|
|
Level string `json:"level"`
|
|
Focus string `json:"focus,omitempty"`
|
|
Title string `json:"title"` // what the view shows: a site's name, a host's
|
|
Crumbs []MapBox `json:"crumbs"`
|
|
Boxes []MapBox `json:"boxes"`
|
|
Lines []MapLine `json:"lines"`
|
|
Cut bool `json:"cut,omitempty"` // more than the caps: the rest left out
|
|
Hosts int `json:"hosts"`
|
|
Mapped int `json:"mapped"` // hosts that sent a map sample
|
|
}
|
|
|
|
var statusOrder = map[string]int{"good": 0, "waiting": 1, "warning": 2, "critical": 3}
|
|
|
|
func worse(a, b string) string {
|
|
if statusOrder[b] > statusOrder[a] {
|
|
return b
|
|
}
|
|
return a
|
|
}
|
|
|
|
// fold makes a group box out of members: the worst status, the count and
|
|
// the first few members in trouble.
|
|
func fold(id, kind, name string, members []string, status map[string]string) MapBox {
|
|
b := MapBox{ID: id, Kind: kind, Name: name, Status: "good", Count: len(members), Open: true}
|
|
if len(members) == 0 {
|
|
b.Status = "waiting"
|
|
}
|
|
for _, m := range members {
|
|
s := cmp.Or(status[m], "waiting")
|
|
b.Status = worse(b.Status, s)
|
|
if (s == "critical" || s == "warning") && len(b.Problems) < 5 {
|
|
b.Problems = append(b.Problems, m)
|
|
}
|
|
}
|
|
return b
|
|
}
|
|
|
|
func (v *MapView) capped() {
|
|
if len(v.Boxes) > mapMaxBoxes {
|
|
v.Boxes, v.Cut = v.Boxes[:mapMaxBoxes], true
|
|
}
|
|
keep := map[string]bool{}
|
|
for _, b := range v.Boxes {
|
|
keep[b.ID] = true
|
|
}
|
|
v.Lines = slices.DeleteFunc(v.Lines, func(l MapLine) bool { return !keep[l.A] || !keep[l.B] })
|
|
if len(v.Lines) > mapMaxLines {
|
|
v.Lines, v.Cut = v.Lines[:mapMaxLines], true
|
|
}
|
|
if v.Lines == nil {
|
|
v.Lines = []MapLine{}
|
|
}
|
|
if v.Boxes == nil {
|
|
v.Boxes = []MapBox{}
|
|
}
|
|
if v.Crumbs == nil {
|
|
v.Crumbs = []MapBox{}
|
|
}
|
|
}
|
|
|
|
// lines folds links between members into lines between their boxes.
|
|
type lineSet struct {
|
|
m map[[3]string]*MapLine
|
|
order [][3]string
|
|
}
|
|
|
|
func newLineSet() *lineSet { return &lineSet{m: map[[3]string]*MapLine{}} }
|
|
|
|
func (s *lineSet) add(a, b, kind string, up bool, ports []int, stage string) {
|
|
if a == "" || b == "" || a == b {
|
|
return
|
|
}
|
|
if kind != "needs" && kind != "internet" && a > b {
|
|
a, b = b, a
|
|
}
|
|
k := [3]string{a, b, kind}
|
|
l := s.m[k]
|
|
if l == nil {
|
|
l = &MapLine{A: a, B: b, Kind: kind, Up: up, Stage: stage}
|
|
s.m[k] = l
|
|
s.order = append(s.order, k)
|
|
} else {
|
|
l.Up = l.Up && up
|
|
if stageRank[stage] > stageRank[l.Stage] {
|
|
l.Stage = stage
|
|
}
|
|
}
|
|
l.Count++
|
|
for _, p := range ports {
|
|
if !slices.Contains(l.Ports, p) {
|
|
l.Ports = append(l.Ports, p)
|
|
}
|
|
}
|
|
slices.Sort(l.Ports)
|
|
}
|
|
|
|
var stageRank = map[string]int{stageFading: 0, stageSeen: 1, stageSteady: 2, stageDeclared: 3}
|
|
|
|
func (s *lineSet) list() []MapLine {
|
|
out := make([]MapLine, 0, len(s.order))
|
|
for _, k := range s.order {
|
|
out = append(out, *s.m[k])
|
|
}
|
|
return out
|
|
}
|
|
|
|
// hostStatus is every host's status now.
|
|
func (srv *Server) hostStatus(now time.Time) (map[string]string, map[string]HostView) {
|
|
hosts, _ := srv.view(now)
|
|
st := make(map[string]string, len(hosts))
|
|
by := make(map[string]HostView, len(hosts))
|
|
for _, h := range hosts {
|
|
st[h.Name], by[h.Name] = h.Status, h
|
|
}
|
|
return st, by
|
|
}
|
|
|
|
func (srv *Server) handleMapNetwork(w http.ResponseWriter, r *http.Request) {
|
|
now := time.Now()
|
|
v, ok := srv.networkView(r.URL.Query().Get("focus"), now)
|
|
if !ok {
|
|
http.Error(w, "no such place on the map", http.StatusNotFound)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, v)
|
|
}
|
|
|
|
func (srv *Server) networkView(focus string, now time.Time) (*MapView, bool) {
|
|
g := srv.mapGraph(now)
|
|
status, views := srv.hostStatus(now)
|
|
v := &MapView{Built: g.Built, Focus: focus, Hosts: len(g.Hosts)}
|
|
node := map[string]mapgraph.HostNode{}
|
|
for _, n := range g.Hosts {
|
|
node[n.Name] = n
|
|
if n.Mapped {
|
|
v.Mapped++
|
|
}
|
|
}
|
|
site := map[string]mapgraph.Site{}
|
|
for _, s := range g.Sites {
|
|
site[s.ID] = s
|
|
}
|
|
hostBox := func(n mapgraph.HostNode) MapBox {
|
|
b := MapBox{ID: "host:" + n.Name, Kind: "host", Name: n.Name, Sub: n.Roles, Status: cmp.Or(status[n.Name], "waiting"),
|
|
Ports: n.Internet, Open: true, Site: n.Site, Via: n.Via}
|
|
if hv, ok := views[n.Name]; ok && b.Sub == "" {
|
|
b.Sub = hv.Word
|
|
}
|
|
return b
|
|
}
|
|
overview := MapBox{ID: "", Kind: "overview", Name: "Everything"}
|
|
ls := newLineSet()
|
|
|
|
switch kind, id, _ := strings.Cut(focus, ":"); kind {
|
|
case "":
|
|
v.Level, v.Title = "overview", "Everything"
|
|
// Where each host is drawn: its site, or itself.
|
|
where := map[string]string{}
|
|
internet := false
|
|
for _, s := range g.Sites {
|
|
b := fold(s.ID, "site", s.Name, s.Hosts, status)
|
|
b.Sub = fmt.Sprintf("%d hosts", len(s.Hosts))
|
|
if s.Mesh {
|
|
b.Sub += " · WireGuard mesh"
|
|
}
|
|
var ports []int
|
|
for _, h := range s.Hosts {
|
|
where[h] = b.ID
|
|
for _, p := range node[h].Internet {
|
|
if !slices.Contains(ports, p) {
|
|
ports = append(ports, p)
|
|
}
|
|
}
|
|
}
|
|
slices.Sort(ports)
|
|
b.Ports = ports
|
|
if len(ports) > 0 {
|
|
internet = true
|
|
ls.add("internet", b.ID, "internet", true, ports, "")
|
|
}
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
var alone []string
|
|
for _, n := range g.Hosts {
|
|
if n.Site != "" {
|
|
continue
|
|
}
|
|
if n.Via != "" {
|
|
b := hostBox(n)
|
|
where[n.Name] = b.ID
|
|
v.Boxes = append(v.Boxes, b)
|
|
} else {
|
|
alone = append(alone, n.Name)
|
|
}
|
|
if len(n.Internet) > 0 {
|
|
internet = true
|
|
}
|
|
}
|
|
if len(alone) > 0 && len(alone) <= 30 {
|
|
for _, h := range alone {
|
|
b := hostBox(node[h])
|
|
where[h] = b.ID
|
|
v.Boxes = append(v.Boxes, b)
|
|
if len(node[h].Internet) > 0 {
|
|
ls.add("internet", b.ID, "internet", true, node[h].Internet, "")
|
|
}
|
|
}
|
|
} else if len(alone) > 30 {
|
|
b := fold("group:alone", "group", "Hosts on their own", alone, status)
|
|
for _, h := range alone {
|
|
where[h] = b.ID
|
|
}
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
if internet {
|
|
v.Boxes = append([]MapBox{{ID: "internet", Kind: "internet", Name: "Internet", Status: "good"}}, v.Boxes...)
|
|
}
|
|
for _, l := range g.Links {
|
|
ls.add(where[l.A], where[l.B], l.Kind, l.Up, l.Ports, "")
|
|
}
|
|
_, conds := srv.view(now)
|
|
for _, c := range srv.clusterViews(now, conds) {
|
|
v.Boxes = append(v.Boxes, MapBox{ID: "cluster:" + c.Name, Kind: "cluster", Name: c.Name, Status: c.Status,
|
|
Sub: c.Platform + " · " + c.Summary, Count: c.Nodes})
|
|
}
|
|
|
|
case "site", "group":
|
|
hosts, title, ok := srv.siteHosts(g, kind, id)
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
v.Level, v.Title = kind, title
|
|
v.Crumbs = []MapBox{overview}
|
|
if kind == "group" {
|
|
if s, ok := site[groupSite(id)]; ok {
|
|
v.Crumbs = append(v.Crumbs, MapBox{ID: s.ID, Kind: "site", Name: s.Name})
|
|
}
|
|
}
|
|
where := map[string]string{}
|
|
if len(hosts) <= mapSiteCards || kind == "group" {
|
|
for _, h := range hosts {
|
|
b := hostBox(node[h])
|
|
where[h] = b.ID
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
} else {
|
|
for _, grp := range groupHosts(id, hosts) {
|
|
b := fold("group:"+grp.id, "group", grp.name, grp.hosts, status)
|
|
for _, h := range grp.hosts {
|
|
where[h] = b.ID
|
|
}
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
}
|
|
// Links out of the box go to where the other end is drawn on the
|
|
// overview: its site, or itself.
|
|
inside := map[string]bool{}
|
|
for _, h := range hosts {
|
|
inside[h] = true
|
|
}
|
|
elsewhere := map[string]MapBox{}
|
|
outside := func(h string) string {
|
|
n := node[h]
|
|
b := hostBox(n)
|
|
if n.Site != "" {
|
|
s := site[n.Site]
|
|
b = fold(s.ID, "site", s.Name, s.Hosts, status)
|
|
}
|
|
b.Kind = "elsewhere:" + b.Kind
|
|
elsewhere[b.ID] = b
|
|
return b.ID
|
|
}
|
|
var ports []int
|
|
for _, h := range hosts {
|
|
for _, p := range node[h].Internet {
|
|
if !slices.Contains(ports, p) {
|
|
ports = append(ports, p)
|
|
}
|
|
ls.add("internet", where[h], "internet", true, node[h].Internet, "")
|
|
}
|
|
}
|
|
if len(ports) > 0 {
|
|
v.Boxes = append([]MapBox{{ID: "internet", Kind: "internet", Name: "Internet", Status: "good"}}, v.Boxes...)
|
|
}
|
|
for _, l := range g.Links {
|
|
a, b := inside[l.A], inside[l.B]
|
|
switch {
|
|
case a && b:
|
|
ls.add(where[l.A], where[l.B], l.Kind, l.Up, l.Ports, "")
|
|
case a:
|
|
ls.add(where[l.A], outside(l.B), l.Kind, l.Up, l.Ports, "")
|
|
case b:
|
|
ls.add(outside(l.A), where[l.B], l.Kind, l.Up, l.Ports, "")
|
|
}
|
|
}
|
|
for _, b := range sortedBoxes(elsewhere) {
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
|
|
case "host":
|
|
n, ok := node[id]
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
v.Level, v.Title = "host", n.Name
|
|
v.Crumbs = []MapBox{overview}
|
|
if n.Site != "" {
|
|
s := site[n.Site]
|
|
v.Crumbs = append(v.Crumbs, MapBox{ID: s.ID, Kind: "site", Name: s.Name})
|
|
}
|
|
b := hostBox(n)
|
|
var svcs []string
|
|
for _, s := range g.Services {
|
|
for _, p := range s.Parts {
|
|
if p.Host == id {
|
|
svcs = append(svcs, s.ID)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
b.Detail = map[string]any{"addrs": n.Addrs, "outside_peers": n.Outside, "services": svcs, "mapped": n.Mapped}
|
|
v.Boxes = append(v.Boxes, b)
|
|
seen := map[string]bool{id: true}
|
|
for _, l := range g.Links {
|
|
other := ""
|
|
switch id {
|
|
case l.A:
|
|
other = l.B
|
|
case l.B:
|
|
other = l.A
|
|
default:
|
|
continue
|
|
}
|
|
if !seen[other] {
|
|
seen[other] = true
|
|
v.Boxes = append(v.Boxes, hostBox(node[other]))
|
|
}
|
|
ls.add(b.ID, "host:"+other, l.Kind, l.Up, l.Ports, "")
|
|
}
|
|
if len(n.Internet) > 0 {
|
|
v.Boxes = append([]MapBox{{ID: "internet", Kind: "internet", Name: "Internet", Status: "good"}}, v.Boxes...)
|
|
ls.add("internet", b.ID, "internet", true, n.Internet, "")
|
|
}
|
|
default:
|
|
return nil, false
|
|
}
|
|
v.Lines = ls.list()
|
|
v.capped()
|
|
return v, true
|
|
}
|
|
|
|
func sortedBoxes(m map[string]MapBox) []MapBox {
|
|
out := make([]MapBox, 0, len(m))
|
|
for _, b := range m {
|
|
out = append(out, b)
|
|
}
|
|
slices.SortFunc(out, func(a, b MapBox) int { return strings.Compare(a.ID, b.ID) })
|
|
return out
|
|
}
|
|
|
|
// A group of a site's hosts is "<site id>|<key>".
|
|
func groupSite(id string) string { s, _, _ := strings.Cut(id, "|"); return s }
|
|
|
|
func (srv *Server) siteHosts(g *mapgraph.Graph, kind, id string) ([]string, string, bool) {
|
|
if kind == "group" && id == "alone" {
|
|
var hs []string
|
|
for _, n := range g.Hosts {
|
|
if n.Site == "" && n.Via == "" {
|
|
hs = append(hs, n.Name)
|
|
}
|
|
}
|
|
return hs, "Hosts on their own", len(hs) > 0
|
|
}
|
|
for _, s := range g.Sites {
|
|
if kind == "site" && s.ID == "site:"+id {
|
|
return s.Hosts, s.Name, true
|
|
}
|
|
if kind == "group" && s.ID == groupSite(id) {
|
|
for _, grp := range groupHosts(s.ID, s.Hosts) {
|
|
if grp.id == id {
|
|
return grp.hosts, grp.name, true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil, "", false
|
|
}
|
|
|
|
type hostGroup struct {
|
|
id, name string
|
|
hosts []string
|
|
}
|
|
|
|
var trailingNumber = regexp.MustCompile(`[-_.]?\d+$`)
|
|
|
|
// groupHosts splits a big site: by name pattern (web-01 … web-40 is "web"),
|
|
// and anything still too big into runs of mapGroupSize in name order.
|
|
func groupHosts(siteID string, hosts []string) []hostGroup {
|
|
byPat := map[string][]string{}
|
|
var pats []string
|
|
for _, h := range hosts {
|
|
p := trailingNumber.ReplaceAllString(h, "")
|
|
if p == "" {
|
|
p = h
|
|
}
|
|
if byPat[p] == nil {
|
|
pats = append(pats, p)
|
|
}
|
|
byPat[p] = append(byPat[p], h)
|
|
}
|
|
slices.Sort(pats)
|
|
var out []hostGroup
|
|
for _, p := range pats {
|
|
hs := byPat[p]
|
|
slices.Sort(hs)
|
|
for i := 0; i < len(hs); i += mapGroupSize {
|
|
part := hs[i:min(i+mapGroupSize, len(hs))]
|
|
name := p
|
|
key := p
|
|
if len(hs) > mapGroupSize {
|
|
name = part[0] + " … " + part[len(part)-1]
|
|
key = p + "/" + strconv.Itoa(i/mapGroupSize)
|
|
}
|
|
out = append(out, hostGroup{id: siteID + "|" + key, name: name, hosts: part})
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (srv *Server) handleMapServices(w http.ResponseWriter, r *http.Request) {
|
|
now := time.Now()
|
|
steps, _ := strconv.Atoi(r.URL.Query().Get("steps"))
|
|
if steps <= 0 || steps > 10 {
|
|
steps = 3
|
|
}
|
|
v, ok := srv.servicesView(r.URL.Query().Get("focus"), steps, now)
|
|
if !ok {
|
|
http.Error(w, "no such service on the map", http.StatusNotFound)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, v)
|
|
}
|
|
|
|
// serviceStatus is the worst of a service's parts: a container's verdict,
|
|
// a unit's or process's host. A service with no parts is waiting.
|
|
func serviceStatus(s mapgraph.Service, hosts map[string]HostView, k8s map[string][2]string) (string, string) {
|
|
if s.Source == "outside" {
|
|
return "waiting", "Outside, not watched"
|
|
}
|
|
if len(s.Parts) == 0 {
|
|
return "waiting", "Nothing found for it yet"
|
|
}
|
|
st, word := "good", "Running"
|
|
for _, p := range s.Parts {
|
|
h, ok := hosts[p.Host]
|
|
ps, pw := cmp.Or(h.Status, "waiting"), h.Word
|
|
if strings.HasPrefix(p.Owner, "k8s:") { // a controller or VM: its record says
|
|
ps, pw = "good", "Running"
|
|
if p.Owner != "k8s:ingress" {
|
|
v, seen := k8s[mapgraph.PartKey(p.Host, p.Owner)]
|
|
ps, pw = cmp.Or(v[0], "waiting"), strings.TrimPrefix(p.Owner, "k8s:")+": "+cmp.Or(v[1], "not seen")
|
|
if !seen || ps == "off" {
|
|
ps = "waiting"
|
|
}
|
|
}
|
|
} else if !ok || h.Silent {
|
|
ps, pw = cmp.Or(h.Status, "waiting"), p.Host+": "+cmp.Or(h.Word, "no reports")
|
|
} else if name, isC := strings.CutPrefix(p.Owner, "container:"); isC {
|
|
ps, pw = "waiting", "Not seen"
|
|
for _, c := range h.rows {
|
|
if c.Name == name {
|
|
ps, pw = c.Verdict.Severity, p.Host+": "+c.Verdict.Word
|
|
if ps == "off" {
|
|
ps = "waiting"
|
|
}
|
|
break
|
|
}
|
|
}
|
|
} else if ps == "good" {
|
|
pw = "Running"
|
|
} else {
|
|
pw = p.Host + ": " + h.Word
|
|
}
|
|
if statusOrder[ps] > statusOrder[st] {
|
|
st, word = ps, pw
|
|
}
|
|
}
|
|
return st, word
|
|
}
|
|
|
|
// declaredSignals is what judges each declared service besides its parts:
|
|
// its checks and Cloudflare (topology.yaml), and the units and containers
|
|
// it claims, by service id. Those last are mostly its parts already, but a
|
|
// unit that failed stops listening and drops off the map: without them a
|
|
// service whose one copy is down read "Running" from the copies still up.
|
|
func (srv *Server) declaredSignals(now time.Time) map[string][]Signal {
|
|
svcs, ok := srv.serviceStates(now)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
out := map[string][]Signal{}
|
|
for _, sv := range svcs {
|
|
for _, sg := range sv.Signals {
|
|
switch sg.Kind {
|
|
case "check", "cloudflare", "unit", "container":
|
|
out[sv.ID] = append(out[sv.ID], sg)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// withSignals folds a declared service's checks into its parts' status. A
|
|
// service with no parts (mail judged only by its checks) takes theirs.
|
|
func withSignals(st, word string, noParts bool, sigs []Signal) (string, string) {
|
|
answered := false
|
|
for _, sg := range sigs {
|
|
if sg.Status == "waiting" || sg.Status == "off" {
|
|
continue
|
|
}
|
|
if !answered && noParts {
|
|
st, word = "good", "OK"
|
|
}
|
|
answered = true
|
|
ss := sg.Status
|
|
if ss == "serious" { // the maps colour in four
|
|
ss = "critical"
|
|
}
|
|
if statusOrder[ss] > statusOrder[st] {
|
|
st, word = ss, sg.Name+": "+sg.Word
|
|
}
|
|
}
|
|
return st, word
|
|
}
|
|
|
|
func (srv *Server) servicesView(focus string, steps int, now time.Time) (*MapView, bool) {
|
|
g := srv.mapGraph(now)
|
|
_, hosts := srv.hostStatus(now)
|
|
edges := srv.mapEdges(g, now)
|
|
v := &MapView{Built: g.Built, Focus: focus, Hosts: len(g.Hosts)}
|
|
for _, n := range g.Hosts {
|
|
if n.Mapped {
|
|
v.Mapped++
|
|
}
|
|
}
|
|
svc := map[string]mapgraph.Service{}
|
|
status := map[string]string{}
|
|
words := map[string]string{}
|
|
k8s := srv.k8sParts()
|
|
judged := srv.declaredSignals(now)
|
|
for _, s := range g.Services {
|
|
svc[s.ID] = s
|
|
st, word := serviceStatus(s, hosts, k8s)
|
|
status[s.ID], words[s.ID] = withSignals(st, word, len(s.Parts) == 0, judged[s.ID])
|
|
}
|
|
site := map[string]string{}
|
|
for _, n := range g.Hosts {
|
|
site[n.Name] = n.Site
|
|
}
|
|
siteName := map[string]string{}
|
|
for _, s := range g.Sites {
|
|
siteName[s.ID] = s.Name
|
|
}
|
|
box := func(s mapgraph.Service) MapBox {
|
|
b := MapBox{ID: "svc:" + s.ID, Kind: "service", Name: s.Name, Status: status[s.ID], Sub: words[s.ID],
|
|
Tier: s.Tier, Layer: s.Layer, Ports: s.Internet, Count: len(s.Parts), Open: true}
|
|
var hs []string
|
|
for _, p := range s.Parts {
|
|
hs = appendNew(hs, p.Host)
|
|
}
|
|
// The box says how many; the detail lists the first few. The
|
|
// service's own page (step 5) lists them all.
|
|
b.Detail = map[string]any{"source": s.Source, "kind": s.Kind, "parts": s.Parts[:min(len(s.Parts), mapDetailList)],
|
|
"hosts": hs[:min(len(hs), mapDetailList)], "host_count": len(hs), "ports": s.Ports, "outside": s.Outside, "declared": s.Declared}
|
|
return b
|
|
}
|
|
overview := MapBox{ID: "", Kind: "overview", Name: "Every service"}
|
|
ls := newLineSet()
|
|
// groupOf: where a service goes when there are too many to draw one by
|
|
// one: what was declared together, else the site its first part is in.
|
|
groupOf := func(s mapgraph.Service) (string, string) {
|
|
if c, ok := k8sCluster(s); ok {
|
|
return "group:cluster:" + c, c
|
|
}
|
|
if s.Declared || len(s.Parts) == 0 {
|
|
return "group:declared", "Declared"
|
|
}
|
|
sid := site[s.Parts[0].Host]
|
|
if sid == "" {
|
|
return "group:host:" + s.Parts[0].Host, s.Parts[0].Host
|
|
}
|
|
return "group:" + sid, cmp.Or(siteName[sid], sid)
|
|
}
|
|
|
|
switch kind, id, _ := strings.Cut(focus, ":"); kind {
|
|
case "":
|
|
v.Level, v.Title = "overview", "Every service"
|
|
// A Kubernetes cluster is always one box here, opening into its
|
|
// services; the rest are drawn one by one until there are too many.
|
|
few := len(g.Services) <= mapServiceCards
|
|
where := map[string]string{}
|
|
members := map[string][]string{}
|
|
names := map[string]string{}
|
|
var order []string
|
|
layer := map[string]int{}
|
|
for _, s := range g.Services {
|
|
_, inCluster := k8sCluster(s)
|
|
if few && !inCluster {
|
|
v.Boxes = append(v.Boxes, box(s))
|
|
where[s.ID] = "svc:" + s.ID
|
|
continue
|
|
}
|
|
gid, gname := groupOf(s)
|
|
if members[gid] == nil {
|
|
order = append(order, gid)
|
|
layer[gid] = s.Layer
|
|
}
|
|
members[gid] = append(members[gid], s.ID)
|
|
names[gid] = gname
|
|
where[s.ID] = gid
|
|
layer[gid] = min(layer[gid], s.Layer)
|
|
}
|
|
kinds := map[string]string{} // a source's name → what it is, for its box (#37)
|
|
for _, s := range srv.workloadSnapshot() {
|
|
kinds[s.name] = s.kindLabel()
|
|
}
|
|
// A cluster's box takes the cluster's own state too, the one the
|
|
// Clusters page and the network map show (#38), not only its
|
|
// services'.
|
|
clusters := map[string]ClusterView{}
|
|
_, conds := srv.view(now)
|
|
for _, c := range srv.clusterViews(now, conds) {
|
|
clusters[c.Name] = c
|
|
}
|
|
for _, gid := range order {
|
|
b := fold(gid, "group", names[gid], members[gid], status)
|
|
for i, m := range b.Problems {
|
|
b.Problems[i] = svc[m].Name
|
|
}
|
|
b.Layer = layer[gid]
|
|
if c, ok := strings.CutPrefix(gid, "group:cluster:"); ok {
|
|
cv, known := clusters[c]
|
|
clusterBox(&b, kinds[c], cv, known, members[gid], status)
|
|
}
|
|
v.Boxes = append(v.Boxes, b)
|
|
}
|
|
for _, e := range edges {
|
|
ls.add(where[e.From], where[e.To], "needs", true, portList(e.Port), e.Stage)
|
|
}
|
|
|
|
case "group":
|
|
gid := "group:" + id
|
|
v.Level = "group"
|
|
v.Crumbs = []MapBox{overview}
|
|
in := map[string]bool{}
|
|
for _, s := range g.Services {
|
|
if g2, _ := groupOf(s); g2 == gid {
|
|
in[s.ID] = true
|
|
_, v.Title = groupOf(s)
|
|
v.Boxes = append(v.Boxes, box(s))
|
|
}
|
|
}
|
|
if len(in) == 0 {
|
|
return nil, false
|
|
}
|
|
others := map[string]MapBox{}
|
|
for _, e := range edges {
|
|
a, b := in[e.From], in[e.To]
|
|
if !a && !b {
|
|
continue
|
|
}
|
|
for _, x := range []string{e.From, e.To} {
|
|
if !in[x] {
|
|
ob := box(svc[x])
|
|
ob.Kind = "elsewhere:service"
|
|
others[ob.ID] = ob
|
|
}
|
|
}
|
|
ls.add("svc:"+e.From, "svc:"+e.To, "needs", true, portList(e.Port), e.Stage)
|
|
}
|
|
v.Boxes = append(v.Boxes, sortedBoxes(others)...)
|
|
|
|
case "svc":
|
|
if _, ok := svc[id]; !ok {
|
|
return nil, false
|
|
}
|
|
v.Level, v.Title = "service", svc[id].Name
|
|
v.Crumbs = []MapBox{overview}
|
|
if c, ok := k8sCluster(svc[id]); ok {
|
|
v.Crumbs = append(v.Crumbs, MapBox{ID: "group:cluster:" + c, Kind: "group", Name: c})
|
|
}
|
|
down := map[string][]MapEdge{}
|
|
up := map[string][]MapEdge{}
|
|
for _, e := range edges {
|
|
down[e.From] = append(down[e.From], e)
|
|
up[e.To] = append(up[e.To], e)
|
|
}
|
|
keep := map[string]bool{id: true}
|
|
walk := func(next map[string][]MapEdge, toward func(MapEdge) string) {
|
|
frontier := []string{id}
|
|
for range steps {
|
|
var more []string
|
|
for _, f := range frontier {
|
|
for _, e := range next[f] {
|
|
t := toward(e)
|
|
ls.add("svc:"+e.From, "svc:"+e.To, "needs", true, portList(e.Port), e.Stage)
|
|
if !keep[t] {
|
|
keep[t] = true
|
|
more = append(more, t)
|
|
}
|
|
}
|
|
}
|
|
frontier = more
|
|
}
|
|
}
|
|
walk(down, func(e MapEdge) string { return e.To })
|
|
walk(up, func(e MapEdge) string { return e.From })
|
|
for _, s := range g.Services {
|
|
if keep[s.ID] {
|
|
v.Boxes = append(v.Boxes, box(s))
|
|
}
|
|
}
|
|
default:
|
|
return nil, false
|
|
}
|
|
v.Lines = ls.list()
|
|
slices.SortStableFunc(v.Boxes, func(a, b MapBox) int { return cmp.Compare(a.Layer, b.Layer) })
|
|
v.capped()
|
|
return v, true
|
|
}
|
|
|
|
func portList(p int) []int {
|
|
if p == 0 {
|
|
return nil
|
|
}
|
|
return []int{p}
|
|
}
|
|
|
|
func appendNew(s []string, v string) []string {
|
|
if slices.Contains(s, v) {
|
|
return s
|
|
}
|
|
return append(s, v)
|
|
}
|
|
|
|
// MapFound is a search hit on the maps: where to go to see it.
|
|
type MapFound struct {
|
|
Kind string `json:"kind"` // host, site, service
|
|
Name string `json:"name"`
|
|
Where string `json:"where,omitempty"` // the site it's in
|
|
Map string `json:"map"` // network or services
|
|
Focus string `json:"focus"`
|
|
}
|
|
|
|
// handleMapFind finds hosts, sites and services by name: ?q=, at most 20,
|
|
// whole-name matches first.
|
|
func (srv *Server) handleMapFind(w http.ResponseWriter, r *http.Request) {
|
|
q := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q")))
|
|
out := []MapFound{}
|
|
if q == "" {
|
|
writeJSON(w, http.StatusOK, map[string]any{"found": out})
|
|
return
|
|
}
|
|
g := srv.mapGraph(time.Now())
|
|
siteName := map[string]string{}
|
|
for _, s := range g.Sites {
|
|
siteName[s.ID] = s.Name
|
|
}
|
|
type hit struct {
|
|
f MapFound
|
|
exact bool
|
|
}
|
|
var hits []hit
|
|
match := func(names ...string) (bool, bool) {
|
|
for _, n := range names {
|
|
n = strings.ToLower(n)
|
|
if n == q {
|
|
return true, true
|
|
}
|
|
if strings.Contains(n, q) {
|
|
return true, false
|
|
}
|
|
}
|
|
return false, false
|
|
}
|
|
for _, s := range g.Sites {
|
|
if ok, ex := match(s.Name, strings.TrimPrefix(s.ID, "site:")); ok {
|
|
hits = append(hits, hit{MapFound{Kind: "site", Name: s.Name, Map: "network", Focus: s.ID}, ex})
|
|
}
|
|
}
|
|
for _, h := range g.Hosts {
|
|
if ok, ex := match(h.Name); ok {
|
|
hits = append(hits, hit{MapFound{Kind: "host", Name: h.Name, Where: siteName[h.Site], Map: "network", Focus: "host:" + h.Name}, ex})
|
|
}
|
|
}
|
|
for _, s := range g.Services {
|
|
if ok, ex := match(s.Name, s.ID); ok {
|
|
hits = append(hits, hit{MapFound{Kind: "service", Name: s.Name, Map: "services", Focus: "svc:" + s.ID}, ex})
|
|
}
|
|
}
|
|
slices.SortStableFunc(hits, func(a, b hit) int {
|
|
if a.exact != b.exact {
|
|
if a.exact {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
return cmp.Compare(len(a.f.Name), len(b.f.Name))
|
|
})
|
|
for _, h := range hits[:min(len(hits), 20)] {
|
|
out = append(out, h.f)
|
|
}
|
|
writeJSON(w, http.StatusOK, map[string]any{"found": out, "more": len(hits) > 20})
|
|
}
|
|
|
|
// k8sCluster is the cluster a service on the map comes from, if it's from
|
|
// one: its parts are all that cluster's (docs/maps.md, step 7).
|
|
// clusterBox says what a cluster's box on the service map is, and gives it
|
|
// the cluster's own state when that's worse than its services' (#38): the
|
|
// state the Clusters page and the network map show. VMs someone stopped are
|
|
// grey on their own but don't grey a cluster whose other services run.
|
|
func clusterBox(b *MapBox, kind string, cv ClusterView, known bool, members []string, status map[string]string) {
|
|
b.Sub = cmp.Or(kind, "Kubernetes cluster")
|
|
if b.Status == "waiting" {
|
|
idle, running := 0, 0
|
|
for _, m := range members {
|
|
switch status[m] {
|
|
case "waiting", "":
|
|
idle++
|
|
case "good":
|
|
running++
|
|
}
|
|
}
|
|
if running > 0 {
|
|
b.Status = "good"
|
|
b.Sub += fmt.Sprintf(" · %d not running", idle)
|
|
}
|
|
}
|
|
if known && statusOrder[cv.Status] > statusOrder[b.Status] {
|
|
b.Status = cv.Status
|
|
b.Sub += " · " + cv.Word // why it isn't green when its services are
|
|
}
|
|
}
|
|
|
|
func k8sCluster(s mapgraph.Service) (string, bool) {
|
|
if s.Source != "kubernetes" || len(s.Parts) == 0 {
|
|
return "", false
|
|
}
|
|
return s.Parts[0].Host, true
|
|
}
|