The ring buffer on each agent holds 4095 flows, ~10 s at the observed ~380 flows/s, so the 5/15/60 min windows were really showing the last few seconds. A background follow stream now fills per-minute buckets for the last hour, and counts are distinct connections (5-tuples) instead of Hubble events, with opened (SYN) and dropped broken out. /api/flows reports coveredSec so the UI can say how much of the window the collector has seen since start. /api/graph reads informer caches instead of listing every kind per request (~0.9 s before). Pod-to-workload resolution for flows uses the same cache. YAML view drops managedFields. Frontend: traffic refreshes in place every 30 s without relayout; dash animation rationed (12 fps, only highlighted edges in dense views, paused after a minute idle) since each step redraws the whole element layer, ~15 ms on a 200-element view. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
660 lines
19 KiB
Go
660 lines
19 KiB
Go
// cluster-map: a live topology view of a Deckhouse/Kubernetes cluster.
|
|
//
|
|
// Builds a graph on every request to /api/graph from informer caches:
|
|
// namespaces group workloads, which connect to Services (by label-selector
|
|
// match) and Ingresses (by backend reference). Informers keep the caches
|
|
// in step with the API by watch; a fresh List per request cost ~0.9 s and
|
|
// timed out the 1 s probe.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"sort"
|
|
"strings"
|
|
|
|
appsv1 "k8s.io/api/apps/v1"
|
|
batchv1 "k8s.io/api/batch/v1"
|
|
corev1 "k8s.io/api/core/v1"
|
|
networkingv1 "k8s.io/api/networking/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/kubernetes"
|
|
"k8s.io/client-go/rest"
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
type Node struct {
|
|
ID string `json:"id"`
|
|
Label string `json:"label"`
|
|
Kind string `json:"kind"` // namespace | deployment | statefulset | daemonset | cronjob | service | ingress | node
|
|
Namespace string `json:"namespace"` // empty for namespace/node kind
|
|
Parent string `json:"parent,omitempty"`
|
|
NodeName string `json:"nodeName,omitempty"` // physical node a workload's pods land on, if known
|
|
Facts map[string]string `json:"facts,omitempty"` // short summary shown in the sidebar without a follow-up fetch
|
|
}
|
|
|
|
type Edge struct {
|
|
ID string `json:"id"`
|
|
Source string `json:"source"`
|
|
Target string `json:"target"`
|
|
Kind string `json:"kind"` // selects | routes | schedules-on
|
|
}
|
|
|
|
type Graph struct {
|
|
Nodes []Node `json:"nodes"`
|
|
Edges []Edge `json:"edges"`
|
|
}
|
|
|
|
var clientset *kubernetes.Clientset
|
|
|
|
func main() {
|
|
cfg, err := rest.InClusterConfig()
|
|
if err != nil {
|
|
log.Fatalf("not running in-cluster and no kubeconfig fallback wired up: %v", err)
|
|
}
|
|
clientset, err = kubernetes.NewForConfig(cfg)
|
|
if err != nil {
|
|
log.Fatalf("building clientset: %v", err)
|
|
}
|
|
|
|
if err := startInformers(); err != nil {
|
|
log.Fatalf("informers: %v", err)
|
|
}
|
|
startHubble()
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/healthz", func(w http.ResponseWriter, _ *http.Request) { w.Write([]byte("ok")) })
|
|
mux.HandleFunc("/api/flows", handleFlows)
|
|
mux.HandleFunc("/api/graph", handleGraph)
|
|
mux.HandleFunc("/api/resource", handleResource)
|
|
mux.HandleFunc("/api/pods", handlePods)
|
|
mux.HandleFunc("/api/logs", handleLogs)
|
|
mux.Handle("/", http.FileServer(http.Dir("./static")))
|
|
|
|
addr := ":8080"
|
|
log.Printf("cluster-map listening on %s", addr)
|
|
log.Fatal(http.ListenAndServe(addr, mux))
|
|
}
|
|
|
|
func handleGraph(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
g, err := buildGraph(ctx)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(g)
|
|
}
|
|
|
|
// selectorSubset reports whether every key/value in sel is present in labels --
|
|
// the standard Kubernetes rule for whether a Service's spec.selector matches a
|
|
// pod template's labels.
|
|
func selectorSubset(sel, labels map[string]string) bool {
|
|
if len(sel) == 0 {
|
|
return false // an empty selector matches everything in real k8s, but showing an edge to "everything" is useless noise here
|
|
}
|
|
for k, v := range sel {
|
|
if labels[k] != v {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func buildGraph(ctx context.Context) (*Graph, error) {
|
|
g := &Graph{}
|
|
|
|
namespaces, err := listAll[corev1.Namespace](nsLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, ns := range namespaces.Items {
|
|
system := strings.HasPrefix(ns.Name, "d8-") || ns.Name == "kube-system" || ns.Name == "kube-public" || ns.Name == "kube-node-lease"
|
|
g.Nodes = append(g.Nodes, Node{
|
|
ID: "ns/" + ns.Name,
|
|
Label: ns.Name,
|
|
Kind: "namespace",
|
|
Facts: map[string]string{"system": boolStr(system)},
|
|
})
|
|
}
|
|
|
|
// pod-template-labels indexed by namespace, used to match Services to
|
|
// their owning workload below.
|
|
type workloadRef struct {
|
|
id string
|
|
labels map[string]string
|
|
}
|
|
var workloads []workloadRef
|
|
|
|
deployments, err := listAll[appsv1.Deployment](deployLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, d := range deployments.Items {
|
|
id := workloadID(d.Namespace, "deployment", d.Name)
|
|
g.Nodes = append(g.Nodes, workloadNode(id, "deployment", d.Namespace, d.Name, deploymentFacts(d)))
|
|
workloads = append(workloads, workloadRef{id, d.Spec.Template.Labels})
|
|
}
|
|
|
|
statefulsets, err := listAll[appsv1.StatefulSet](stsLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, s := range statefulsets.Items {
|
|
id := workloadID(s.Namespace, "statefulset", s.Name)
|
|
g.Nodes = append(g.Nodes, workloadNode(id, "statefulset", s.Namespace, s.Name, statefulsetFacts(s)))
|
|
workloads = append(workloads, workloadRef{id, s.Spec.Template.Labels})
|
|
}
|
|
|
|
daemonsets, err := listAll[appsv1.DaemonSet](dsLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, ds := range daemonsets.Items {
|
|
id := workloadID(ds.Namespace, "daemonset", ds.Name)
|
|
g.Nodes = append(g.Nodes, workloadNode(id, "daemonset", ds.Namespace, ds.Name, daemonsetFacts(ds)))
|
|
workloads = append(workloads, workloadRef{id, ds.Spec.Template.Labels})
|
|
}
|
|
|
|
cronjobs, err := listAll[batchv1.CronJob](cronLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, cj := range cronjobs.Items {
|
|
id := workloadID(cj.Namespace, "cronjob", cj.Name)
|
|
g.Nodes = append(g.Nodes, workloadNode(id, "cronjob", cj.Namespace, cj.Name, cronjobFacts(cj)))
|
|
// CronJob pods don't back a Service, so no labels needed for matching.
|
|
}
|
|
|
|
// Pods whose controller is not a native workload (kruise Advanced
|
|
// DaemonSet behind ingress-nginx, database operators, bare Jobs) would
|
|
// otherwise be invisible. They become workload nodes of their own, IDed
|
|
// the way Hubble names workloads, so traffic attaches to them too.
|
|
pods, err := listAll[corev1.Pod](podLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
known := map[string]bool{}
|
|
for _, n := range g.Nodes {
|
|
known[n.ID] = true
|
|
}
|
|
type foreignWl struct {
|
|
ns, kind, name, controller string
|
|
pods, ready int
|
|
labels map[string]string
|
|
}
|
|
foreign := map[string]*foreignWl{}
|
|
for _, p := range pods.Items {
|
|
kind, name, ctrl := podOwner(p)
|
|
if kind == "" {
|
|
continue
|
|
}
|
|
id := workloadID(p.Namespace, kind, name)
|
|
if known[id] {
|
|
continue
|
|
}
|
|
f := foreign[id]
|
|
if f == nil {
|
|
f = &foreignWl{ns: p.Namespace, kind: kind, name: name, controller: ctrl, labels: p.Labels}
|
|
foreign[id] = f
|
|
}
|
|
if p.Status.Phase == corev1.PodSucceeded {
|
|
continue
|
|
}
|
|
f.pods++
|
|
if podReady(p) {
|
|
f.ready++
|
|
}
|
|
}
|
|
for id, f := range foreign {
|
|
kind := f.kind
|
|
switch kind {
|
|
case "deployment", "statefulset", "daemonset", "cronjob":
|
|
default:
|
|
kind = "pod"
|
|
}
|
|
n := workloadNode(id, kind, f.ns, f.name, map[string]string{
|
|
"controller": f.controller,
|
|
"pods": itoa(f.pods),
|
|
"ready": itoa(f.ready),
|
|
"health": health(f.pods, f.ready),
|
|
"foreign": "true",
|
|
})
|
|
g.Nodes = append(g.Nodes, n)
|
|
workloads = append(workloads, workloadRef{id, f.labels})
|
|
}
|
|
|
|
services, err := listAll[corev1.Service](svcLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, svc := range services.Items {
|
|
id := "service/" + svc.Namespace + "/" + svc.Name
|
|
g.Nodes = append(g.Nodes, Node{
|
|
ID: id, Label: svc.Name, Kind: "service", Namespace: svc.Namespace, Parent: "ns/" + svc.Namespace,
|
|
Facts: serviceFacts(svc),
|
|
})
|
|
for _, wl := range workloads {
|
|
if !strings.HasPrefix(wl.id, "wl/"+svc.Namespace+"/") {
|
|
continue
|
|
}
|
|
if selectorSubset(svc.Spec.Selector, wl.labels) {
|
|
g.Edges = append(g.Edges, Edge{ID: wl.id + "->" + id, Source: wl.id, Target: id, Kind: "selects"})
|
|
}
|
|
}
|
|
}
|
|
|
|
ingresses, err := listAll[networkingv1.Ingress](ingLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, ing := range ingresses.Items {
|
|
id := "ingress/" + ing.Namespace + "/" + ing.Name
|
|
g.Nodes = append(g.Nodes, Node{
|
|
ID: id, Label: ing.Name, Kind: "ingress", Namespace: ing.Namespace, Parent: "ns/" + ing.Namespace,
|
|
Facts: ingressFacts(ing),
|
|
})
|
|
for _, svcName := range ingressBackendServices(ing) {
|
|
target := "service/" + ing.Namespace + "/" + svcName
|
|
g.Edges = append(g.Edges, Edge{ID: id + "->" + target, Source: id, Target: target, Kind: "routes"})
|
|
}
|
|
}
|
|
|
|
// Physical nodes as a separate, non-namespaced layer, linked from each
|
|
// workload to wherever its pods actually run right now -- this is the
|
|
// "what's deployed where" question specifically, not covered by the
|
|
// Service/Ingress graph above.
|
|
nodes, err := listAll[corev1.Node](nodeLister)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, n := range nodes.Items {
|
|
g.Nodes = append(g.Nodes, Node{ID: "node/" + n.Name, Label: n.Name, Kind: "node", Facts: nodeFacts(n)})
|
|
}
|
|
|
|
seenPlacement := map[string]bool{}
|
|
for _, p := range pods.Items {
|
|
if p.Spec.NodeName == "" {
|
|
continue
|
|
}
|
|
ownerWl := ownerWorkloadID(p)
|
|
if ownerWl == "" {
|
|
continue
|
|
}
|
|
key := ownerWl + "@" + p.Spec.NodeName
|
|
if seenPlacement[key] {
|
|
continue
|
|
}
|
|
seenPlacement[key] = true
|
|
g.Edges = append(g.Edges, Edge{ID: key, Source: ownerWl, Target: "node/" + p.Spec.NodeName, Kind: "schedules-on"})
|
|
}
|
|
|
|
sort.Slice(g.Nodes, func(i, j int) bool { return g.Nodes[i].ID < g.Nodes[j].ID })
|
|
sort.Slice(g.Edges, func(i, j int) bool { return g.Edges[i].ID < g.Edges[j].ID })
|
|
return g, nil
|
|
}
|
|
|
|
// podOwner names the workload a pod belongs to the way Hubble does
|
|
// (cilium's GetWorkloadMetaFromPod): ReplicaSet -> its Deployment, a Job
|
|
// whose name ends in the scheduler's numeric suffix -> its CronJob, any
|
|
// other controller kind as-is. controller is "<apiVersion> <Kind>".
|
|
func podOwner(p corev1.Pod) (kind, name, controller string) {
|
|
var o *metav1.OwnerReference
|
|
for i := range p.OwnerReferences {
|
|
if p.OwnerReferences[i].Controller != nil && *p.OwnerReferences[i].Controller {
|
|
o = &p.OwnerReferences[i]
|
|
break
|
|
}
|
|
}
|
|
if o == nil && len(p.OwnerReferences) > 0 {
|
|
o = &p.OwnerReferences[0]
|
|
}
|
|
if o == nil {
|
|
return "", "", ""
|
|
}
|
|
controller = o.APIVersion + " " + o.Kind
|
|
switch o.Kind {
|
|
case "Node":
|
|
// static pod mirrored by the kubelet: "<component>-<node>", grouped
|
|
// per component across nodes like a DaemonSet would be
|
|
return "staticpod", strings.TrimSuffix(p.Name, "-"+p.Spec.NodeName), "static pod (kubelet)"
|
|
case "ReplicaSet":
|
|
if i := strings.LastIndex(o.Name, "-"); i > 0 {
|
|
return "deployment", o.Name[:i], controller
|
|
}
|
|
case "Job":
|
|
if i := strings.LastIndex(o.Name, "-"); i > 0 && allDigits(o.Name[i+1:]) {
|
|
return "cronjob", o.Name[:i], controller
|
|
}
|
|
}
|
|
return strings.ToLower(o.Kind), o.Name, controller
|
|
}
|
|
|
|
func allDigits(s string) bool {
|
|
if s == "" {
|
|
return false
|
|
}
|
|
for _, c := range s {
|
|
if c < '0' || c > '9' {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func podReady(p corev1.Pod) bool {
|
|
for _, c := range p.Status.Conditions {
|
|
if c.Type == corev1.PodReady {
|
|
return c.Status == corev1.ConditionTrue
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func ownerWorkloadID(p corev1.Pod) string {
|
|
kind, name, _ := podOwner(p)
|
|
if kind == "" {
|
|
return ""
|
|
}
|
|
return workloadID(p.Namespace, kind, name)
|
|
}
|
|
|
|
func workloadID(ns, kind, name string) string { return "wl/" + ns + "/" + kind + "/" + name }
|
|
|
|
func workloadNode(id, kind, ns, name string, facts map[string]string) Node {
|
|
return Node{ID: id, Label: name, Kind: kind, Namespace: ns, Parent: "ns/" + ns, Facts: facts}
|
|
}
|
|
|
|
func boolStr(b bool) string {
|
|
if b {
|
|
return "true"
|
|
}
|
|
return "false"
|
|
}
|
|
|
|
func ingressBackendServices(ing networkingv1.Ingress) []string {
|
|
seen := map[string]bool{}
|
|
var out []string
|
|
add := func(name string) {
|
|
if name != "" && !seen[name] {
|
|
seen[name] = true
|
|
out = append(out, name)
|
|
}
|
|
}
|
|
if ing.Spec.DefaultBackend != nil && ing.Spec.DefaultBackend.Service != nil {
|
|
add(ing.Spec.DefaultBackend.Service.Name)
|
|
}
|
|
for _, rule := range ing.Spec.Rules {
|
|
if rule.HTTP == nil {
|
|
continue
|
|
}
|
|
for _, path := range rule.HTTP.Paths {
|
|
if path.Backend.Service != nil {
|
|
add(path.Backend.Service.Name)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func firstContainerImage(containers []corev1.Container) string {
|
|
if len(containers) == 0 {
|
|
return ""
|
|
}
|
|
return containers[0].Image
|
|
}
|
|
|
|
// health is what the status dot on a card shows: ok, warn (partly ready),
|
|
// error (nothing ready), idle (scaled to zero or suspended).
|
|
func health(want, ready int) string {
|
|
switch {
|
|
case want == 0:
|
|
return "idle"
|
|
case ready >= want:
|
|
return "ok"
|
|
case ready == 0:
|
|
return "error"
|
|
}
|
|
return "warn"
|
|
}
|
|
|
|
func replicasOf(p *int32) int {
|
|
if p == nil {
|
|
return 1
|
|
}
|
|
return int(*p)
|
|
}
|
|
|
|
func deploymentFacts(d appsv1.Deployment) map[string]string {
|
|
return map[string]string{
|
|
"replicas": itoa32(d.Spec.Replicas),
|
|
"readyReplicas": itoa(int(d.Status.ReadyReplicas)),
|
|
"image": firstContainerImage(d.Spec.Template.Spec.Containers),
|
|
"health": health(replicasOf(d.Spec.Replicas), int(d.Status.ReadyReplicas)),
|
|
}
|
|
}
|
|
|
|
func statefulsetFacts(s appsv1.StatefulSet) map[string]string {
|
|
return map[string]string{
|
|
"replicas": itoa32(s.Spec.Replicas),
|
|
"readyReplicas": itoa(int(s.Status.ReadyReplicas)),
|
|
"image": firstContainerImage(s.Spec.Template.Spec.Containers),
|
|
"health": health(replicasOf(s.Spec.Replicas), int(s.Status.ReadyReplicas)),
|
|
}
|
|
}
|
|
|
|
func daemonsetFacts(ds appsv1.DaemonSet) map[string]string {
|
|
return map[string]string{
|
|
"desired": itoa(int(ds.Status.DesiredNumberScheduled)),
|
|
"ready": itoa(int(ds.Status.NumberReady)),
|
|
"image": firstContainerImage(ds.Spec.Template.Spec.Containers),
|
|
"health": health(int(ds.Status.DesiredNumberScheduled), int(ds.Status.NumberReady)),
|
|
}
|
|
}
|
|
|
|
func cronjobFacts(cj batchv1.CronJob) map[string]string {
|
|
f := map[string]string{"schedule": cj.Spec.Schedule, "health": "ok", "active": itoa(len(cj.Status.Active))}
|
|
if cj.Spec.Suspend != nil && *cj.Spec.Suspend {
|
|
f["suspended"] = "true"
|
|
f["health"] = "idle"
|
|
}
|
|
if cj.Status.LastSuccessfulTime != nil {
|
|
f["lastSuccess"] = cj.Status.LastSuccessfulTime.UTC().Format("2006-01-02 15:04")
|
|
}
|
|
return f
|
|
}
|
|
|
|
func serviceFacts(svc corev1.Service) map[string]string {
|
|
var ports []string
|
|
for _, p := range svc.Spec.Ports {
|
|
ports = append(ports, itoa(int(p.Port))+"/"+string(p.Protocol))
|
|
}
|
|
return map[string]string{"type": string(svc.Spec.Type), "ports": strings.Join(ports, ", ")}
|
|
}
|
|
|
|
func ingressFacts(ing networkingv1.Ingress) map[string]string {
|
|
var hosts []string
|
|
for _, r := range ing.Spec.Rules {
|
|
if r.Host != "" {
|
|
hosts = append(hosts, r.Host)
|
|
}
|
|
}
|
|
class := ""
|
|
if ing.Spec.IngressClassName != nil {
|
|
class = *ing.Spec.IngressClassName
|
|
}
|
|
return map[string]string{"hosts": strings.Join(hosts, ", "), "class": class}
|
|
}
|
|
|
|
func nodeFacts(n corev1.Node) map[string]string {
|
|
ready := "False"
|
|
for _, c := range n.Status.Conditions {
|
|
if c.Type == corev1.NodeReady {
|
|
ready = string(c.Status)
|
|
}
|
|
}
|
|
h := "ok"
|
|
if ready != "True" {
|
|
h = "error"
|
|
}
|
|
return map[string]string{"ready": ready, "os": n.Status.NodeInfo.OSImage, "kubelet": n.Status.NodeInfo.KubeletVersion, "health": h}
|
|
}
|
|
|
|
func itoa(i int) string {
|
|
if i == 0 {
|
|
return "0"
|
|
}
|
|
neg := i < 0
|
|
if neg {
|
|
i = -i
|
|
}
|
|
var b []byte
|
|
for i > 0 {
|
|
b = append([]byte{byte('0' + i%10)}, b...)
|
|
i /= 10
|
|
}
|
|
if neg {
|
|
b = append([]byte{'-'}, b...)
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func itoa32(p *int32) string {
|
|
if p == nil {
|
|
return "?"
|
|
}
|
|
return itoa(int(*p))
|
|
}
|
|
|
|
// handleResource returns the raw manifest (as YAML, easiest to read) for a
|
|
// single graph node, fetched fresh -- not cached alongside the graph, since
|
|
// most nodes are never clicked and a full spec dump for every workload on
|
|
// every /api/graph call would be wasteful.
|
|
func handleResource(w http.ResponseWriter, r *http.Request) {
|
|
kind := r.URL.Query().Get("kind")
|
|
ns := r.URL.Query().Get("namespace")
|
|
name := r.URL.Query().Get("name")
|
|
ctx := r.Context()
|
|
|
|
var obj interface{}
|
|
var err error
|
|
switch kind {
|
|
case "namespace":
|
|
obj, err = clientset.CoreV1().Namespaces().Get(ctx, name, metav1.GetOptions{})
|
|
case "deployment":
|
|
obj, err = clientset.AppsV1().Deployments(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "statefulset":
|
|
obj, err = clientset.AppsV1().StatefulSets(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "daemonset":
|
|
obj, err = clientset.AppsV1().DaemonSets(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "cronjob":
|
|
obj, err = clientset.BatchV1().CronJobs(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "service":
|
|
obj, err = clientset.CoreV1().Services(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "ingress":
|
|
obj, err = clientset.NetworkingV1().Ingresses(ns).Get(ctx, name, metav1.GetOptions{})
|
|
case "node":
|
|
obj, err = clientset.CoreV1().Nodes().Get(ctx, name, metav1.GetOptions{})
|
|
default:
|
|
http.Error(w, "unknown kind: "+kind, http.StatusBadRequest)
|
|
return
|
|
}
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusNotFound)
|
|
return
|
|
}
|
|
if a, ok := obj.(metav1.Object); ok {
|
|
a.SetManagedFields(nil)
|
|
}
|
|
out, err := yaml.Marshal(obj)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
w.Write(out)
|
|
}
|
|
|
|
// podsForWorkload finds the live pods currently owned by a given workload,
|
|
// reusing the same ownerReferences-walking logic buildGraph uses for the
|
|
// schedules-on edges -- so "which pods back this node" stays consistent
|
|
// with what the graph already shows for placement.
|
|
func podsForWorkload(ctx context.Context, ns, target string) ([]corev1.Pod, error) {
|
|
pods, err := listAll[corev1.Pod](podLister.Pods(ns))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var out []corev1.Pod
|
|
for _, p := range pods.Items {
|
|
if ownerWorkloadID(p) == target {
|
|
out = append(out, p)
|
|
}
|
|
}
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
|
|
return out, nil
|
|
}
|
|
|
|
type PodInfo struct {
|
|
Name string `json:"name"`
|
|
NodeName string `json:"nodeName"`
|
|
Phase string `json:"phase"`
|
|
Containers []string `json:"containers"`
|
|
}
|
|
|
|
// handlePods lists the pods backing a workload node, with their containers --
|
|
// the frontend uses this to build the pod/container pickers before fetching
|
|
// logs, since a Deployment/StatefulSet/DaemonSet/CronJob isn't itself a log
|
|
// source, its pods are.
|
|
func handlePods(w http.ResponseWriter, r *http.Request) {
|
|
id := r.URL.Query().Get("id")
|
|
ns := r.URL.Query().Get("namespace")
|
|
if ns == "" || !strings.HasPrefix(id, "wl/"+ns+"/") {
|
|
http.Error(w, "namespace and a workload id (wl/<ns>/<kind>/<name>) are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
pods, err := podsForWorkload(r.Context(), ns, id)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
out := make([]PodInfo, 0, len(pods))
|
|
for _, p := range pods {
|
|
var containers []string
|
|
for _, c := range p.Spec.Containers {
|
|
containers = append(containers, c.Name)
|
|
}
|
|
out = append(out, PodInfo{Name: p.Name, NodeName: p.Spec.NodeName, Phase: string(p.Status.Phase), Containers: containers})
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(out)
|
|
}
|
|
|
|
// handleLogs streams a single container's recent log tail. Read-only,
|
|
// no follow -- this is a click-to-inspect tool, not a live tail viewer.
|
|
func handleLogs(w http.ResponseWriter, r *http.Request) {
|
|
ns := r.URL.Query().Get("namespace")
|
|
pod := r.URL.Query().Get("pod")
|
|
container := r.URL.Query().Get("container")
|
|
if ns == "" || pod == "" {
|
|
http.Error(w, "namespace and pod are required", http.StatusBadRequest)
|
|
return
|
|
}
|
|
var tail int64 = 500
|
|
opts := &corev1.PodLogOptions{TailLines: &tail}
|
|
if container != "" {
|
|
opts.Container = container
|
|
}
|
|
stream, err := clientset.CoreV1().Pods(ns).GetLogs(pod, opts).Stream(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer stream.Close()
|
|
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
io.Copy(w, stream)
|
|
}
|