v0.8.0: problem badges, actions as the viewer, load, events, lock

Problems: cards, namespace and node boxes and the tree carry a yellow or
red badge, computed on the server from object state (crash loops, image
pulls, pending and unschedulable pods, readiness older than 2 minutes, a
stuck rollout, a failed CronJob run, Services without endpoints,
Ingresses to missing Services, node conditions), recent Warning events
(notable reasons at once, others after five repeats) and Deckhouse
ClusterAlerts mapped by their labels. A Problems panel lists them all.
Checked against the live cluster: upmeter's synthetic probe pods and
ingress-nginx's fakeservice Ingresses are excluded, they fail on purpose.

Actions: restart, scale, run a CronJob now, suspend/resume, delete a
pod, cordon/uncordon. They run with the viewer's bearer token from the
DexAuthenticator (sendAuthorizationHeader), buttons follow a
SelfSubjectAccessReview, the service account stays read-only. Cross-site
writes are refused by Sec-Fetch-Site/Origin/content type. Scale retries
on conflict: right after a restart a single Get+Update got 409.

Load (metrics.k8s.io against requests/limits/allocatable, per-pod table)
and an Events tab. Cards are locked until the padlock is opened; the map
exports to PNG; the page refreshes badges every minute in place.

Performance, measured on the live cluster:
- layout of big views 3-4x faster: equal-size cards with no edges are
  laid out on the grid ELK would produce (same sizes, checked against
  ELK on a frozen node view), skipping ~8 ms per ELK call;
- hubble-relay gets ~20% fewer flows: the to-overlay copy of pod-to-pod
  traffic is dropped at the agents; 331/331 directions unchanged;
- static files carry ETags, a reload revalidates instead of pulling
  ~2 MB of vendored scripts.

KUBECONFIG is honoured for running the binary on a workstation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Виталий Чефанов
2026-09-24 17:25:36 +03:00
co-authored by Claude Opus 5.5
parent 8b8fe341d5
commit 3cdc2583ee
36 changed files with 2909 additions and 83 deletions
+31 -7
View File
@@ -35,9 +35,12 @@ import (
"github.com/prometheus/client_golang/prometheus/promhttp"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"git.project-chimera.ru/fanchji/cluster-map/internal/actions"
"git.project-chimera.ru/fanchji/cluster-map/internal/config"
"git.project-chimera.ru/fanchji/cluster-map/internal/kube"
"git.project-chimera.ru/fanchji/cluster-map/internal/metrics"
@@ -63,7 +66,15 @@ func run() error {
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
srv := server.New(cfg, web.Static())
restCfg, err := restConfig()
if err != nil {
return err
}
var asViewer actions.ClientFactory
if cfg.ActionsEnabled {
asViewer = actions.NewClientFactory(restCfg)
}
srv := server.New(cfg, web.Static(), asViewer)
api := &http.Server{Addr: cfg.ListenAddr, Handler: srv.Handler(), ReadHeaderTimeout: 10 * time.Second}
metricsSrv := &http.Server{Addr: cfg.MetricsAddr, Handler: promhttp.HandlerFor(metrics.Registry, promhttp.HandlerOpts{}), ReadHeaderTimeout: 10 * time.Second}
errc := make(chan error, 2)
@@ -74,17 +85,17 @@ func run() error {
}
}()
}
slog.Info("listening", "api", cfg.ListenAddr, "metrics", cfg.MetricsAddr, "traffic", cfg.TrafficMode)
slog.Info("listening", "api", cfg.ListenAddr, "metrics", cfg.MetricsAddr, "traffic", cfg.TrafficMode, "actions", cfg.ActionsEnabled)
restCfg, err := rest.InClusterConfig()
if err != nil {
return fmt.Errorf("in-cluster config: %w", err)
}
client, err := kubernetes.NewForConfig(restCfg)
if err != nil {
return err
}
cache, err := kube.Start(ctx, client, 2*time.Minute)
dyn, err := dynamic.NewForConfig(restCfg)
if err != nil {
return err
}
cache, err := kube.Start(ctx, client, dyn, 2*time.Minute)
if err != nil {
return err
}
@@ -110,6 +121,19 @@ func run() error {
return errors.Join(api.Shutdown(shutdownCtx), metricsSrv.Shutdown(shutdownCtx))
}
// restConfig is the pod's service account; KUBECONFIG, when set, is for
// running the binary on a workstation during development.
func restConfig() (*rest.Config, error) {
if path := os.Getenv("KUBECONFIG"); path != "" {
return clientcmd.BuildConfigFromFlags("", path)
}
cfg, err := rest.InClusterConfig()
if err != nil {
return nil, fmt.Errorf("in-cluster config: %w", err)
}
return cfg, nil
}
// hubbleClient connects to Hubble Relay over TLS. Relay presents a
// *.hubble-relay.cilium.io certificate signed by the cluster's hubble CA
// and does not ask for a client certificate, so only the CA is needed.
+1
View File
@@ -39,6 +39,7 @@ require (
github.com/prometheus/client_model v0.6.2 // indirect
github.com/prometheus/common v0.70.1 // indirect
github.com/prometheus/procfs v0.21.1 // indirect
github.com/spf13/pflag v1.0.6-0.20210604193023-d5e0c0615ace // indirect
github.com/x448/float16 v0.8.4 // indirect
golang.org/x/net v0.57.0 // indirect
golang.org/x/oauth2 v0.36.0 // indirect
@@ -0,0 +1,263 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Package actions runs the few changes the map offers (restart, scale,
// delete a pod, run a CronJob, cordon a node) as the viewer.
//
// Every call goes to the API server with the viewer's own bearer token,
// the one the DexAuthenticator puts into the Authorization header. The
// module's service account stays read-only, so the map can never do more
// than its viewer could do with kubectl, and the API server's audit log
// names the person, not cluster-map.
package actions
import (
"context"
"errors"
"fmt"
"strconv"
"time"
authnv1 "k8s.io/api/authentication/v1"
authzv1 "k8s.io/api/authorization/v1"
batchv1 "k8s.io/api/batch/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/util/retry"
)
// Action names, as the UI sends them.
const (
Restart = "restart"
Scale = "scale"
DeletePod = "delete-pod"
Run = "run"
Suspend = "suspend"
Resume = "resume"
Cordon = "cordon"
Uncordon = "uncordon"
)
// MaxReplicas bounds Scale; a typo in the dialog should not start 5000 pods.
const MaxReplicas = 100
// Request is the body of POST /api/action.
type Request struct {
Action string `json:"action"`
Kind string `json:"kind"` // deployment | statefulset | daemonset | cronjob | pod | node
Namespace string `json:"namespace"`
Name string `json:"name"`
Replicas *int32 `json:"replicas,omitempty"`
}
func (r Request) String() string {
if r.Namespace == "" {
return r.Kind + "/" + r.Name
}
return r.Kind + " " + r.Namespace + "/" + r.Name
}
// check is the RBAC question an action asks the API server first.
type check struct{ group, resource, subresource, verb string }
var byKind = map[string]map[string]check{
"deployment": {
Restart: {"apps", "deployments", "", "patch"},
Scale: {"apps", "deployments", "scale", "update"},
},
"statefulset": {
Restart: {"apps", "statefulsets", "", "patch"},
Scale: {"apps", "statefulsets", "scale", "update"},
},
"daemonset": {
Restart: {"apps", "daemonsets", "", "patch"},
},
"cronjob": {
Run: {"batch", "jobs", "", "create"},
Suspend: {"batch", "cronjobs", "", "patch"},
Resume: {"batch", "cronjobs", "", "patch"},
},
"pod": {
DeletePod: {"", "pods", "", "delete"},
},
"node": {
Cordon: {"", "nodes", "", "patch"},
Uncordon: {"", "nodes", "", "patch"},
},
}
// ErrUnsupported is returned for an action the kind does not offer.
var ErrUnsupported = errors.New("this action is not offered for this kind of object")
// ClientFactory returns a clientset that authenticates as the viewer.
type ClientFactory func(token string) (kubernetes.Interface, error)
// NewClientFactory keeps base's API server address and CA and drops its
// credentials, so a request carries the viewer's token and nothing else.
func NewClientFactory(base *rest.Config) ClientFactory {
return func(token string) (kubernetes.Interface, error) {
cfg := rest.AnonymousClientConfig(base)
cfg.BearerToken = token
cfg.UserAgent = "cluster-map (on behalf of the viewer)"
cfg.Timeout = 15 * time.Second
return kubernetes.NewForConfig(cfg)
}
}
// WhoAmI returns the viewer's username as the API server sees it.
func WhoAmI(ctx context.Context, c kubernetes.Interface) (string, error) {
r, err := c.AuthenticationV1().SelfSubjectReviews().Create(ctx, &authnv1.SelfSubjectReview{}, metav1.CreateOptions{})
if err != nil {
return "", err
}
return r.Status.UserInfo.Username, nil
}
// Allowed asks the API server which of the kind's actions the viewer may
// run on the object.
func Allowed(ctx context.Context, c kubernetes.Interface, kind, namespace, name string) (map[string]bool, error) {
out := map[string]bool{}
for action, ch := range byKind[kind] {
ok, err := can(ctx, c, ch, namespace, name)
if err != nil {
return nil, err
}
out[action] = ok
}
return out, nil
}
func can(ctx context.Context, c kubernetes.Interface, ch check, namespace, name string) (bool, error) {
attrs := &authzv1.ResourceAttributes{Group: ch.group, Resource: ch.resource, Subresource: ch.subresource, Verb: ch.verb, Namespace: namespace, Name: name}
if ch.verb == "create" {
attrs.Name = "" // a Job that does not exist yet
}
r, err := c.AuthorizationV1().SelfSubjectAccessReviews().Create(ctx, &authzv1.SelfSubjectAccessReview{
Spec: authzv1.SelfSubjectAccessReviewSpec{ResourceAttributes: attrs},
}, metav1.CreateOptions{})
if err != nil {
return false, err
}
return r.Status.Allowed, nil
}
// Do runs the action and returns a short description of what changed.
// Authorization is the API server's: a viewer without the right gets its
// Forbidden error back unchanged.
func Do(ctx context.Context, c kubernetes.Interface, r Request, now time.Time) (string, error) {
if _, ok := byKind[r.Kind][r.Action]; !ok {
return "", ErrUnsupported
}
if r.Name == "" || (r.Kind != "node" && r.Namespace == "") {
return "", errors.New("namespace and name are required")
}
switch r.Action {
case Restart:
// what kubectl rollout restart does
patch := fmt.Sprintf(`{"spec":{"template":{"metadata":{"annotations":{"kubectl.kubernetes.io/restartedAt":%q}}}}}`, now.UTC().Format(time.RFC3339))
var err error
switch r.Kind {
case "deployment":
_, err = c.AppsV1().Deployments(r.Namespace).Patch(ctx, r.Name, types.StrategicMergePatchType, []byte(patch), metav1.PatchOptions{})
case "statefulset":
_, err = c.AppsV1().StatefulSets(r.Namespace).Patch(ctx, r.Name, types.StrategicMergePatchType, []byte(patch), metav1.PatchOptions{})
case "daemonset":
_, err = c.AppsV1().DaemonSets(r.Namespace).Patch(ctx, r.Name, types.StrategicMergePatchType, []byte(patch), metav1.PatchOptions{})
}
return "rollout restarted", err
case Scale:
return scale(ctx, c, r)
case DeletePod:
return "pod deleted", c.CoreV1().Pods(r.Namespace).Delete(ctx, r.Name, metav1.DeleteOptions{})
case Run:
return runCronJob(ctx, c, r, now)
case Suspend, Resume:
patch := fmt.Sprintf(`{"spec":{"suspend":%t}}`, r.Action == Suspend)
_, err := c.BatchV1().CronJobs(r.Namespace).Patch(ctx, r.Name, types.MergePatchType, []byte(patch), metav1.PatchOptions{})
if r.Action == Suspend {
return "suspended", err
}
return "resumed", err
case Cordon, Uncordon:
patch := fmt.Sprintf(`{"spec":{"unschedulable":%t}}`, r.Action == Cordon)
_, err := c.CoreV1().Nodes().Patch(ctx, r.Name, types.MergePatchType, []byte(patch), metav1.PatchOptions{})
return r.Action + "ed", err
}
return "", ErrUnsupported
}
// scale reads and writes the scale subresource, retrying on a conflict:
// right after a restart the controller keeps updating the object, and a
// single Get+Update then failed with 409.
func scale(ctx context.Context, c kubernetes.Interface, r Request) (string, error) {
if r.Replicas == nil || *r.Replicas < 0 || *r.Replicas > MaxReplicas {
return "", fmt.Errorf("replicas must be between 0 and %d", MaxReplicas)
}
err := retry.RetryOnConflict(retry.DefaultRetry, func() error {
if r.Kind == "deployment" {
s, err := c.AppsV1().Deployments(r.Namespace).GetScale(ctx, r.Name, metav1.GetOptions{})
if err != nil {
return err
}
s.Spec.Replicas = *r.Replicas
_, err = c.AppsV1().Deployments(r.Namespace).UpdateScale(ctx, r.Name, s, metav1.UpdateOptions{})
return err
}
s, err := c.AppsV1().StatefulSets(r.Namespace).GetScale(ctx, r.Name, metav1.GetOptions{})
if err != nil {
return err
}
s.Spec.Replicas = *r.Replicas
_, err = c.AppsV1().StatefulSets(r.Namespace).UpdateScale(ctx, r.Name, s, metav1.UpdateOptions{})
return err
})
return "scaled to " + strconv.Itoa(int(*r.Replicas)), err
}
// runCronJob creates a Job from the CronJob's template, as kubectl create
// job --from=cronjob/<name> does. The name ends in digits, so the map and
// Hubble both attribute its pods to the CronJob.
func runCronJob(ctx context.Context, c kubernetes.Interface, r Request, now time.Time) (string, error) {
cj, err := c.BatchV1().CronJobs(r.Namespace).Get(ctx, r.Name, metav1.GetOptions{})
if err != nil {
return "", err
}
base := cj.Name
if len(base) > 52 { // Job names end up in a 63-character label
base = base[:52]
}
annotations := map[string]string{"cronjob.kubernetes.io/instantiate": "manual"}
for k, v := range cj.Spec.JobTemplate.Annotations {
annotations[k] = v
}
job := &batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: base + "-" + strconv.FormatInt(now.Unix(), 10),
Namespace: cj.Namespace,
Labels: cj.Spec.JobTemplate.Labels,
Annotations: annotations,
OwnerReferences: []metav1.OwnerReference{*metav1.NewControllerRef(cj, batchv1.SchemeGroupVersion.WithKind("CronJob"))},
},
Spec: cj.Spec.JobTemplate.Spec,
}
created, err := c.BatchV1().Jobs(r.Namespace).Create(ctx, job, metav1.CreateOptions{})
if err != nil {
return "", err
}
return "job " + created.Name + " created", nil
}
@@ -0,0 +1,133 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package actions
import (
"context"
"strings"
"testing"
"time"
appsv1 "k8s.io/api/apps/v1"
autoscalingv1 "k8s.io/api/autoscaling/v1"
batchv1 "k8s.io/api/batch/v1"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/kubernetes/fake"
k8stesting "k8s.io/client-go/testing"
)
var t0 = time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC)
func TestRestartSuspendCordon(t *testing.T) {
c := fake.NewSimpleClientset(
&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "web", Namespace: "shop"}},
&batchv1.CronJob{ObjectMeta: metav1.ObjectMeta{Name: "backup", Namespace: "shop"}},
&corev1.Node{ObjectMeta: metav1.ObjectMeta{Name: "node-a"}},
)
ctx := context.Background()
if _, err := Do(ctx, c, Request{Action: Restart, Kind: "deployment", Namespace: "shop", Name: "web"}, t0); err != nil {
t.Fatal(err)
}
d, _ := c.AppsV1().Deployments("shop").Get(ctx, "web", metav1.GetOptions{})
if d.Spec.Template.Annotations["kubectl.kubernetes.io/restartedAt"] != "2026-09-24T12:00:00Z" {
t.Errorf("restart annotation: %v", d.Spec.Template.Annotations)
}
if msg, err := Do(ctx, c, Request{Action: Suspend, Kind: "cronjob", Namespace: "shop", Name: "backup"}, t0); err != nil || msg != "suspended" {
t.Fatal(msg, err)
}
cj, _ := c.BatchV1().CronJobs("shop").Get(ctx, "backup", metav1.GetOptions{})
if cj.Spec.Suspend == nil || !*cj.Spec.Suspend {
t.Error("cronjob not suspended")
}
if _, err := Do(ctx, c, Request{Action: Cordon, Kind: "node", Name: "node-a"}, t0); err != nil {
t.Fatal(err)
}
n, _ := c.CoreV1().Nodes().Get(ctx, "node-a", metav1.GetOptions{})
if !n.Spec.Unschedulable {
t.Error("node not cordoned")
}
}
func TestRunCronJob(t *testing.T) {
c := fake.NewSimpleClientset(&batchv1.CronJob{
ObjectMeta: metav1.ObjectMeta{Name: "backup", Namespace: "shop", UID: "u1"},
Spec: batchv1.CronJobSpec{JobTemplate: batchv1.JobTemplateSpec{
ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"app": "backup"}},
Spec: batchv1.JobSpec{Template: corev1.PodTemplateSpec{Spec: corev1.PodSpec{Containers: []corev1.Container{{Name: "dump"}}}}},
}},
})
ctx := context.Background()
msg, err := Do(ctx, c, Request{Action: Run, Kind: "cronjob", Namespace: "shop", Name: "backup"}, t0)
if err != nil {
t.Fatal(err)
}
jobs, _ := c.BatchV1().Jobs("shop").List(ctx, metav1.ListOptions{})
if len(jobs.Items) != 1 || !strings.Contains(msg, jobs.Items[0].Name) {
t.Fatalf("jobs: %+v, msg %q", jobs.Items, msg)
}
j := jobs.Items[0]
if j.Name != "backup-1790251200" || j.OwnerReferences[0].Kind != "CronJob" || j.OwnerReferences[0].UID != "u1" ||
j.Annotations["cronjob.kubernetes.io/instantiate"] != "manual" || j.Labels["app"] != "backup" {
t.Errorf("job: %+v", j.ObjectMeta)
}
}
func TestScaleRetriesConflict(t *testing.T) {
c := fake.NewSimpleClientset()
var updated int32 = -1
attempts := 0
c.PrependReactor("get", "deployments", func(k8stesting.Action) (bool, runtime.Object, error) {
return true, &autoscalingv1.Scale{ObjectMeta: metav1.ObjectMeta{Name: "web", Namespace: "shop"}, Spec: autoscalingv1.ScaleSpec{Replicas: 1}}, nil
})
c.PrependReactor("update", "deployments", func(a k8stesting.Action) (bool, runtime.Object, error) {
attempts++
if attempts == 1 { // the controller got there first
return true, nil, apierrors.NewConflict(schema.GroupResource{Group: "apps", Resource: "deployments"}, "web", nil)
}
s := a.(k8stesting.UpdateAction).GetObject().(*autoscalingv1.Scale)
updated = s.Spec.Replicas
return true, s, nil
})
three := int32(3)
if _, err := Do(context.Background(), c, Request{Action: Scale, Kind: "deployment", Namespace: "shop", Name: "web", Replicas: &three}, t0); err != nil {
t.Fatal(err)
}
if updated != 3 || attempts != 2 {
t.Errorf("scale sent %d after %d attempts", updated, attempts)
}
tooMany := int32(MaxReplicas + 1)
if _, err := Do(context.Background(), c, Request{Action: Scale, Kind: "deployment", Namespace: "shop", Name: "web", Replicas: &tooMany}, t0); err == nil {
t.Error("replicas above the limit accepted")
}
}
func TestUnsupported(t *testing.T) {
c := fake.NewSimpleClientset()
for _, r := range []Request{
{Action: Scale, Kind: "daemonset", Namespace: "a", Name: "b"},
{Action: "exec", Kind: "pod", Namespace: "a", Name: "b"},
{Action: DeletePod, Kind: "pod", Name: "b"},
} {
if _, err := Do(context.Background(), c, r, t0); err == nil {
t.Errorf("%+v accepted", r)
}
}
}
@@ -57,6 +57,11 @@ type Config struct {
// Namespaces matching these prefixes/names are grouped as "system".
SystemNamespacePrefixes []string
LogTailLines int64
// ActionsEnabled turns on restart/scale/delete and the rest. They run
// with the viewer's own token (the Authorization header the
// DexAuthenticator adds), never with the module's service account.
ActionsEnabled bool
}
// Load reads and validates the configuration from the environment.
@@ -83,6 +88,9 @@ func Load() (Config, error) {
if c.LogTailLines, err = strconv.ParseInt(env("LOG_TAIL_LINES", "500"), 10, 64); err != nil {
return c, fmt.Errorf("LOG_TAIL_LINES: %w", err)
}
if c.ActionsEnabled, err = strconv.ParseBool(env("ACTIONS_ENABLED", "false")); err != nil {
return c, fmt.Errorf("ACTIONS_ENABLED: %w", err)
}
switch c.TrafficMode {
case TrafficContinuous, TrafficOnDemand, TrafficDisabled:
default:
+93 -9
View File
@@ -21,22 +21,41 @@ package kube
import (
"context"
"fmt"
"log/slog"
"time"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/dynamic/dynamicinformer"
"k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes"
appslisters "k8s.io/client-go/listers/apps/v1"
batchlisters "k8s.io/client-go/listers/batch/v1"
corelisters "k8s.io/client-go/listers/core/v1"
netlisters "k8s.io/client-go/listers/networking/v1"
"k8s.io/client-go/tools/cache"
)
// ClusterAlerts is the resource Deckhouse's prometheus module mirrors
// firing Alertmanager alerts into.
var ClusterAlerts = schema.GroupVersionResource{Group: "deckhouse.io", Version: "v1alpha1", Resource: "clusteralerts"}
// Cache holds synced listers plus a client for reads that must be live
// (YAML view, logs).
type Cache struct {
Client kubernetes.Interface
Client kubernetes.Interface
// Events holds Warning events only; Normal ones are most of the event
// volume and none of them is a problem.
Events corelisters.EventLister
// Alerts is nil when the ClusterAlert resource is not served (the
// prometheus module is off).
Alerts cache.GenericLister
Namespaces corelisters.NamespaceLister
Pods corelisters.PodLister
Services corelisters.ServiceLister
@@ -48,16 +67,24 @@ type Cache struct {
Ingresses netlisters.IngressLister
}
// stripManagedFields: managedFields is most of a cached object's size and
// nothing here reads it.
func stripManagedFields(obj any) (any, error) {
if a, err := meta.Accessor(obj); err == nil {
a.SetManagedFields(nil)
}
return obj, nil
}
// Start runs the informers and blocks until every cache has synced or ctx
// is done.
func Start(ctx context.Context, client kubernetes.Interface, syncTimeout time.Duration) (*Cache, error) {
f := informers.NewSharedInformerFactoryWithOptions(client, 0,
// managedFields is most of a cached object's size and nothing here reads it
informers.WithTransform(func(obj any) (any, error) {
if a, err := meta.Accessor(obj); err == nil {
a.SetManagedFields(nil)
}
return obj, nil
func Start(ctx context.Context, client kubernetes.Interface, dyn dynamic.Interface, syncTimeout time.Duration) (*Cache, error) {
f := informers.NewSharedInformerFactoryWithOptions(client, 0, informers.WithTransform(stripManagedFields))
// A separate factory: a list option tweak applies to every informer of
// the factory it is set on.
ef := informers.NewSharedInformerFactoryWithOptions(client, 0, informers.WithTransform(stripManagedFields),
informers.WithTweakListOptions(func(o *metav1.ListOptions) {
o.FieldSelector = fields.OneTermEqualSelector("type", corev1.EventTypeWarning).String()
}))
c := &Cache{
Client: client,
@@ -70,8 +97,20 @@ func Start(ctx context.Context, client kubernetes.Interface, syncTimeout time.Du
DaemonSets: f.Apps().V1().DaemonSets().Lister(),
CronJobs: f.Batch().V1().CronJobs().Lister(),
Ingresses: f.Networking().V1().Ingresses().Lister(),
Events: ef.Core().V1().Events().Lister(),
}
var df dynamicinformer.DynamicSharedInformerFactory
if dyn != nil && served(client, ClusterAlerts) {
df = dynamicinformer.NewDynamicSharedInformerFactory(dyn, 0)
c.Alerts = df.ForResource(ClusterAlerts).Lister()
} else {
slog.Info("ClusterAlert resource is not served; alerts are not shown")
}
f.Start(ctx.Done())
ef.Start(ctx.Done())
if df != nil {
df.Start(ctx.Done())
}
syncCtx, cancel := context.WithTimeout(ctx, syncTimeout)
defer cancel()
@@ -80,9 +119,54 @@ func Start(ctx context.Context, client kubernetes.Interface, syncTimeout time.Du
return nil, fmt.Errorf("cache for %v did not sync within %s", t, syncTimeout)
}
}
for t, ok := range ef.WaitForCacheSync(syncCtx.Done()) {
if !ok {
return nil, fmt.Errorf("cache for %v did not sync within %s", t, syncTimeout)
}
}
if df != nil {
for r, ok := range df.WaitForCacheSync(syncCtx.Done()) {
if !ok {
return nil, fmt.Errorf("cache for %v did not sync within %s", r, syncTimeout)
}
}
}
return c, nil
}
// served reports whether the API server serves the resource, so an
// informer is not started for a CRD that is not installed.
func served(client kubernetes.Interface, gvr schema.GroupVersionResource) bool {
list, err := client.Discovery().ServerResourcesForGroupVersion(gvr.GroupVersion().String())
if err != nil {
return false
}
for _, r := range list.APIResources {
if r.Name == gvr.Resource {
return true
}
}
return false
}
// AlertList returns the cached ClusterAlerts, or nil when they are off.
func (c *Cache) AlertList() []*unstructured.Unstructured {
if c.Alerts == nil {
return nil
}
objs, err := c.Alerts.List(labels.Everything())
if err != nil {
return nil
}
out := make([]*unstructured.Unstructured, 0, len(objs))
for _, o := range objs {
if u, ok := o.(*unstructured.Unstructured); ok {
out = append(out, u)
}
}
return out
}
// List reads a lister as values. Callers must not mutate cached objects,
// and copying the top-level struct is cheap.
func List[T any](l interface {
@@ -37,6 +37,9 @@ var (
HTTPRequests = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "cluster_map_http_requests_total", Help: "HTTP API requests by handler and status code.",
}, []string{"handler", "code"})
Actions = prometheus.NewCounterVec(prometheus.CounterOpts{
Name: "cluster_map_actions_total", Help: "Actions run from the UI, by action and result (ok, denied, error).",
}, []string{"action", "result"})
HTTPDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
Name: "cluster_map_http_request_duration_seconds", Help: "HTTP API latency by handler.",
Buckets: []float64{.001, .005, .01, .05, .1, .5, 1, 5},
@@ -48,7 +51,7 @@ func init() {
collectors.NewGoCollector(),
collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
HubbleStreamActive, HubbleConnected, HubbleReconnects, FlowsProcessed, TrackedTuples, CacheSynced,
HTTPRequests, HTTPDuration,
HTTPRequests, HTTPDuration, Actions,
)
}
@@ -0,0 +1,172 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package server
import (
"encoding/json"
"errors"
"log/slog"
"mime"
"net/http"
"net/url"
"strings"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/client-go/kubernetes"
"git.project-chimera.ru/fanchji/cluster-map/internal/actions"
"git.project-chimera.ru/fanchji/cluster-map/internal/metrics"
)
// viewerToken is the bearer token the DexAuthenticator forwarded, or "".
func viewerToken(r *http.Request) string {
h := r.Header.Get("Authorization")
if len(h) > 7 && strings.EqualFold(h[:7], "Bearer ") {
return strings.TrimSpace(h[7:])
}
return ""
}
// viewerClient returns a client acting as the viewer, or writes the reason
// there is none.
func (s *Server) viewerClient(w http.ResponseWriter, r *http.Request) (kubernetes.Interface, bool) {
if !s.cfg.ActionsEnabled || s.asViewer == nil {
http.Error(w, "actions are disabled in the module settings", http.StatusNotFound)
return nil, false
}
token := viewerToken(r)
if token == "" {
http.Error(w, "no user token in the request: actions need the DexAuthenticator to send the Authorization header", http.StatusUnauthorized)
return nil, false
}
c, err := s.asViewer(token)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return nil, false
}
return c, true
}
// Me is the /api/me response.
type Me struct {
ActionsEnabled bool `json:"actionsEnabled"`
User string `json:"user,omitempty"`
Reason string `json:"reason,omitempty"` // why actions are unavailable: disabled | noToken | rejected
}
func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
me := Me{ActionsEnabled: s.cfg.ActionsEnabled && s.asViewer != nil}
token := viewerToken(r)
switch {
case !me.ActionsEnabled:
me.Reason = "disabled"
case token == "":
me.Reason = "noToken"
default:
c, err := s.asViewer(token)
if err == nil {
me.User, err = actions.WhoAmI(r.Context(), c)
}
if err != nil {
slog.Info("viewer token rejected", "err", err)
me.Reason = "rejected"
}
}
writeJSON(w, me)
}
func (s *Server) handlePermissions(w http.ResponseWriter, r *http.Request) {
c, ok := s.viewerClient(w, r)
if !ok {
return
}
q := r.URL.Query()
allowed, err := actions.Allowed(r.Context(), c, q.Get("kind"), q.Get("namespace"), q.Get("name"))
if err != nil {
http.Error(w, err.Error(), apiStatus(err))
return
}
writeJSON(w, map[string]any{"allowed": allowed})
}
// sameOrigin rejects cross-site writes: the Fetch metadata header that
// every current browser sends, then Origin for older ones. A JSON content
// type also keeps a plain HTML form from reaching the handler.
func sameOrigin(r *http.Request) error {
if ct, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type")); ct != "application/json" {
return errors.New("content type must be application/json")
}
switch r.Header.Get("Sec-Fetch-Site") {
case "", "same-origin":
default:
return errors.New("cross-site request")
}
if o := r.Header.Get("Origin"); o != "" {
u, err := url.Parse(o)
if err != nil || u.Host != r.Host {
return errors.New("origin does not match the host")
}
}
return nil
}
func (s *Server) handleAction(w http.ResponseWriter, r *http.Request) {
if err := sameOrigin(r); err != nil {
http.Error(w, err.Error(), http.StatusForbidden)
return
}
c, ok := s.viewerClient(w, r)
if !ok {
return
}
var req actions.Request
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4096)).Decode(&req); err != nil {
http.Error(w, "bad request body: "+err.Error(), http.StatusBadRequest)
return
}
user, err := actions.WhoAmI(r.Context(), c)
if err != nil {
http.Error(w, "the API server did not accept the user token: "+err.Error(), http.StatusUnauthorized)
return
}
msg, err := actions.Do(r.Context(), c, req, time.Now())
// The API server's audit log has the same record under the user's name;
// this one ties it to the map.
log := slog.With("user", user, "action", req.Action, "target", req.String())
switch {
case err == nil:
log.Info("action done", "result", msg)
metrics.Actions.WithLabelValues(req.Action, "ok").Inc()
writeJSON(w, map[string]string{"result": msg})
case errors.Is(err, actions.ErrUnsupported):
http.Error(w, err.Error(), http.StatusBadRequest)
case apierrors.IsForbidden(err):
log.Info("action denied", "err", err)
metrics.Actions.WithLabelValues(req.Action, "denied").Inc()
http.Error(w, err.Error(), http.StatusForbidden)
default:
log.Warn("action failed", "err", err)
metrics.Actions.WithLabelValues(req.Action, "error").Inc()
code := http.StatusBadRequest // Do's own validation errors
var st apierrors.APIStatus
if errors.As(err, &st) && st.Status().Code != 0 {
code = int(st.Status().Code)
}
http.Error(w, err.Error(), code)
}
}
@@ -0,0 +1,152 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package server
import (
"net/http"
"net/http/httptest"
"strings"
"testing"
"testing/fstest"
"time"
appsv1 "k8s.io/api/apps/v1"
authnv1 "k8s.io/api/authentication/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/fake"
k8stesting "k8s.io/client-go/testing"
"git.project-chimera.ru/fanchji/cluster-map/internal/config"
)
// actionServer: tokens are checked by the fake "API server": "good" is
// alice, anything else is rejected; alice may patch deployments only.
func actionServer(t *testing.T, enabled bool) (http.Handler, *fake.Clientset) {
t.Helper()
c := fake.NewSimpleClientset(&appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: "web", Namespace: "shop"}})
c.PrependReactor("create", "selfsubjectreviews", func(k8stesting.Action) (bool, runtime.Object, error) {
return true, &authnv1.SelfSubjectReview{Status: authnv1.SelfSubjectReviewStatus{UserInfo: authnv1.UserInfo{Username: "alice@example.com"}}}, nil
})
c.PrependReactor("patch", "nodes", func(k8stesting.Action) (bool, runtime.Object, error) {
return true, nil, apierrors.NewForbidden(schema.GroupResource{Resource: "nodes"}, "node-a", nil)
})
factory := func(token string) (kubernetes.Interface, error) {
if token != "good" {
return fake.NewSimpleClientset(), nil
}
return c, nil
}
cfg := config.Config{TrafficMode: config.TrafficDisabled, Retention: time.Hour, ActionsEnabled: enabled}
s := New(cfg, fstest.MapFS{"index.html": {Data: []byte("x")}}, factory)
s.ready.Store(true)
return s.Handler(), c
}
func post(h http.Handler, body string, headers map[string]string) *httptest.ResponseRecorder {
req := httptest.NewRequest(http.MethodPost, "http://cluster-map.example.com/api/action", strings.NewReader(body))
req.Header.Set("Content-Type", "application/json")
for k, v := range headers {
req.Header.Set(k, v)
}
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
return rec
}
const restartWeb = `{"action":"restart","kind":"deployment","namespace":"shop","name":"web"}`
func TestActionRunsAsViewer(t *testing.T) {
h, c := actionServer(t, true)
rec := post(h, restartWeb, map[string]string{"Authorization": "Bearer good", "Sec-Fetch-Site": "same-origin", "Origin": "http://cluster-map.example.com"})
if rec.Code != http.StatusOK {
t.Fatalf("%d %s", rec.Code, rec.Body)
}
var patched bool
for _, a := range c.Actions() {
if a.GetVerb() == "patch" && a.GetResource().Resource == "deployments" {
patched = true
}
}
if !patched {
t.Error("the viewer's client did not patch the deployment")
}
}
func TestActionGuards(t *testing.T) {
h, _ := actionServer(t, true)
cases := []struct {
name string
body string
headers map[string]string
want int
}{
{"no token", restartWeb, map[string]string{"Sec-Fetch-Site": "same-origin"}, http.StatusUnauthorized},
{"cross-site", restartWeb, map[string]string{"Authorization": "Bearer good", "Sec-Fetch-Site": "cross-site"}, http.StatusForbidden},
{"foreign origin", restartWeb, map[string]string{"Authorization": "Bearer good", "Origin": "https://evil.example.org"}, http.StatusForbidden},
{"form post", restartWeb, map[string]string{"Authorization": "Bearer good", "Content-Type": "application/x-www-form-urlencoded"}, http.StatusForbidden},
{"api forbids", `{"action":"cordon","kind":"node","name":"node-a"}`, map[string]string{"Authorization": "Bearer good"}, http.StatusForbidden},
{"unsupported", `{"action":"scale","kind":"daemonset","namespace":"shop","name":"x","replicas":1}`, map[string]string{"Authorization": "Bearer good"}, http.StatusBadRequest},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
if rec := post(h, c.body, c.headers); rec.Code != c.want {
t.Errorf("got %d (%s), want %d", rec.Code, strings.TrimSpace(rec.Body.String()), c.want)
}
})
}
off, _ := actionServer(t, false)
if rec := post(off, restartWeb, map[string]string{"Authorization": "Bearer good"}); rec.Code != http.StatusNotFound {
t.Errorf("actions disabled: %d", rec.Code)
}
}
func TestMe(t *testing.T) {
h, _ := actionServer(t, true)
req := httptest.NewRequest(http.MethodGet, "/api/me", nil)
req.Header.Set("Authorization", "Bearer good")
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
if !strings.Contains(rec.Body.String(), `"user":"alice@example.com"`) {
t.Errorf("me: %s", rec.Body)
}
if body := get(h, "/api/me").Body.String(); !strings.Contains(body, `"reason":"noToken"`) {
t.Errorf("me without a token: %s", body)
}
}
func TestStaticRevalidation(t *testing.T) {
_, h := newServer(t, config.TrafficDisabled)
first := get(h, "/")
tag := first.Header().Get("ETag")
if tag == "" || first.Header().Get("Cache-Control") != "no-cache" {
t.Fatalf("static headers: %v", first.Header())
}
req := httptest.NewRequest(http.MethodGet, "/", nil)
req.Header.Set("If-None-Match", tag)
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
if rec.Code != http.StatusNotModified {
t.Errorf("revalidation: %d", rec.Code)
}
if get(h, "/api/graph").Header().Get("Cache-Control") != "no-store" {
t.Error("API responses must stay no-store")
}
}
@@ -0,0 +1,314 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package server
import (
"context"
"encoding/json"
"net/http"
"sort"
"strings"
"time"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields"
"git.project-chimera.ru/fanchji/cluster-map/internal/kube"
"git.project-chimera.ru/fanchji/cluster-map/internal/topology"
)
// EventInfo is one row of the Events tab.
type EventInfo struct {
Type string `json:"type"`
Reason string `json:"reason"`
Message string `json:"message"`
Object string `json:"object"` // Kind/name of what the event is about
Count int32 `json:"count"`
Last string `json:"last"`
}
const maxEvents = 100
// handleEvents lists recent events of a card: for a workload also those of
// its pods and ReplicaSets, which is where Kubernetes reports most of what
// goes wrong with it. Read live, all types, not from the Warning cache.
func (s *Server) handleEvents(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("id")
parts := strings.Split(id, "/")
ctx := r.Context()
var list *corev1.EventList
var err error
match := func(corev1.ObjectReference) bool { return true }
switch {
case len(parts) == 2 && parts[0] == "node":
list, err = s.cache.Client.CoreV1().Events("").List(ctx, metav1.ListOptions{FieldSelector: fields.Set{
"involvedObject.kind": "Node", "involvedObject.name": parts[1]}.String()})
case len(parts) == 2 && parts[0] == "ns":
list, err = s.cache.Client.CoreV1().Events(parts[1]).List(ctx, metav1.ListOptions{Limit: 500})
case len(parts) == 3 && (parts[0] == "service" || parts[0] == "ingress"):
kind := map[string]string{"service": "Service", "ingress": "Ingress"}[parts[0]]
list, err = s.cache.Client.CoreV1().Events(parts[1]).List(ctx, metav1.ListOptions{FieldSelector: fields.Set{
"involvedObject.kind": kind, "involvedObject.name": parts[2]}.String()})
case len(parts) == 4 && parts[0] == "wl":
ns, name := parts[1], parts[3]
owners := s.podOwners(ns)
match = func(ref corev1.ObjectReference) bool {
if topology.EventTargetID(ref, owners) == id {
return true
}
// a pod already gone is no longer in the cache; its name still tells
return ref.Kind == "Pod" && owners[ns+"/"+ref.Name] == "" && strings.HasPrefix(ref.Name, name+"-")
}
list, err = s.cache.Client.CoreV1().Events(ns).List(ctx, metav1.ListOptions{Limit: 500})
default:
http.Error(w, "id must be a card id (wl/…, service/…, ingress/…, node/…, ns/…)", http.StatusBadRequest)
return
}
if err != nil {
http.Error(w, err.Error(), apiStatus(err))
return
}
out := []EventInfo{}
for _, e := range list.Items {
if !match(e.InvolvedObject) {
continue
}
count := e.Count
if e.Series != nil {
count = e.Series.Count
}
out = append(out, EventInfo{
Type: e.Type, Reason: e.Reason, Message: e.Message, Count: max(count, 1),
Object: e.InvolvedObject.Kind + "/" + e.InvolvedObject.Name, Last: lastSeen(e).UTC().Format(time.RFC3339),
})
}
sort.Slice(out, func(i, j int) bool { return out[i].Last > out[j].Last })
if len(out) > maxEvents {
out = out[:maxEvents]
}
writeJSON(w, out)
}
func lastSeen(e corev1.Event) time.Time {
switch {
case e.Series != nil && !e.Series.LastObservedTime.IsZero():
return e.Series.LastObservedTime.Time
case !e.LastTimestamp.IsZero():
return e.LastTimestamp.Time
case !e.EventTime.IsZero():
return e.EventTime.Time
}
return e.CreationTimestamp.Time
}
func (s *Server) podOwners(ns string) map[string]string {
pods, _ := kube.List[corev1.Pod](s.cache.Pods.Pods(ns))
out := make(map[string]string, len(pods))
for _, p := range pods {
out[ns+"/"+p.Name] = topology.OwnerWorkloadID(p)
}
return out
}
// Amount is a CPU (millicores) or memory (bytes) figure; nil when unknown.
type Amount struct {
Usage *int64 `json:"usage"`
Request int64 `json:"request"`
Limit int64 `json:"limit"` // 0 when any container has no limit
Capacity int64 `json:"capacity"` // allocatable, nodes only
}
// PodUsage is one pod in the usage table.
type PodUsage struct {
Name string `json:"name"`
Node string `json:"node"`
Ready bool `json:"ready"`
Restarts int32 `json:"restarts"`
CPU *int64 `json:"cpu"`
Memory *int64 `json:"memory"`
}
// Usage is the /api/usage response.
type Usage struct {
Metrics bool `json:"metrics"` // false when metrics.k8s.io did not answer
CPU Amount `json:"cpu"`
Memory Amount `json:"memory"`
Pods []PodUsage `json:"pods"`
}
// metricsList is the part of a metrics.k8s.io PodMetricsList read here.
type metricsList struct {
Items []struct {
Metadata metav1.ObjectMeta `json:"metadata"`
Containers []struct {
Usage corev1.ResourceList `json:"usage"`
} `json:"containers"`
} `json:"items"`
}
type nodeMetrics struct {
Usage corev1.ResourceList `json:"usage"`
}
// metricsGet reads the resource metrics API through the discovery REST
// client, which spares a dependency on k8s.io/metrics for two GETs.
func (s *Server) metricsGet(ctx context.Context, into any, path ...string) bool {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
raw, err := s.cache.Client.Discovery().RESTClient().Get().AbsPath(append([]string{"/apis/metrics.k8s.io/v1beta1"}, path...)...).DoRaw(ctx)
if err != nil {
return false
}
return json.Unmarshal(raw, into) == nil
}
func ptr(v int64) *int64 { return &v }
// handleUsage: CPU and memory of a workload (sum over its pods) or a node,
// against requests, limits and, for a node, allocatable.
func (s *Server) handleUsage(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("id")
parts := strings.Split(id, "/")
var pods []corev1.Pod
u := Usage{Pods: []PodUsage{}}
switch {
case len(parts) == 4 && parts[0] == "wl":
all, err := kube.List[corev1.Pod](s.cache.Pods.Pods(parts[1]))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
for _, p := range all {
if topology.OwnerWorkloadID(p) == id {
pods = append(pods, p)
}
}
case len(parts) == 2 && parts[0] == "node":
n, err := s.cache.Nodes.Get(parts[1])
if err != nil {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
u.CPU.Capacity = n.Status.Allocatable.Cpu().MilliValue()
u.Memory.Capacity = n.Status.Allocatable.Memory().Value()
all, _ := kube.List[corev1.Pod](s.cache.Pods)
for _, p := range all {
if p.Spec.NodeName == parts[1] {
pods = append(pods, p)
}
}
var nm nodeMetrics
if s.metricsGet(r.Context(), &nm, "nodes", parts[1]) {
u.Metrics = true
u.CPU.Usage, u.Memory.Usage = ptr(nm.Usage.Cpu().MilliValue()), ptr(nm.Usage.Memory().Value())
}
default:
http.Error(w, "id must be a workload (wl/…) or a node (node/…)", http.StatusBadRequest)
return
}
live := pods[:0]
for _, p := range pods {
if p.Status.Phase != corev1.PodSucceeded && p.Status.Phase != corev1.PodFailed {
live = append(live, p)
}
}
cpuReq, cpuLim, memReq, memLim, noCPULimit, noMemLimit := requests(live)
u.CPU.Request, u.Memory.Request = cpuReq, memReq
if !noCPULimit {
u.CPU.Limit = cpuLim
}
if !noMemLimit {
u.Memory.Limit = memLim
}
workload := parts[0] == "wl"
var ml metricsList
byPod := map[string][2]int64{}
if workload && s.metricsGet(r.Context(), &ml, "namespaces", parts[1], "pods") {
u.Metrics = true
for _, it := range ml.Items {
var cpu, mem int64
for _, c := range it.Containers {
cpu += c.Usage.Cpu().MilliValue()
mem += c.Usage.Memory().Value()
}
byPod[it.Metadata.Name] = [2]int64{cpu, mem}
}
var cpu, mem int64
for _, p := range live {
cpu += byPod[p.Name][0]
mem += byPod[p.Name][1]
}
u.CPU.Usage, u.Memory.Usage = ptr(cpu), ptr(mem)
}
if workload {
for _, p := range live {
row := PodUsage{Name: p.Name, Node: p.Spec.NodeName, Ready: isReady(p)}
for _, cs := range p.Status.ContainerStatuses {
row.Restarts += cs.RestartCount
}
if v, ok := byPod[p.Name]; ok {
row.CPU, row.Memory = ptr(v[0]), ptr(v[1])
}
u.Pods = append(u.Pods, row)
}
sort.Slice(u.Pods, func(i, j int) bool { return u.Pods[i].Name < u.Pods[j].Name })
}
writeJSON(w, u)
}
// requests sums the regular containers' requests and limits. A limit sum
// only means something when every container has one.
func requests(pods []corev1.Pod) (cpuReq, cpuLim, memReq, memLim int64, noCPULimit, noMemLimit bool) {
for _, p := range pods {
for _, c := range p.Spec.Containers {
cpuReq += qty(c.Resources.Requests, corev1.ResourceCPU, true)
memReq += qty(c.Resources.Requests, corev1.ResourceMemory, false)
if _, ok := c.Resources.Limits[corev1.ResourceCPU]; !ok {
noCPULimit = true
}
if _, ok := c.Resources.Limits[corev1.ResourceMemory]; !ok {
noMemLimit = true
}
cpuLim += qty(c.Resources.Limits, corev1.ResourceCPU, true)
memLim += qty(c.Resources.Limits, corev1.ResourceMemory, false)
}
}
return
}
func qty(l corev1.ResourceList, name corev1.ResourceName, milli bool) int64 {
q, ok := l[name]
if !ok {
return 0
}
if milli {
return q.MilliValue()
}
return q.Value()
}
func isReady(p corev1.Pod) bool {
for _, c := range p.Status.Conditions {
if c.Type == corev1.PodReady {
return c.Status == corev1.ConditionTrue
}
}
return false
}
@@ -18,6 +18,8 @@ limitations under the License.
package server
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"io"
@@ -35,6 +37,7 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/yaml"
"git.project-chimera.ru/fanchji/cluster-map/internal/actions"
"git.project-chimera.ru/fanchji/cluster-map/internal/config"
"git.project-chimera.ru/fanchji/cluster-map/internal/kube"
"git.project-chimera.ru/fanchji/cluster-map/internal/metrics"
@@ -44,16 +47,56 @@ import (
// Server serves the JSON API and the embedded frontend.
type Server struct {
cfg config.Config
cache *kube.Cache
traffic *traffic.Collector
static fs.FS
ready atomic.Bool
cfg config.Config
cache *kube.Cache
traffic *traffic.Collector
static fs.FS
etags map[string]string
asViewer actions.ClientFactory // nil when actions are off
ready atomic.Bool
}
// New returns a server that answers 503 on the API until SetReady.
func New(cfg config.Config, static fs.FS) *Server {
return &Server{cfg: cfg, static: static}
// asViewer builds clients from the viewer's token; nil disables actions.
func New(cfg config.Config, static fs.FS, asViewer actions.ClientFactory) *Server {
return &Server{cfg: cfg, static: static, etags: etags(static), asViewer: asViewer}
}
// etags hashes the embedded files once: they cannot change while the
// process runs, so a browser revalidates with If-None-Match and gets a 304
// instead of the 2 MB of vendored scripts on every visit.
func etags(static fs.FS) map[string]string {
out := map[string]string{}
_ = fs.WalkDir(static, ".", func(path string, d fs.DirEntry, err error) error {
if err != nil || d.IsDir() {
return err
}
b, err := fs.ReadFile(static, path)
if err != nil {
return err
}
sum := sha256.Sum256(b)
out["/"+path] = `"` + hex.EncodeToString(sum[:12]) + `"`
return nil
})
if v, ok := out["/index.html"]; ok {
out["/"] = v
}
return out
}
// staticHandler serves the embedded frontend with validators. Everything
// is revalidated on each load (no-cache), so a new release shows up on the
// next reload without versioned file names.
func (s *Server) staticHandler() http.Handler {
files := http.FileServerFS(s.static)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if tag, ok := s.etags[r.URL.Path]; ok {
w.Header().Set("ETag", tag)
w.Header().Set("Cache-Control", "no-cache")
}
files.ServeHTTP(w, r)
})
}
// SetReady is called once the caches have synced; until then API calls
@@ -79,7 +122,12 @@ func (s *Server) Handler() http.Handler {
mux.Handle("GET /api/resource", s.api("resource", s.handleResource))
mux.Handle("GET /api/pods", s.api("pods", s.handlePods))
mux.Handle("GET /api/logs", s.api("logs", s.handleLogs))
mux.Handle("GET /", http.FileServerFS(s.static))
mux.Handle("GET /api/events", s.api("events", s.handleEvents))
mux.Handle("GET /api/usage", s.api("usage", s.handleUsage))
mux.Handle("GET /api/me", s.api("me", s.handleMe))
mux.Handle("GET /api/permissions", s.api("permissions", s.handlePermissions))
mux.Handle("POST /api/action", s.api("action", s.handleAction))
mux.Handle("GET /", s.staticHandler())
return securityHeaders(mux)
}
@@ -38,7 +38,7 @@ import (
func newServer(t *testing.T, mode config.TrafficMode) (*Server, http.Handler) {
t.Helper()
cfg := config.Config{TrafficMode: mode, Retention: time.Hour, LogTailLines: 10, SystemNamespacePrefixes: []string{"d8-"}}
s := New(cfg, fstest.MapFS{"index.html": {Data: []byte("<!doctype html>")}})
s := New(cfg, fstest.MapFS{"index.html": {Data: []byte("<!doctype html>")}}, nil)
return s, s.Handler()
}
@@ -84,7 +84,7 @@ func TestPodsAndFlows(t *testing.T) {
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
cache, err := kube.Start(ctx, client, 10*time.Second)
cache, err := kube.Start(ctx, client, nil, 10*time.Second)
if err != nil {
t.Fatal(err)
}
@@ -41,6 +41,7 @@ type Node struct {
Namespace string `json:"namespace"` // empty for namespace and node
Parent string `json:"parent,omitempty"`
Facts map[string]string `json:"facts,omitempty"` // short summary shown without a follow-up fetch
Problems []Problem `json:"problems,omitempty"`
}
// Edge is a configuration or placement link between two nodes.
@@ -55,6 +56,12 @@ type Edge struct {
type Graph struct {
Nodes []Node `json:"nodes"`
Edges []Edge `json:"edges"`
// ClusterProblems are problems no card owns: cluster-wide alerts and
// alerts about namespaces that no longer exist.
ClusterProblems []Problem `json:"clusterProblems"`
// AlertsAvailable is false when ClusterAlerts are not served, so the UI
// can say that alerts are not part of the picture.
AlertsAvailable bool `json:"alertsAvailable"`
}
// WorkloadID is the graph ID of a workload. Traffic endpoints use the same
@@ -163,6 +170,16 @@ func Build(c *kube.Cache, isSystem func(string) bool) (*Graph, error) {
}
g.Edges = append(g.Edges, placementEdges(pods)...)
events, err := kube.List[corev1.Event](c.Events)
if err != nil {
return nil, err
}
attachProblems(g, problemInputs{
pods: pods, deployments: deployments, cronjobs: cronjobs,
services: services, ingresses: ingresses, nodes: hostNodes, events: events, alerts: c.AlertList(),
})
g.AlertsAvailable = c.Alerts != nil
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
@@ -462,5 +479,9 @@ func nodeFacts(n corev1.Node) map[string]string {
if ready != "True" {
h = "error"
}
return map[string]string{"ready": ready, "os": n.Status.NodeInfo.OSImage, "kubelet": n.Status.NodeInfo.KubeletVersion, "health": h}
f := map[string]string{"ready": ready, "os": n.Status.NodeInfo.OSImage, "kubelet": n.Status.NodeInfo.KubeletVersion, "health": h}
if n.Spec.Unschedulable {
f["unschedulable"] = "true"
}
return f
}
@@ -134,7 +134,7 @@ func TestBuildGraph(t *testing.T) {
)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
cache, err := kube.Start(ctx, client, 10*time.Second)
cache, err := kube.Start(ctx, client, nil, 10*time.Second)
if err != nil {
t.Fatal(err)
}
@@ -0,0 +1,509 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package topology
import (
"sort"
"strconv"
"strings"
"time"
appsv1 "k8s.io/api/apps/v1"
batchv1 "k8s.io/api/batch/v1"
corev1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)
// Severity of a problem, which is the colour of the badge on its card.
const (
Critical = "critical"
Warning = "warning"
Info = "info"
)
// Problem is one reason a card carries a badge. Reason is a stable code the
// UI translates (CrashLoopBackOff, NoEndpoints, an alert name); Message is
// the text Kubernetes or Alertmanager gave, shown as is.
type Problem struct {
Severity string `json:"severity"`
Source string `json:"source"` // alert | state | event
Reason string `json:"reason"`
Message string `json:"message,omitempty"`
Object string `json:"object,omitempty"` // the pod or container it was seen on, when not the card itself
Count int `json:"count,omitempty"` // events folded into this problem
Since string `json:"since,omitempty"` // RFC 3339
}
// Time windows: a restart or a warning event older than this no longer
// marks the card, so a problem fixed an hour ago does not stay red.
var (
now = time.Now
restartWindow = 30 * time.Minute
eventWindow = 30 * time.Minute
pendingAfter = 5 * time.Minute
notReadyAfter = 2 * time.Minute // a pod starting or restarting is not yet a problem
maxPerCard = 20
// Warning events that mark a card even when seen once. Any other reason
// (a failed readiness probe during a restart, say) needs eventRepeats
// occurrences in the window; below that it is listed, not badged.
eventNotable = map[string]bool{
"FailedScheduling": true, "FailedMount": true, "FailedAttachVolume": true, "FailedCreate": true,
"FailedCreatePodSandBox": true, "BackOff": true, "Evicted": true, "OOMKilling": true, "FailedKillPod": true,
"ProvisioningFailed": true, "FailedBinding": true, "NetworkNotReady": true, "SystemOOM": true,
}
eventRepeats = 5
waitingCritical = map[string]bool{
"CrashLoopBackOff": true, "ImagePullBackOff": true, "ErrImagePull": true, "InvalidImageName": true,
"CreateContainerConfigError": true, "CreateContainerError": true, "RunContainerError": true,
}
)
var severityRank = map[string]int{Critical: 3, Warning: 2, Info: 1}
// WorstSeverity is the severity of the most serious problem, empty for none.
func WorstSeverity(ps []Problem) string {
worst := ""
for _, p := range ps {
if severityRank[p.Severity] > severityRank[worst] {
worst = p.Severity
}
}
return worst
}
type problemSet struct {
byID map[string][]Problem
cluster []Problem
}
func (s *problemSet) add(id string, p Problem) {
if id == "" {
s.cluster = append(s.cluster, p)
return
}
s.byID[id] = append(s.byID[id], p)
}
type problemInputs struct {
pods []corev1.Pod
deployments []appsv1.Deployment
cronjobs []batchv1.CronJob
services []corev1.Service
ingresses []networkingv1.Ingress
nodes []corev1.Node
events []corev1.Event
alerts []*unstructured.Unstructured
}
// attachProblems fills Node.Problems and Graph.ClusterProblems. Problems
// for an ID the graph has no card for (a bare pod, a deleted object) go to
// the namespace card, and those without a namespace to the cluster list.
func attachProblems(g *Graph, in problemInputs) {
s := &problemSet{byID: map[string][]Problem{}}
podsByNs := map[string][]corev1.Pod{}
podOwner := map[string]string{} // ns/name -> workload ID
notReadySince := map[string]time.Time{} // workload ID -> the longest a pod of it has been not ready
for _, p := range in.pods {
podsByNs[p.Namespace] = append(podsByNs[p.Namespace], p)
id := OwnerWorkloadID(p)
podOwner[p.Namespace+"/"+p.Name] = id
if syntheticProbe(p.Namespace, p.Name) {
continue
}
podProblems(s, p)
if since, ok := notReadyFrom(p); ok && id != "" {
if old, seen := notReadySince[id]; !seen || since.Before(old) {
notReadySince[id] = since
}
}
}
for _, d := range in.deployments {
for _, c := range d.Status.Conditions {
if c.Type == appsv1.DeploymentProgressing && c.Status == corev1.ConditionFalse && c.Reason == "ProgressDeadlineExceeded" {
s.add(WorkloadID(d.Namespace, "deployment", d.Name), Problem{Severity: Critical, Source: "state", Reason: "ProgressDeadlineExceeded", Message: c.Message, Since: stamp(c.LastTransitionTime.Time)})
}
}
}
for _, cj := range in.cronjobs {
cronJobProblems(s, cj)
}
for _, svc := range in.services {
serviceProblems(s, svc, podsByNs[svc.Namespace])
}
services := map[string]bool{}
for _, svc := range in.services {
services[svc.Namespace+"/"+svc.Name] = true
}
for _, ing := range in.ingresses {
for _, name := range IngressBackendServices(ing) {
// Deckhouse's ingress-nginx points its config-reload Ingresses at a
// service that does not exist on purpose
if !services[ing.Namespace+"/"+name] && name != "fakeservice" {
s.add("ingress/"+ing.Namespace+"/"+ing.Name, Problem{Severity: Warning, Source: "state", Reason: "BackendMissing", Object: name})
}
}
}
for _, n := range in.nodes {
nodeProblems(s, n)
}
eventProblems(s, in.events, podOwner)
for _, n := range g.Nodes {
if !syntheticProbe(n.Namespace, n.Label) {
readinessProblem(s, n, notReadySince)
}
}
for _, a := range in.alerts {
alertProblem(s, a, podOwner)
}
known := make(map[string]int, len(g.Nodes))
for i, n := range g.Nodes {
known[n.ID] = i
}
for id, ps := range s.byID {
i, ok := known[id]
if !ok {
ns := namespaceOfID(id)
if i, ok = known["ns/"+ns]; !ok {
s.cluster = append(s.cluster, ps...)
continue
}
}
g.Nodes[i].Problems = append(g.Nodes[i].Problems, ps...)
}
for i := range g.Nodes {
g.Nodes[i].Problems = sortProblems(g.Nodes[i].Problems)
if len(g.Nodes[i].Problems) > maxPerCard {
g.Nodes[i].Problems = g.Nodes[i].Problems[:maxPerCard]
}
}
g.ClusterProblems = sortProblems(s.cluster)
if g.ClusterProblems == nil {
g.ClusterProblems = []Problem{}
}
}
func sortProblems(ps []Problem) []Problem {
sort.SliceStable(ps, func(i, j int) bool {
if severityRank[ps[i].Severity] != severityRank[ps[j].Severity] {
return severityRank[ps[i].Severity] > severityRank[ps[j].Severity]
}
return ps[i].Since > ps[j].Since
})
return ps
}
// namespaceOfID reads the namespace out of "wl/<ns>/…", "service/<ns>/…",
// "ingress/<ns>/…" and "ns/<ns>".
func namespaceOfID(id string) string {
parts := strings.SplitN(id, "/", 3)
if len(parts) >= 2 && parts[0] != "node" {
return parts[1]
}
return ""
}
func stamp(t time.Time) string {
if t.IsZero() {
return ""
}
return t.UTC().Format(time.RFC3339)
}
func podProblems(s *problemSet, p corev1.Pod) {
id := OwnerWorkloadID(p)
if id == "" {
id = "ns/" + p.Namespace // a bare pod has no card; its namespace carries the badge
}
if p.Status.Phase == corev1.PodSucceeded {
return
}
if p.Status.Phase == corev1.PodFailed {
if p.Status.Reason == "Evicted" && now().Sub(p.CreationTimestamp.Time) < 24*time.Hour {
s.add(id, Problem{Severity: Warning, Source: "state", Reason: "Evicted", Message: p.Status.Message, Object: p.Name})
}
return
}
statuses := append(append([]corev1.ContainerStatus{}, p.Status.InitContainerStatuses...), p.Status.ContainerStatuses...)
for _, cs := range statuses {
obj := p.Name + "/" + cs.Name
if w := cs.State.Waiting; w != nil && waitingCritical[w.Reason] {
// a crash loop is also a restart; one problem, with the restart count
s.add(id, Problem{Severity: Critical, Source: "state", Reason: w.Reason, Message: w.Message, Object: obj, Count: int(cs.RestartCount)})
continue
}
if t := cs.LastTerminationState.Terminated; t != nil && now().Sub(t.FinishedAt.Time) < restartWindow {
reason := "Restarted"
if t.Reason == "OOMKilled" {
reason = "OOMKilled"
}
s.add(id, Problem{Severity: Warning, Source: "state", Reason: reason, Object: obj, Count: int(cs.RestartCount),
Message: strings.TrimSpace(t.Reason + " exit " + strconv.Itoa(int(t.ExitCode))), Since: stamp(t.FinishedAt.Time)})
}
}
if p.Status.Phase == corev1.PodPending && now().Sub(p.CreationTimestamp.Time) > pendingAfter {
pr := Problem{Severity: Warning, Source: "state", Reason: "Pending", Object: p.Name, Since: stamp(p.CreationTimestamp.Time)}
for _, c := range p.Status.Conditions {
if c.Type == corev1.PodScheduled && c.Status == corev1.ConditionFalse {
pr.Reason, pr.Message = "Unschedulable", c.Message
}
}
s.add(id, pr)
}
}
// cronJobProblems: the last scheduled run ended without success. Job
// objects are not cached, so this reads the CronJob's own status: a
// schedule time later than the last success, with nothing running.
func cronJobProblems(s *problemSet, cj batchv1.CronJob) {
last := cj.Status.LastScheduleTime
if last == nil || len(cj.Status.Active) > 0 {
return
}
ok := cj.Status.LastSuccessfulTime
if ok != nil && !ok.Before(last) {
return
}
s.add(WorkloadID(cj.Namespace, "cronjob", cj.Name), Problem{Severity: Warning, Source: "state", Reason: "LastRunFailed", Since: stamp(last.Time)})
}
func serviceProblems(s *problemSet, svc corev1.Service, pods []corev1.Pod) {
if len(svc.Spec.Selector) == 0 || svc.Spec.Type == corev1.ServiceTypeExternalName {
return
}
for _, p := range pods {
if podReady(p) && SelectorMatches(svc.Spec.Selector, p.Labels) {
return
}
}
s.add("service/"+svc.Namespace+"/"+svc.Name, Problem{Severity: Warning, Source: "state", Reason: "NoEndpoints"})
}
func nodeProblems(s *problemSet, n corev1.Node) {
id := "node/" + n.Name
for _, c := range n.Status.Conditions {
switch {
case c.Type == corev1.NodeReady && c.Status != corev1.ConditionTrue:
s.add(id, Problem{Severity: Critical, Source: "state", Reason: "NodeNotReady", Message: c.Message, Since: stamp(c.LastTransitionTime.Time)})
case (c.Type == corev1.NodeMemoryPressure || c.Type == corev1.NodeDiskPressure || c.Type == corev1.NodePIDPressure) && c.Status == corev1.ConditionTrue:
s.add(id, Problem{Severity: Warning, Source: "state", Reason: string(c.Type), Message: c.Message, Since: stamp(c.LastTransitionTime.Time)})
}
}
if n.Spec.Unschedulable {
s.add(id, Problem{Severity: Info, Source: "state", Reason: "Cordoned"})
}
}
// eventTime is when an event last happened, whichever field the emitter set.
func eventTime(e corev1.Event) time.Time {
switch {
case e.Series != nil && !e.Series.LastObservedTime.IsZero():
return e.Series.LastObservedTime.Time
case !e.LastTimestamp.IsZero():
return e.LastTimestamp.Time
case !e.EventTime.IsZero():
return e.EventTime.Time
}
return e.CreationTimestamp.Time
}
// EventTargetID maps an event's involved object to a card ID, the way pods
// and their controllers map to workloads.
func EventTargetID(ref corev1.ObjectReference, podOwner map[string]string) string {
ns := ref.Namespace
switch ref.Kind {
case "Pod":
if id := podOwner[ns+"/"+ref.Name]; id != "" {
return id
}
return "ns/" + ns
case "ReplicaSet":
if i := strings.LastIndex(ref.Name, "-"); i > 0 {
return WorkloadID(ns, "deployment", ref.Name[:i])
}
case "Deployment", "StatefulSet", "DaemonSet", "CronJob":
return WorkloadID(ns, strings.ToLower(ref.Kind), ref.Name)
case "Job":
if cj, ok := CronJobFromJob(ref.Name); ok {
return WorkloadID(ns, "cronjob", cj)
}
case "Service":
return "service/" + ns + "/" + ref.Name
case "Ingress":
return "ingress/" + ns + "/" + ref.Name
case "Node":
return "node/" + ref.Name
}
if ns != "" {
return "ns/" + ns
}
return ""
}
// eventProblems folds recent Warning events into one problem per card and
// reason, keeping the latest message.
func eventProblems(s *problemSet, events []corev1.Event, podOwner map[string]string) {
type key struct{ id, reason string }
folded := map[key]*Problem{}
var order []key
for _, e := range events {
at := eventTime(e)
if e.Type != corev1.EventTypeWarning || now().Sub(at) > eventWindow || syntheticProbe(e.InvolvedObject.Namespace, e.InvolvedObject.Name) {
continue
}
id := EventTargetID(e.InvolvedObject, podOwner)
k := key{id, e.Reason}
count := int(e.Count)
if e.Series != nil {
count = int(e.Series.Count)
}
count = max(count, 1)
if p := folded[k]; p != nil {
p.Count += count
if stamp(at) > p.Since {
p.Since, p.Message, p.Object = stamp(at), e.Message, eventObject(e.InvolvedObject)
}
continue
}
folded[k] = &Problem{Severity: Warning, Source: "event", Reason: e.Reason, Message: e.Message, Object: eventObject(e.InvolvedObject), Count: count, Since: stamp(at)}
order = append(order, k)
}
for _, k := range order {
p := folded[k]
if !eventNotable[p.Reason] && p.Count < eventRepeats {
p.Severity = Info
}
s.add(k.id, *p)
}
}
// readinessProblem turns the card's own health into a problem, so a
// workload with nothing ready is red even when no pod says why. It waits
// notReadyAfter for its pods, so a rollout or a restart does not flash.
// A workload short of replicas with no pod at all (none could be created)
// is reported at once.
func readinessProblem(s *problemSet, n Node, notReadySince map[string]time.Time) {
if !nativeKinds[n.Kind] && n.Facts["foreign"] != "true" {
return
}
if since, ok := notReadySince[n.ID]; ok && now().Sub(since) < notReadyAfter {
return
}
switch n.Facts["health"] {
case "error":
s.add(n.ID, Problem{Severity: Critical, Source: "state", Reason: "NotReady"})
case "warn":
s.add(n.ID, Problem{Severity: Warning, Source: "state", Reason: "PartlyReady"})
}
}
// syntheticProbe: upmeter, Deckhouse's availability monitor, creates short
// lived StatefulSets and pods named upmeter-probe-* that are unschedulable
// on purpose (it measures how fast the control plane reacts). Their
// FailedScheduling and NotReady are the probe working, not a problem.
func syntheticProbe(ns, name string) bool {
return ns == "d8-upmeter" && strings.HasPrefix(name, "upmeter-probe-")
}
// notReadyFrom is when a running or pending pod stopped being ready (or
// was created, if it never was); ok is false for ready and finished pods.
func notReadyFrom(p corev1.Pod) (time.Time, bool) {
if p.Status.Phase == corev1.PodSucceeded || p.Status.Phase == corev1.PodFailed || p.DeletionTimestamp != nil {
return time.Time{}, false
}
for _, c := range p.Status.Conditions {
if c.Type == corev1.PodReady {
if c.Status == corev1.ConditionTrue {
return time.Time{}, false
}
if !c.LastTransitionTime.IsZero() {
return c.LastTransitionTime.Time, true
}
}
}
return p.CreationTimestamp.Time, true
}
func eventObject(ref corev1.ObjectReference) string {
if ref.Kind == "Pod" {
return ref.Name
}
return ""
}
// AlertSeverity maps Deckhouse's severity_level (1 is the most severe) to a
// badge colour.
func AlertSeverity(level string) string {
n, err := strconv.Atoi(strings.TrimSpace(level))
switch {
case err != nil:
return Warning
case n <= 3:
return Critical
case n <= 6:
return Warning
}
return Info
}
// AlertTargetID picks the card an alert is about from its labels, most
// specific first. Unknown objects fall back to the namespace, alerts
// without a namespace to the cluster.
func AlertTargetID(labels map[string]string, podOwner map[string]string) string {
ns := labels["namespace"]
if n := labels["node"]; n != "" && ns == "" {
return "node/" + n
}
if ns == "" {
return ""
}
for _, kind := range []string{"deployment", "statefulset", "daemonset", "cronjob"} {
if name := labels[kind]; name != "" {
return WorkloadID(ns, kind, name)
}
}
if pod := labels["pod"]; pod != "" {
if id := podOwner[ns+"/"+pod]; id != "" {
return id
}
}
if job := labels["job_name"]; job != "" {
if cj, ok := CronJobFromJob(job); ok {
return WorkloadID(ns, "cronjob", cj)
}
}
if svc := labels["service"]; svc != "" {
return "service/" + ns + "/" + svc
}
if ing := labels["ingress"]; ing != "" {
return "ingress/" + ns + "/" + ing
}
return "ns/" + ns
}
func alertProblem(s *problemSet, a *unstructured.Unstructured, podOwner map[string]string) {
if st, _, _ := unstructured.NestedString(a.Object, "status", "alertStatus"); st != "" && st != "firing" {
return
}
name, _, _ := unstructured.NestedString(a.Object, "alert", "name")
summary, _, _ := unstructured.NestedString(a.Object, "alert", "summary")
level, _, _ := unstructured.NestedString(a.Object, "alert", "severityLevel")
labels, _, _ := unstructured.NestedStringMap(a.Object, "alert", "labels")
since, _, _ := unstructured.NestedString(a.Object, "status", "startsAt")
s.add(AlertTargetID(labels, podOwner), Problem{Severity: AlertSeverity(level), Source: "alert", Reason: name, Message: strings.TrimSpace(summary), Since: since})
}
@@ -0,0 +1,240 @@
/*
Copyright 2026 The cluster-map Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package topology
import (
"testing"
"time"
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/apimachinery/pkg/apis/meta/v1/unstructured"
)
var t0 = time.Date(2026, 9, 24, 12, 0, 0, 0, time.UTC)
func withNow(t *testing.T) {
t.Helper()
old := now
now = func() time.Time { return t0 }
t.Cleanup(func() { now = old })
}
func ingressTo(ns, name, svc string) networkingv1.Ingress {
return networkingv1.Ingress{ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: ns}, Spec: networkingv1.IngressSpec{
DefaultBackend: &networkingv1.IngressBackend{Service: &networkingv1.IngressServiceBackend{Name: svc}},
}}
}
func problemsOf(g *Graph, id string) map[string]Problem {
out := map[string]Problem{}
for _, n := range g.Nodes {
if n.ID == id {
for _, p := range n.Problems {
out[p.Reason] = p
}
}
}
return out
}
func TestProblemsFromState(t *testing.T) {
withNow(t)
ready := []corev1.PodCondition{{Type: corev1.PodReady, Status: corev1.ConditionTrue}}
g := &Graph{Nodes: []Node{
{ID: "ns/shop"}, {ID: "wl/shop/deployment/web", Kind: "deployment", Facts: map[string]string{"health": "warn"}}, {ID: "service/shop/web"}, {ID: "service/shop/idle"},
{ID: "ingress/shop/web"}, {ID: "wl/shop/cronjob/backup"}, {ID: "node/node-a"},
}}
in := problemInputs{
pods: []corev1.Pod{
{ // crash-looping, restarted 10 min ago
ObjectMeta: metav1.ObjectMeta{Name: "web-5f-a", Namespace: "shop", Labels: map[string]string{"app": "web"}, OwnerReferences: owned("ReplicaSet", "web-5f")},
Status: corev1.PodStatus{Phase: corev1.PodRunning, ContainerStatuses: []corev1.ContainerStatus{{
Name: "app", RestartCount: 7,
State: corev1.ContainerState{Waiting: &corev1.ContainerStateWaiting{Reason: "CrashLoopBackOff"}},
LastTerminationState: corev1.ContainerState{Terminated: &corev1.ContainerStateTerminated{Reason: "Error", ExitCode: 1, FinishedAt: metav1.NewTime(t0.Add(-10 * time.Minute))}},
}}},
},
{ // ready, OOM-killed long ago: no problem
ObjectMeta: metav1.ObjectMeta{Name: "web-5f-b", Namespace: "shop", Labels: map[string]string{"app": "web"}, OwnerReferences: owned("ReplicaSet", "web-5f")},
Status: corev1.PodStatus{Phase: corev1.PodRunning, Conditions: ready, ContainerStatuses: []corev1.ContainerStatus{{
Name: "app", LastTerminationState: corev1.ContainerState{Terminated: &corev1.ContainerStateTerminated{Reason: "OOMKilled", FinishedAt: metav1.NewTime(t0.Add(-3 * time.Hour))}},
}}},
},
{ // bare pod pending for 10 minutes: badge on the namespace
ObjectMeta: metav1.ObjectMeta{Name: "debug", Namespace: "shop", CreationTimestamp: metav1.NewTime(t0.Add(-10 * time.Minute))},
Status: corev1.PodStatus{Phase: corev1.PodPending, Conditions: []corev1.PodCondition{{Type: corev1.PodScheduled, Status: corev1.ConditionFalse, Message: "0/3 nodes are available"}}},
},
},
services: []corev1.Service{
{ObjectMeta: metav1.ObjectMeta{Name: "web", Namespace: "shop"}, Spec: corev1.ServiceSpec{Selector: map[string]string{"app": "web"}}},
{ObjectMeta: metav1.ObjectMeta{Name: "idle", Namespace: "shop"}, Spec: corev1.ServiceSpec{Selector: map[string]string{"app": "gone"}}},
},
ingresses: []networkingv1.Ingress{ingressTo("shop", "web", "missing")},
cronjobs: []batchv1.CronJob{{
ObjectMeta: metav1.ObjectMeta{Name: "backup", Namespace: "shop"},
Status: batchv1.CronJobStatus{LastScheduleTime: &metav1.Time{Time: t0.Add(-time.Hour)}, LastSuccessfulTime: &metav1.Time{Time: t0.Add(-25 * time.Hour)}},
}},
nodes: []corev1.Node{{
ObjectMeta: metav1.ObjectMeta{Name: "node-a"}, Spec: corev1.NodeSpec{Unschedulable: true},
Status: corev1.NodeStatus{Conditions: []corev1.NodeCondition{{Type: corev1.NodeReady, Status: corev1.ConditionTrue}, {Type: corev1.NodeDiskPressure, Status: corev1.ConditionTrue}}},
}},
deployments: []appsv1.Deployment{},
}
attachProblems(g, in)
web := problemsOf(g, "wl/shop/deployment/web")
if p := web["CrashLoopBackOff"]; p.Severity != Critical || p.Object != "web-5f-a/app" || p.Count != 7 {
t.Errorf("crash loop: %+v", web)
}
if web["PartlyReady"].Severity != Warning {
t.Errorf("partly ready workload: %+v", web)
}
if _, ok := web["Restarted"]; ok {
t.Error("a crash loop is reported once, not also as a restart")
}
if _, ok := web["OOMKilled"]; ok {
t.Error("an OOM kill three hours ago must not mark the card")
}
if _, ok := problemsOf(g, "service/shop/web")["NoEndpoints"]; ok {
t.Error("service with a ready pod reported without endpoints")
}
if _, ok := problemsOf(g, "service/shop/idle")["NoEndpoints"]; !ok {
t.Error("service selecting nothing not reported")
}
if p := problemsOf(g, "ingress/shop/web")["BackendMissing"]; p.Object != "missing" {
t.Errorf("ingress to a missing service: %+v", p)
}
if _, ok := problemsOf(g, "wl/shop/cronjob/backup")["LastRunFailed"]; !ok {
t.Error("cronjob whose last run did not succeed")
}
if p := problemsOf(g, "ns/shop")["Unschedulable"]; p.Message == "" {
t.Errorf("bare pending pod on the namespace: %+v", problemsOf(g, "ns/shop"))
}
node := problemsOf(g, "node/node-a")
if node["DiskPressure"].Severity != Warning || node["Cordoned"].Severity != Info {
t.Errorf("node: %+v", node)
}
if got := g.Nodes[1].Problems[0].Severity; got != Critical {
t.Errorf("critical first, got %s", got)
}
}
func TestReadinessGraceAndProbes(t *testing.T) {
withNow(t)
notReady := func(name string, since time.Duration) corev1.Pod {
return corev1.Pod{
ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: "shop", OwnerReferences: owned("ReplicaSet", name[:len(name)-2])},
Status: corev1.PodStatus{Phase: corev1.PodRunning, Conditions: []corev1.PodCondition{
{Type: corev1.PodReady, Status: corev1.ConditionFalse, LastTransitionTime: metav1.NewTime(t0.Add(-since))}}},
}
}
g := &Graph{Nodes: []Node{
{ID: "ns/shop"}, {ID: "ns/d8-upmeter"},
{ID: "wl/shop/deployment/fresh", Kind: "deployment", Facts: map[string]string{"health": "error"}},
{ID: "wl/shop/deployment/stuck", Kind: "deployment", Facts: map[string]string{"health": "error"}},
{ID: "wl/shop/deployment/nopods", Kind: "deployment", Facts: map[string]string{"health": "error"}},
}}
attachProblems(g, problemInputs{
pods: []corev1.Pod{notReady("fresh-5f-a", 30*time.Second), notReady("stuck-5f-a", 10*time.Minute)},
events: []corev1.Event{{Type: corev1.EventTypeWarning, Reason: "FailedScheduling", LastTimestamp: metav1.NewTime(t0),
InvolvedObject: corev1.ObjectReference{Kind: "Pod", Namespace: "d8-upmeter", Name: "upmeter-probe-controller-manager-9b2cc8b5-0"}}},
})
if _, ok := problemsOf(g, "wl/shop/deployment/fresh")["NotReady"]; ok {
t.Error("a pod not ready for 30 seconds marks the card")
}
if _, ok := problemsOf(g, "wl/shop/deployment/stuck")["NotReady"]; !ok {
t.Error("a pod not ready for 10 minutes does not mark the card")
}
if _, ok := problemsOf(g, "wl/shop/deployment/nopods")["NotReady"]; !ok {
t.Error("a workload with no pod at all must be reported")
}
if len(problemsOf(g, "ns/d8-upmeter")) != 0 {
t.Error("upmeter's synthetic probe reported as a problem")
}
}
func alert(name, level string, labels map[string]string) *unstructured.Unstructured {
l := map[string]any{}
for k, v := range labels {
l[k] = v
}
return &unstructured.Unstructured{Object: map[string]any{
"alert": map[string]any{"name": name, "severityLevel": level, "summary": "summary of " + name, "labels": l},
"status": map[string]any{"alertStatus": "firing", "startsAt": "2026-09-24T10:00:00Z"},
}}
}
func TestAlertsAndEvents(t *testing.T) {
withNow(t)
g := &Graph{Nodes: []Node{{ID: "ns/shop"}, {ID: "wl/shop/deployment/web"}, {ID: "node/node-a"}}}
in := problemInputs{
pods: []corev1.Pod{{ObjectMeta: metav1.ObjectMeta{Name: "web-5f-a", Namespace: "shop", OwnerReferences: owned("ReplicaSet", "web-5f")}}},
alerts: []*unstructured.Unstructured{
alert("KubernetesDeploymentReplicasUnavailable", "3", map[string]string{"namespace": "shop", "deployment": "web"}),
alert("PodHighMemory", "5", map[string]string{"namespace": "shop", "pod": "web-5f-a"}),
alert("NamespaceQuota", "6", map[string]string{"namespace": "shop"}),
alert("NodeDiskFull", "4", map[string]string{"node": "node-a"}),
alert("ModuleConfigObsoleteVersion", "4", map[string]string{"name": "operator-trivy"}),
alert("GoneNamespace", "4", map[string]string{"namespace": "deleted"}),
},
events: []corev1.Event{
{Type: corev1.EventTypeWarning, Reason: "ProbeWarning", Count: 1, InvolvedObject: corev1.ObjectReference{Kind: "Node", Name: "node-a"}, LastTimestamp: metav1.NewTime(t0.Add(-time.Minute))},
{Type: corev1.EventTypeWarning, Reason: "Unhealthy", Message: "old", Count: 2, InvolvedObject: corev1.ObjectReference{Kind: "Pod", Namespace: "shop", Name: "web-5f-a"}, LastTimestamp: metav1.NewTime(t0.Add(-20 * time.Minute))},
{Type: corev1.EventTypeWarning, Reason: "Unhealthy", Message: "latest", Count: 3, InvolvedObject: corev1.ObjectReference{Kind: "Pod", Namespace: "shop", Name: "web-5f-a"}, LastTimestamp: metav1.NewTime(t0.Add(-time.Minute))},
{Type: corev1.EventTypeWarning, Reason: "FailedMount", InvolvedObject: corev1.ObjectReference{Kind: "Pod", Namespace: "shop", Name: "web-5f-a"}, LastTimestamp: metav1.NewTime(t0.Add(-2 * time.Hour))},
},
}
attachProblems(g, in)
web := problemsOf(g, "wl/shop/deployment/web")
if web["KubernetesDeploymentReplicasUnavailable"].Severity != Critical || web["PodHighMemory"].Severity != Warning {
t.Errorf("alerts on the workload: %+v", web)
}
if p := web["Unhealthy"]; p.Count != 5 || p.Message != "latest" || p.Severity != Warning {
t.Errorf("folded events: %+v", p)
}
if _, ok := web["FailedMount"]; ok {
t.Error("a warning two hours old must not mark the card")
}
if _, ok := problemsOf(g, "ns/shop")["NamespaceQuota"]; !ok {
t.Error("namespace-level alert")
}
if _, ok := problemsOf(g, "node/node-a")["NodeDiskFull"]; !ok {
t.Error("node alert")
}
if p := problemsOf(g, "node/node-a")["ProbeWarning"]; p.Severity != Info {
t.Errorf("a single ordinary warning is listed, not badged: %+v", p)
}
cluster := map[string]bool{}
for _, p := range g.ClusterProblems {
cluster[p.Reason] = true
}
if !cluster["ModuleConfigObsoleteVersion"] || !cluster["GoneNamespace"] || len(g.ClusterProblems) != 2 {
t.Errorf("cluster problems: %+v", g.ClusterProblems)
}
}
func TestAlertSeverity(t *testing.T) {
for level, want := range map[string]string{"1": Critical, "3": Critical, "4": Warning, "6": Warning, "7": Info, "": Warning} {
if got := AlertSeverity(level); got != want {
t.Errorf("level %q: %s, want %s", level, got, want)
}
}
}
@@ -48,8 +48,8 @@ import (
// count for that edge stops growing for the rest of the minute.
const maxTuplesPerKey = 20000
// InfraFilters are applied at the agents, so the relay never serialises
// these flows. On a 12k-event sample from a real cluster they were ~74% of
// InfraFilters (a blacklist) are applied at the agents, so the relay never
// serialises these flows. On a 12k-event sample from a real cluster they were ~74% of
// non-reply events: host-originated traffic (kubelet probes, hostNetwork
// pods) 43%, DNS 19%, remote-node 11%, cilium health 1%. None of them map
// to a workload card, and streaming them kept hubble-relay at ~400m CPU.
@@ -59,8 +59,24 @@ var InfraFilters = []*flowpb.FlowFilter{
{SourceLabel: []string{"reserved:health"}},
{DestinationLabel: []string{"reserved:health"}},
{DestinationPort: []string{"53"}},
// Pod-to-pod across nodes is traced twice: to-overlay on the sender's
// node and to-endpoint on the receiver's. The second copy carries the
// same tuple, so the first is dropped when the receiver is a pod; to a
// hostNetwork pod or the API server, to-overlay is the only trace and
// stays. Measured on six nodes: ~20% of the events that reach the relay.
{
EventType: []*flowpb.EventTypeFilter{{Type: monitorTrace, MatchSubType: true, SubType: traceToOverlay}},
DestinationLabel: []string{"k8s:io.kubernetes.pod.namespace"},
},
}
// Cilium datapath codes (pkg/monitor/api): message type "trace" and its
// observation point "to-overlay".
const (
monitorTrace = 4
traceToOverlay = 4
)
var flowFields = []string{"time", "verdict", "IP", "l4", "source", "destination", "source_names", "destination_names", "node_name"}
// Endpoint is one side of a traffic edge: a workload, a pod or an address.
+103 -1
View File
@@ -66,7 +66,9 @@ select, input[type="search"] {
flex: none;
}
.brand { font-weight: 650; letter-spacing: 0.01em; }
.crumbs { display: flex; flex-wrap: wrap; align-items: center; gap: 0.35rem; flex: 1; min-width: 0; }
.crumbs { display: flex; align-items: center; gap: 0.35rem; flex: 1; min-width: 0; overflow: hidden; white-space: nowrap; }
.crumbs > * { flex: none; }
.crumbs > :last-child { flex: 0 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; }
.crumbs button {
background: none; border: none; color: var(--accent); font: inherit; cursor: pointer; padding: 0.1rem 0.2rem; border-radius: 4px;
}
@@ -197,6 +199,106 @@ select, input[type="search"] {
.logs-bar { display: flex; gap: 0.4rem; margin-bottom: 0.5rem; flex-wrap: wrap; }
.logs-bar select { max-width: 100%; }
/* problem badges */
.pbadge {
display: inline-grid; place-items: center; flex: none;
width: 15px; height: 15px; border-radius: 50%;
font-size: 0.65rem; font-weight: 800; line-height: 1; color: #fff;
}
.pbadge.warning { background: var(--warn); }
.pbadge.critical { background: var(--error); }
.pbadge.info { background: var(--idle); }
.tree .pbadge { width: 13px; height: 13px; font-size: 0.6rem; }
.legend .pbadge { display: inline-grid; width: 13px; height: 13px; font-size: 0.6rem; }
.problems-btn { display: inline-flex; align-items: center; gap: 0.4rem; }
.problems-btn.ok { color: var(--muted); }
.problems-btn.warning { border-color: var(--warn); }
.problems-btn.critical { border-color: var(--error); }
.whoami { max-width: 14rem; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.summary { display: flex; align-items: center; gap: 0.45rem; margin: 0 0 0.8rem; font-weight: 600; }
.summary.ok { color: var(--ok); }
.summary.warning { color: var(--warn); }
.summary.critical { color: var(--error); }
.summary.idle { color: var(--muted); }
.problem-list { list-style: none; margin: 0 0 0.8rem; padding: 0; display: flex; flex-direction: column; gap: 0.25rem; }
.problem .p-row {
width: 100%; display: flex; align-items: flex-start; gap: 0.5rem; text-align: left;
background: var(--panel-2); border: 1px solid var(--line); border-left-width: 3px; border-radius: 6px;
padding: 0.4rem 0.5rem; color: var(--text); font: inherit;
}
button.p-row { cursor: pointer; }
button.p-row:hover { border-color: var(--accent); }
.problem.warning .p-row { border-left-color: var(--warn); }
.problem.critical .p-row { border-left-color: var(--error); }
.problem.info .p-row { border-left-color: var(--idle); }
.p-body { display: flex; flex-direction: column; gap: 0.1rem; min-width: 0; flex: 1; }
.p-target { display: inline-flex; align-items: center; gap: 0.3rem; font-weight: 600; }
.p-reason { overflow-wrap: anywhere; }
.p-src { margin-left: 0.4rem; font-size: 0.66rem; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted); border: 1px solid var(--line); border-radius: 4px; padding: 0 0.25rem; }
.p-msg { font-size: 0.72rem; overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 3; line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
.problem .meta { margin-left: auto; white-space: nowrap; }
.p-info summary { cursor: pointer; color: var(--muted); margin: 0.6rem 0 0.4rem; }
.p-filter { margin: 0 0.9rem 0.3rem; }
/* actions */
.d-actions { display: flex; flex-wrap: wrap; gap: 0.35rem; padding: 0 0.9rem 0.6rem; }
.d-actions:empty { display: none; }
.btn.small { padding: 0.15rem 0.5rem; font-size: 0.75rem; }
.btn.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
.btn.primary.danger { background: var(--error); border-color: var(--error); }
#lock.unlocked { border-color: var(--warn); color: var(--warn); }
dialog {
background: var(--panel); color: var(--text);
border: 1px solid var(--line); border-radius: 10px; padding: 1rem 1.1rem;
width: min(28rem, calc(100vw - 2rem)); box-shadow: 0 10px 40px #0006;
}
dialog::backdrop { background: #0008; }
dialog h2 { margin: 0 0 0.5rem; font-size: 1rem; overflow-wrap: anywhere; }
dialog p { margin: 0 0 0.8rem; color: var(--muted); }
.confirm-input { display: flex; align-items: center; gap: 0.5rem; margin-bottom: 0.8rem; }
.confirm-input input { width: 6rem; background: var(--panel-2); color: var(--text); border: 1px solid var(--line); border-radius: 6px; padding: 0.3rem 0.5rem; font: inherit; }
.confirm-input[hidden] { display: none; }
.confirm-buttons { display: flex; justify-content: flex-end; gap: 0.5rem; }
.toast {
position: absolute; top: 2.6rem; left: 50%; transform: translateX(-50%); z-index: 5;
max-width: min(36rem, 90%); background: var(--panel); border: 1px solid var(--line); border-left: 3px solid var(--ok);
border-radius: 8px; padding: 0.45rem 0.8rem; box-shadow: 0 4px 16px #0004; overflow-wrap: anywhere;
}
.toast.error { border-left-color: var(--error); }
.toast[hidden] { display: none; }
/* load */
.usage-row { margin-bottom: 0.6rem; }
.usage-head { display: flex; align-items: baseline; gap: 0.5rem; flex-wrap: wrap; }
.usage-head span:first-child { color: var(--muted); min-width: 4rem; }
.usage-row meter { width: 100%; height: 0.55rem; }
table.pods { width: 100%; border-collapse: collapse; margin-top: 0.4rem; font-size: 0.75rem; }
table.pods th { text-align: left; color: var(--muted); font-weight: 500; padding: 0.2rem 0.3rem; border-bottom: 1px solid var(--line); }
table.pods td { padding: 0.3rem; border-bottom: 1px solid var(--line); vertical-align: top; overflow-wrap: anywhere; }
table.pods .warn-text { color: var(--warn); font-weight: 600; }
/* events */
.event-list { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 0.35rem; }
.event-list li { border-left: 3px solid var(--line); padding: 0.1rem 0 0.1rem 0.5rem; }
.event-list li.warning { border-left-color: var(--warn); }
.ev-head { display: flex; gap: 0.4rem; align-items: baseline; }
.ev-reason { font-weight: 600; }
.ev-time { margin-left: auto; white-space: nowrap; }
.ev-msg { overflow-wrap: anywhere; }
@media (max-width: 1280px) {
.whoami { display: none; }
}
@media (max-width: 1100px) {
#updated { display: none; }
.topbar { gap: 0.6rem; }
}
@media (prefers-reduced-motion: reduce) {
* { transition: none !important; animation: none !important; }
}
+482 -34
View File
@@ -83,14 +83,18 @@ function fitText(text, font, max) {
return text.slice(0, lo) + '…';
}
const imgCache = new Map();
function cardImage({ kind, title, sub, health, ghost, w, h }) {
const key = [kind, title, sub, health, ghost, w, h].join('|');
function cardImage({ kind, title, sub, health, ghost, w, h, badge }) {
const key = [kind, title, sub, health, ghost, w, h, badge].join('|');
if (imgCache.has(key)) return imgCache.get(key);
const c = (KIND[kind] || KIND.external).color;
const name = fitText(title, `600 12.5px ${FONT}`, w - 58);
const name = fitText(title, `600 12.5px ${FONT}`, w - (badge ? 74 : 58));
const line2 = sub ? fitText(sub, `11px ${FONT}`, w - 50) : '';
const nameY = sub ? h / 2 - 3 : h / 2 + 4.5;
const dot = health ? `<circle cx="${w - 12}" cy="12" r="4" fill="${T[health]}"/>` : '';
// "!" in a circle left of the health dot: yellow warning, red critical
const bx = health ? w - 28 : w - 14;
const mark = badge ? `<circle cx="${bx}" cy="12" r="7" fill="${badge === 'critical' ? T.error : T.warn}"/>
<text x="${bx}" y="15.6" text-anchor="middle" font-family="${FONT}" font-size="10.5" font-weight="800" fill="#fff">!</text>` : '';
// Drawn at 2x so cards stay crisp up to the max zoom.
const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w * 2}" height="${h * 2}" viewBox="0 0 ${w} ${h}">
<defs><clipPath id="r"><rect x="0.5" y="0.5" width="${w - 1}" height="${h - 1}" rx="8"/></clipPath></defs>
@@ -99,7 +103,7 @@ function cardImage({ kind, title, sub, health, ghost, w, h }) {
<g transform="translate(13 ${h / 2 - 10})" fill="none" stroke="${c}" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round">${ICON[kind] || ''}</g>
<text x="41" y="${nameY}" font-family="${FONT}" font-size="12.5" font-weight="600" fill="${ghost ? T.muted : T.text}">${esc(name)}</text>
${sub ? `<text x="41" y="${h / 2 + 12}" font-family="${FONT}" font-size="11" fill="${T.muted}">${esc(line2)}</text>` : ''}
${dot}</svg>`;
${dot}${mark}</svg>`;
const url = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(svg);
imgCache.set(key, url);
return url;
@@ -159,6 +163,42 @@ function nsHealth(ns) {
}
return any ? worst : 'idle';
}
/* ---------- problems ---------- */
// Info-level problems (a cordoned node, a one-off probe failure) are listed
// but never badge a card.
const SEV_RANK = { critical: 3, warning: 2, info: 1 };
const worse = (a, b) => ((SEV_RANK[b] || 0) > (SEV_RANK[a] || 0) ? b : a);
function badgeSev(problems) {
let w = '';
for (const p of problems || []) if (p.severity !== 'info') w = worse(w, p.severity);
return w;
}
const cardSev = (n) => badgeSev(n?.problems);
function nsSeverity(ns) {
let w = cardSev(G.byId.get('ns/' + ns));
for (const n of G.byNs.get(ns) || []) w = worse(w, cardSev(n));
return w;
}
function problemText(p) {
const k = 'problem.' + p.reason;
const s = t(k, { object: p.object || '', n: p.count || 0 });
return s === k ? p.reason : s;
}
function ago(iso) {
if (!iso) return '';
const sec = Math.max(0, (Date.now() - Date.parse(iso)) / 1000);
return t('ago', { d: fmtDuration(sec) });
}
// Every problem with the card it belongs to, for the Problems panel and the
// top-bar counter.
function allProblems() {
const out = [];
for (const p of G.raw?.clusterProblems || []) out.push({ p, n: null });
for (const n of G.raw?.nodes || []) for (const p of n.problems || []) out.push({ p, n });
out.sort((a, b) => (SEV_RANK[b.p.severity] - SEV_RANK[a.p.severity]) || String(b.p.since || '').localeCompare(String(a.p.since || '')));
return out;
}
function subline(n) {
const f = n.facts || {};
if (f.foreign === 'true') return `${t('sub.ready', { ready: f.ready, want: f.pods })} · ${controllerKind(n)}`;
@@ -207,7 +247,7 @@ function writeHash() {
/* ---------- inventory tree ---------- */
function objectItem(n) {
return { id: 't:obj:' + n.id, label: n.label, icon: n.kind, health: n.facts?.health, match: [n.label, n.facts?.image, n.facts?.hosts].join(' '), activate: () => selectObject(n.id) };
return { id: 't:obj:' + n.id, label: n.label, icon: n.kind, health: n.facts?.health, sev: cardSev(n), match: [n.label, n.facts?.image, n.facts?.hosts].join(' '), activate: () => selectObject(n.id) };
}
function nsKindFolders(ns, objs) {
const folders = [];
@@ -229,12 +269,12 @@ function buildTreeModel() {
children: byNs.get(ns).sort((a, b) => a.label.localeCompare(b.label)).map(objectItem),
activate: () => scopeNode(h.label),
}));
return { id: 't:node:' + h.label, label: h.label, icon: 'node', health: h.facts?.health, count: wls.length, children: nsItems, activate: () => scopeNode(h.label) };
return { id: 't:node:' + h.label, label: h.label, icon: 'node', health: h.facts?.health, sev: cardSev(h), count: wls.length, children: nsItems, activate: () => scopeNode(h.label) };
});
}
const nsItem = (n) => {
const objs = G.byNs.get(n.label) || [];
return { id: 't:ns:' + n.label, label: n.label, icon: 'namespace', health: nsHealth(n.label), count: objs.length, children: nsKindFolders(n.label, objs), activate: (add) => scopeNs(n.label, add), nsName: n.label };
return { id: 't:ns:' + n.label, label: n.label, icon: 'namespace', health: nsHealth(n.label), sev: nsSeverity(n.label), count: objs.length, children: nsKindFolders(n.label, objs), activate: (add) => scopeNs(n.label, add), nsName: n.label };
};
const user = G.nsNodes.filter((n) => n.facts?.system !== 'true').map(nsItem);
const sys = G.nsNodes.filter((n) => n.facts?.system === 'true').map(nsItem);
@@ -287,6 +327,7 @@ function renderTree() {
it.health ? el('span', { class: 'dot ' + it.health, title: HEALTH_TEXT[it.health] }) : null,
el('span', { html: iconSvg(it.icon) }).firstChild,
el('span', { class: 'label' }, highlight(it.label, q)),
it.sev ? el('span', { class: 'pbadge ' + it.sev, title: t('sev.' + it.sev), 'aria-label': t('sev.' + it.sev) }, '!') : null,
it.count !== undefined ? el('span', { class: 'count' }, String(it.count)) : null,
);
li.append(row);
@@ -459,6 +500,8 @@ function mapStyle() {
} },
{ selector: ':parent.ghost', style: { 'border-style': 'dashed', 'background-opacity': 0.2 } },
{ selector: ':parent.hostbox', style: { 'border-width': 1.5, 'border-color': KIND.node.color, 'background-opacity': 0.25, color: T.text } },
{ selector: ':parent.sev-warning', style: { 'border-width': 1.5, 'border-color': T.warn, color: T.warn } },
{ selector: ':parent.sev-critical', style: { 'border-width': 1.5, 'border-color': T.error, color: T.error } },
{ selector: ':parent.group', style: { 'background-opacity': 0, 'border-width': 0, 'font-size': 13, color: T.text } },
{ selector: 'node:childless:selected', style: { 'border-width': 2, 'border-color': T.accent, 'border-opacity': 1 } },
{ selector: 'edge', style: {
@@ -487,7 +530,7 @@ function cardNode(n, parent, ghost) {
group: 'nodes', classes: ghost ? 'ghostcard' : '',
data: {
id: n.id, ref: n.id, parent, kind: n.kind, w: size.w, h: size.h,
img: cardImage({ kind: n.kind, title: n.label, sub: ghost ? n.namespace + ' · ' + KIND[n.kind].title : subline(n), health: ghost ? null : n.facts?.health, ghost, w: size.w, h: size.h }),
img: cardImage({ kind: n.kind, title: n.label, sub: ghost ? n.namespace + ' · ' + KIND[n.kind].title : subline(n), health: ghost ? null : n.facts?.health, ghost, w: size.w, h: size.h, badge: cardSev(n) }),
},
};
}
@@ -509,7 +552,8 @@ function externalNode(ep) {
},
};
}
const nsBox = (ns, ghost, parent) => ({ group: 'nodes', classes: ghost ? 'ghost' : '', data: { id: 'box:' + ns, label: ns, kind: 'nsbox', ns, w: 1, h: 1, img: 'none', lmx: 0, parent } });
const sevClass = (sev) => (sev ? ' sev-' + sev : '');
const nsBox = (ns, ghost, parent) => ({ group: 'nodes', classes: ghost ? 'ghost' : sevClass(nsSeverity(ns)).trim(), data: { id: 'box:' + ns, label: ns, kind: 'nsbox', ns, w: 1, h: 1, img: 'none', lmx: 0, parent } });
function scopeNamespaces() {
if (state.scope.mode === 'ns') return state.scope.ns;
@@ -552,7 +596,7 @@ function buildElements() {
} else {
const host = state.scope.node;
members = [...(G.onNode.get(host) || [])].map((id) => G.byId.get(id)).filter(Boolean);
add({ group: 'nodes', classes: 'hostbox', data: { id: 'host:' + host, label: t('node', { name: host }), kind: 'hostbox', w: 1, h: 1, img: 'none', lmx: 0 } });
add({ group: 'nodes', classes: 'hostbox' + sevClass(cardSev(G.byId.get('node/' + host))), data: { id: 'host:' + host, label: t('node', { name: host }), kind: 'hostbox', w: 1, h: 1, img: 'none', lmx: 0 } });
for (const ns of new Set(members.map((m) => m.namespace))) add(nsBox(ns, false, 'host:' + host));
}
const memberIds = new Set(members.map((m) => m.id));
@@ -636,6 +680,14 @@ async function refreshTraffic() {
}
setInterval(refreshTraffic, 30000);
function nsCardImage(ns) {
const objs = G.byNs.get(ns) || [];
const wl = objs.filter(hasPods).length;
const ing = objs.filter((o) => o.kind === 'ingress').length;
const svc = objs.filter((o) => o.kind === 'service').length;
const sub = `${wl} workload · ${svc} svc · ${ing} ingress`;
return cardImage({ kind: 'namespace', title: ns, sub, health: nsHealth(ns), ghost: false, w: NSCARD.w, h: NSCARD.h, badge: nsSeverity(ns) });
}
function buildClusterElements() {
const els = [];
const groups = [
@@ -649,15 +701,10 @@ function buildClusterElements() {
const cols = Math.max(2, Math.min(8, Math.round(Math.sqrt(list.length * aspect * (NSCARD.h + gapY) / (NSCARD.w + gapX)) * 1.4)));
els.push({ group: 'nodes', classes: 'group', data: { id: gid, label, kind: 'group', w: 1, h: 1, img: 'none', lmx: 0 } });
list.forEach((n, i) => {
const objs = G.byNs.get(n.label) || [];
const wl = objs.filter(hasPods).length;
const ing = objs.filter((o) => o.kind === 'ingress').length;
const svc = objs.filter((o) => o.kind === 'service').length;
const sub = `${wl} workload · ${svc} svc · ${ing} ingress`;
els.push({
group: 'nodes', position: { x: (i % cols) * (NSCARD.w + gapX), y: y0 + Math.floor(i / cols) * (NSCARD.h + gapY) },
data: { id: 'nscard:' + n.label, ns: n.label, parent: gid, kind: 'nscard', w: NSCARD.w, h: NSCARD.h,
img: cardImage({ kind: 'namespace', title: n.label, sub, health: nsHealth(n.label), ghost: false, w: NSCARD.w, h: NSCARD.h }) },
img: nsCardImage(n.label) },
});
});
y0 += Math.ceil(list.length / cols) * (NSCARD.h + gapY) + 90;
@@ -700,6 +747,14 @@ async function layoutLevel(container, edges, aspect) {
const s = owner.get(e.source().id()), t = owner.get(e.target().id());
if (s && t && s !== t) lifted.set(s + '>' + t, { id: 'l' + lifted.size, sources: [s], targets: [t] });
});
// Cards of one size and no edges between them: nothing for ELK to rank,
// and each ELK call costs ~8 ms even for one card, which on a node view
// with 40 small namespaces was most of the layout time. packGrid gives
// the grid ELK would. Boxes of mixed sizes still go to ELK, whose
// packing of those is tighter than a grid.
if (!lifted.size && blocks.every((b) => !b.inner && b.w === blocks[0].w && b.h === blocks[0].h)) {
return packGrid(blocks, aspect, container ? 22 : 48);
}
const graph = {
id: 'root',
layoutOptions: {
@@ -722,6 +777,21 @@ async function layoutLevel(container, edges, aspect) {
for (const b of blocks) { const p = pos.get(b.node.id()); b.x = p.x; b.y = p.y; }
return { blocks, w: out.width, h: out.height };
}
// A row-major grid of equal blocks with the column count whose width to
// height is closest to the requested aspect ratio: what ELK's component
// packing produces for unconnected cards, measured on 2 to 20 of them.
function packGrid(blocks, aspect, gap) {
const { w, h } = blocks[0];
let best = 1, bestDiff = Infinity;
for (let cols = 1; cols <= blocks.length; cols++) {
const rows = Math.ceil(blocks.length / cols);
const diff = Math.abs((cols * (w + gap) - gap) / (rows * (h + gap) - gap) - aspect);
if (diff < bestDiff) { best = cols; bestDiff = diff; }
}
blocks.forEach((b, i) => { b.x = (i % best) * (w + gap); b.y = Math.floor(i / best) * (h + gap); });
const rows = Math.ceil(blocks.length / best);
return { blocks, w: best * (w + gap) - gap, h: rows * (h + gap) - gap };
}
function place(plan, ox, oy) {
for (const b of plan.blocks) {
const x = ox + b.x, y = oy + b.y;
@@ -876,6 +946,7 @@ cy.on('tap', 'node', (e) => {
if (d.kind === 'nscard') { scopeNs(d.ns); return; }
if (e.target.isParent()) {
if (d.kind === 'nsbox' && !(state.scope.mode === 'ns' && state.scope.ns.includes(d.ns))) scopeNs(d.ns);
if (d.kind === 'hostbox') openDetails('node/' + d.id.slice('host:'.length));
return;
}
if (G.byId.has(d.ref)) {
@@ -944,6 +1015,7 @@ function renderLegend() {
l.replaceChildren(
el('span', {}, t('legend.cluster')),
...['ok', 'warn', 'error', 'idle'].map((h) => el('span', {}, el('span', { class: 'dot ' + h }), HEALTH_TEXT[h])),
...badgeLegend(),
);
return;
}
@@ -953,8 +1025,12 @@ function renderLegend() {
el('span', {}, el('span', { class: 'line drop' }), t('legend.drop')),
el('span', {}, t('legend.ghost')),
el('span', {}, t('legend.notCollected')),
...badgeLegend(),
);
}
function badgeLegend() {
return ['warning', 'critical'].map((sev) => el('span', {}, el('span', { class: 'pbadge ' + sev, 'aria-hidden': 'true' }, '!'), t('legend.' + sev)));
}
/* ---------- details panel ---------- */
const yamlCache = new Map();
@@ -968,10 +1044,11 @@ $('#d-close').addEventListener('click', () => { state.selected = null; cy.$(':se
function setTab(name) {
for (const t of document.querySelectorAll('.tabs [role="tab"]')) t.setAttribute('aria-selected', String(t.dataset.tab === name));
for (const p of document.querySelectorAll('.tab-panel')) p.hidden = p.dataset.panel !== name;
for (const p of $('#details').querySelectorAll('.tab-panel')) p.hidden = p.dataset.panel !== name;
const n = G.byId.get(detailsId);
if (name === 'yaml' && n) loadYaml(n);
if (name === 'logs' && n) loadPods(n);
if (name === 'events' && detailsId) loadEvents(detailsId);
}
for (const t of document.querySelectorAll('.tabs [role="tab"]')) t.addEventListener('click', () => setTab(t.dataset.tab));
@@ -1008,28 +1085,15 @@ const FACT_LABELS = {
function openDetails(id) {
const n = G.byId.get(id);
if (!n) return;
closeProblems();
detailsId = id;
showPanelHead(n.kind, n.label, n.namespace ? t('details.namespace', { ns: n.namespace }) : '');
const foreign = n.facts?.foreign === 'true';
tabVisible('yaml', !foreign);
tabVisible('logs', hasPods(n));
const panel = document.querySelector('[data-panel="overview"]');
const dl = el('dl', { class: 'facts' });
const h = n.facts?.health;
if (h) dl.append(el('dt', {}, t('details.state')), el('dd', {}, el('span', { class: 'status' }, el('span', { class: 'dot ' + h }), HEALTH_TEXT[h])));
for (const [k, v] of Object.entries(n.facts || {})) {
if (k === 'health' || k === 'system' || k === 'foreign' || v === '') continue;
dl.append(el('dt', {}, FACT_LABELS[k] || k), el('dd', {}, v));
}
const parts = [dl];
const hosts = [...(G.placement.get(id) || [])].sort();
if (hosts.length) {
parts.push(el('div', { class: 'section-title' }, t('details.runsOn')),
el('ul', { class: 'link-list' }, hosts.map((host) => el('li', {}, el('button', { type: 'button', onclick: () => scopeNode(host) },
el('span', { html: iconSvg('node') }).firstChild, host)))));
}
panel.replaceChildren(...parts);
tabVisible('events', true);
renderOverview(n);
renderActions(n);
renderLinks(id);
$('#d-yaml').textContent = '';
$('#d-logs').textContent = '';
@@ -1037,11 +1101,142 @@ function openDetails(id) {
setTab(document.querySelector(`.tabs [data-tab="${active}"]`).hidden ? 'overview' : active);
}
// A sentence first, for whoever just wants to know whether it works; the
// facts, problems and load below it are for whoever has to fix it.
function summaryLine(n) {
const ps = (n.problems || []).filter((p) => p.severity !== 'info');
const crit = ps.filter((p) => p.severity === 'critical').length;
const sev = badgeSev(n.problems);
if (ps.length) {
return el('p', { class: 'summary ' + sev }, el('span', { class: 'pbadge ' + sev, 'aria-hidden': 'true' }, '!'),
crit ? t('summary.critical', { n: t('plural.problem', { n: ps.length }) }) : t('summary.warning', { n: t('plural.problem', { n: ps.length }) }));
}
const h = n.facts?.health;
if (h === 'idle') return el('p', { class: 'summary idle' }, t('summary.idle'));
if (h && h !== 'ok') return el('p', { class: 'summary warning' }, HEALTH_TEXT[h]);
return el('p', { class: 'summary ok' }, t('summary.ok'));
}
function problemItem(p, n, withTarget) {
const text = problemText(p);
const detail = [p.object && !text.includes(p.object) ? p.object : '', p.message].filter(Boolean).join(' — ');
const body = [
el('span', { class: 'pbadge ' + p.severity, 'aria-label': t('sev.' + p.severity) }, p.severity === 'info' ? 'i' : '!'),
el('span', { class: 'p-body' },
withTarget ? el('span', { class: 'p-target' }, n ? el('span', { html: iconSvg(n.kind) }).firstChild : null,
n ? (n.kind === 'namespace' ? n.label : `${n.label}`) : t('problems.cluster'),
n?.namespace ? el('span', { class: 'muted' }, ' · ' + n.namespace) : null) : null,
el('span', { class: 'p-reason' }, text, p.source === 'alert' ? el('span', { class: 'p-src' }, t('problems.alert')) : null,
p.count > 1 ? el('span', { class: 'muted' }, ' ×' + p.count) : null),
detail ? el('span', { class: 'p-msg muted' }, detail) : null),
p.since ? el('span', { class: 'meta muted small' }, ago(p.since)) : null,
];
if (!withTarget || !n) return el('li', { class: 'problem ' + p.severity }, el('div', { class: 'p-row' }, body));
return el('li', { class: 'problem ' + p.severity }, el('button', { type: 'button', class: 'p-row', onclick: () => goTo(n) }, body));
}
function renderOverview(n) {
const id = n.id;
const panel = document.querySelector('[data-panel="overview"]');
const dl = el('dl', { class: 'facts' });
const h = n.facts?.health;
if (h) dl.append(el('dt', {}, t('details.state')), el('dd', {}, el('span', { class: 'status' }, el('span', { class: 'dot ' + h }), HEALTH_TEXT[h])));
for (const [k, v] of Object.entries(n.facts || {})) {
if (k === 'health' || k === 'system' || k === 'foreign' || k === 'unschedulable' || v === '') continue;
dl.append(el('dt', {}, FACT_LABELS[k] || k), el('dd', {}, v));
}
const parts = [summaryLine(n)];
if (n.problems?.length) {
parts.push(el('div', { class: 'section-title' }, t('details.problems')),
el('ul', { class: 'problem-list' }, n.problems.map((p) => problemItem(p, n, false))));
}
parts.push(dl);
if (hasPods(n) || n.kind === 'node') parts.push(el('div', { class: 'section-title' }, t('usage.title')), el('div', { id: 'd-usage' }, el('p', { class: 'muted small' }, t('loading'))));
const hosts = [...(G.placement.get(id) || [])].sort();
if (hosts.length) {
parts.push(el('div', { class: 'section-title' }, t('details.runsOn')),
el('ul', { class: 'link-list' }, hosts.map((host) => el('li', {}, el('button', { type: 'button', onclick: () => scopeNode(host) },
el('span', { html: iconSvg('node') }).firstChild, host)))));
}
panel.replaceChildren(...parts);
if (hasPods(n) || n.kind === 'node') loadUsage(n);
}
/* ---------- usage ---------- */
const fmtCPU = (m) => (m >= 1000 ? `${(m / 1000).toFixed(m >= 10000 ? 0 : 1)}` : `${m}m`);
function fmtBytes(b) {
const u = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
let i = 0;
while (b >= 1024 && i < u.length - 1) { b /= 1024; i++; }
return `${b >= 100 || i === 0 ? Math.round(b) : b.toFixed(1)} ${u[i]}`;
}
function usageRow(label, a, fmt, metrics) {
const ceiling = a.capacity || a.limit || a.request || 0;
const bits = [];
if (a.request) bits.push(t('usage.request', { v: fmt(a.request) }));
if (a.limit) bits.push(t('usage.limit', { v: fmt(a.limit) }));
if (a.capacity) bits.push(t('usage.capacity', { v: fmt(a.capacity) }));
const used = metrics && a.usage !== null ? fmt(a.usage) : '—';
const row = el('div', { class: 'usage-row' },
el('div', { class: 'usage-head' }, el('span', {}, label), el('strong', {}, used), el('span', { class: 'muted small' }, bits.join(' · '))));
if (metrics && a.usage !== null && ceiling) {
const m = el('meter', { min: '0', max: String(ceiling), value: String(Math.min(a.usage, ceiling)), low: String(ceiling * 0.7), high: String(ceiling * 0.9), optimum: '0' });
row.append(m);
}
return row;
}
async function loadUsage(n) {
const r = await fetch('/api/usage?' + new URLSearchParams({ id: n.id }));
const box = $('#d-usage');
if (detailsId !== n.id || !box) return;
if (!r.ok) { box.replaceChildren(el('p', { class: 'muted small' }, t('usage.failed', { code: r.status }))); return; }
const u = await r.json();
const parts = [usageRow('CPU', u.cpu, fmtCPU, u.metrics), usageRow(t('usage.memory'), u.memory, fmtBytes, u.metrics)];
if (!u.metrics) parts.push(el('p', { class: 'muted small' }, t('usage.noMetrics')));
if (u.pods.length) {
const canDelete = await podDeleteAllowed(n);
const table = el('table', { class: 'pods' },
el('thead', {}, el('tr', {}, ...[t('usage.pod'), t('usage.restarts'), 'CPU', t('usage.memory'), ''].map((h) => el('th', {}, h)))),
el('tbody', {}, u.pods.map((pod) => el('tr', {},
el('td', {}, el('span', { class: 'dot ' + (pod.ready ? 'ok' : 'warn'), title: pod.ready ? t('usage.ready') : t('usage.notReady') }), ' ', pod.name,
el('div', { class: 'muted small' }, pod.node)),
el('td', { class: pod.restarts ? 'warn-text' : '' }, String(pod.restarts)),
el('td', {}, pod.cpu === null ? '—' : fmtCPU(pod.cpu)),
el('td', {}, pod.memory === null ? '—' : fmtBytes(pod.memory)),
el('td', {}, canDelete ? el('button', { type: 'button', class: 'btn small', title: t('action.deletePodHint'),
onclick: () => askAction({ action: 'delete-pod', kind: 'pod', namespace: n.namespace, name: pod.name }, n) }, t('action.delete-pod')) : null),
))));
parts.push(table);
}
if (detailsId === n.id) box.replaceChildren(...parts);
}
/* ---------- events ---------- */
async function loadEvents(id) {
const panel = document.querySelector('[data-panel="events"]');
panel.replaceChildren(el('p', { class: 'muted' }, t('loading')));
const r = await fetch('/api/events?' + new URLSearchParams({ id }));
if (detailsId !== id) return;
if (!r.ok) { panel.replaceChildren(el('p', { class: 'muted' }, t('events.failed', { code: r.status }))); return; }
const list = await r.json();
if (!list.length) { panel.replaceChildren(el('p', { class: 'muted' }, t('events.none'))); return; }
panel.replaceChildren(el('ul', { class: 'event-list' }, list.map((e) => el('li', { class: e.type === 'Warning' ? 'warning' : '' },
el('div', { class: 'ev-head' },
el('span', { class: 'ev-reason' }, e.reason),
e.count > 1 ? el('span', { class: 'muted small' }, '×' + e.count) : null,
el('span', { class: 'muted small ev-time', title: e.last }, ago(e.last))),
el('div', { class: 'ev-msg' }, e.message),
el('div', { class: 'muted small' }, e.object)))));
}
function openExternalDetails(ep) {
detailsId = ep.id;
showPanelHead(ep.namespace ? (KIND[ep.kind] ? ep.kind : 'pod') : 'external', ep.label, ep.namespace ? t('details.namespace', { ns: ep.namespace }) : t('details.outside'));
closeProblems();
tabVisible('yaml', false);
tabVisible('logs', false);
tabVisible('events', false);
$('#d-actions').replaceChildren();
document.querySelector('[data-panel="overview"]').replaceChildren(
el('p', { class: 'muted' }, ep.namespace
? t('details.ghostPod')
@@ -1137,6 +1332,250 @@ async function loadLogs() {
}
$('#logs-reload').addEventListener('click', loadLogs);
/* ---------- actions ---------- */
// Buttons appear only for what the viewer's own RBAC allows: the server
// asks the API server with the viewer's token and runs the action with it.
let me = null;
const ACTIONS = {
deployment: ['restart', 'scale'],
statefulset: ['restart', 'scale'],
daemonset: ['restart'],
cronjob: ['run', 'suspend', 'resume'],
node: ['cordon', 'uncordon'],
};
const actionTarget = (n) => ({ kind: n.kind, namespace: n.namespace || '', name: n.label });
const permCache = new Map();
async function permissions(kind, namespace, name) {
const key = [kind, namespace, name].join('/');
if (permCache.has(key)) return permCache.get(key);
const r = await fetch('/api/permissions?' + new URLSearchParams({ kind, namespace, name }));
const allowed = r.ok ? (await r.json()).allowed : {};
permCache.set(key, allowed);
return allowed;
}
const actionsUsable = () => me?.actionsEnabled && me.user;
async function podDeleteAllowed(n) {
if (!actionsUsable() || !n.namespace) return false;
return !!(await permissions('pod', n.namespace, ''))['delete-pod'];
}
async function renderActions(n) {
const box = $('#d-actions');
box.replaceChildren();
const list = ACTIONS[n.facts?.foreign === 'true' ? '' : n.kind];
if (!list || !me?.actionsEnabled) return;
if (!me.user) { box.append(el('span', { class: 'muted small' }, t('action.unavailable.' + (me.reason || 'noToken')))); return; }
const allowed = await permissions(n.kind, n.namespace || '', n.label);
if (detailsId !== n.id) return;
const suspended = n.facts?.suspended === 'true', cordoned = n.facts?.unschedulable === 'true';
const shown = list.filter((a) => !(a === 'suspend' && suspended) && !(a === 'resume' && !suspended) && !(a === 'cordon' && cordoned) && !(a === 'uncordon' && !cordoned));
const buttons = shown.filter((a) => allowed[a]).map((a) => el('button', { type: 'button', class: 'btn small', onclick: () => askAction({ action: a, ...actionTarget(n) }, n) }, t('action.' + a)));
box.replaceChildren(...(buttons.length ? buttons : [el('span', { class: 'muted small' }, t('action.noRights'))]));
}
const dialog = $('#confirm');
function confirmDialog({ title, text, ok, danger, value }) {
return new Promise((resolve) => {
$('#confirm-title').textContent = title;
$('#confirm-text').textContent = text;
const row = $('#confirm-input-row'), input = $('#confirm-input');
row.hidden = value === undefined;
if (value !== undefined) input.value = String(value);
const okBtn = $('#confirm-ok');
okBtn.textContent = ok;
okBtn.classList.toggle('danger', !!danger);
const done = (result) => { dialog.close(); resolve(result); };
okBtn.onclick = () => done({ ok: true, value: Number(input.value) });
$('#confirm-cancel').onclick = () => done({ ok: false });
dialog.onclose = () => resolve({ ok: false });
dialog.showModal();
(value !== undefined ? input : $('#confirm-cancel')).focus();
});
}
async function askAction(req, n) {
const target = req.kind === 'pod' ? req.name : `${KIND[n.kind]?.title || n.kind} ${n.label}`;
const scale = req.action === 'scale';
const current = Number(n.facts?.replicas ?? 1);
const answer = await confirmDialog({
title: t('action.' + req.action) + ' · ' + target,
text: t('confirm.' + req.action, { target, ns: n.namespace || '' }),
ok: t('action.' + req.action),
danger: ['delete-pod', 'cordon', 'suspend'].includes(req.action),
value: scale ? current : undefined,
});
if (!answer.ok) return;
if (scale) {
if (!Number.isInteger(answer.value) || answer.value < 0 || answer.value > 100) { toast(t('action.badReplicas'), true); return; }
req.replicas = answer.value;
}
const r = await fetch('/api/action', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(req) });
const body = (await r.text()).trim();
if (!r.ok) { toast(t('action.failed', { err: body || 'HTTP ' + r.status }), true); return; }
toast(t('action.done', { what: t('action.' + req.action), target }));
permCache.clear();
setTimeout(() => refreshGraph(true), 1500);
}
/* ---------- toast ---------- */
let toastTimer;
function toast(text, isError = false) {
const box = $('#toast');
box.textContent = text;
box.classList.toggle('error', isError);
box.hidden = false;
clearTimeout(toastTimer);
toastTimer = setTimeout(() => { box.hidden = true; }, isError ? 9000 : 5000);
}
/* ---------- problems panel ---------- */
let problemsScope = 'all';
const problemsPanel = $('#problems-panel');
function problemNs(x) {
if (!x.n) return null;
return x.n.kind === 'namespace' ? x.n.label : x.n.namespace || null;
}
function inProblemsScope(x) {
if (problemsScope === 'all') return true;
const ns = problemNs(x);
const system = !ns || isSystemNs(ns);
return problemsScope === 'system' ? system : !system;
}
function renderProblemsButton() {
const all = allProblems().filter((x) => x.p.severity !== 'info');
const btn = $('#problems-btn');
if (!all.length) {
btn.hidden = false;
btn.className = 'btn problems-btn ok';
btn.textContent = t('problems.none');
return;
}
const crit = all.filter((x) => x.p.severity === 'critical').length;
btn.hidden = false;
btn.className = 'btn problems-btn ' + (crit ? 'critical' : 'warning');
btn.replaceChildren(el('span', { class: 'pbadge ' + (crit ? 'critical' : 'warning'), 'aria-hidden': 'true' }, '!'), t('problems.button', { n: all.length }));
}
function openProblems() {
closeDetails();
problemsPanel.hidden = false;
$('#problems-btn').setAttribute('aria-expanded', 'true');
renderProblems();
requestAnimationFrame(() => cy.resize());
}
function closeProblems() {
if (problemsPanel.hidden) return;
problemsPanel.hidden = true;
$('#problems-btn').setAttribute('aria-expanded', 'false');
requestAnimationFrame(() => cy.resize());
}
function renderProblems() {
const list = allProblems().filter(inProblemsScope);
const badged = list.filter((x) => x.p.severity !== 'info');
const info = list.filter((x) => x.p.severity === 'info');
const crit = badged.filter((x) => x.p.severity === 'critical').length;
$('#p-sub').textContent = badged.length
? t('problems.sub', { crit: t('plural.critical', { n: crit }), warn: t('plural.warning', { n: badged.length - crit }) })
: t('problems.allGood');
const parts = [];
if (badged.length) parts.push(el('ul', { class: 'problem-list' }, badged.map((x) => problemItem(x.p, x.n, true))));
else parts.push(el('p', { class: 'summary ok' }, t('problems.allGood')));
if (info.length) {
parts.push(el('details', { class: 'p-info' }, el('summary', {}, t('problems.info', { n: info.length })),
el('ul', { class: 'problem-list' }, info.map((x) => problemItem(x.p, x.n, true)))));
}
if (G.raw && !G.raw.alertsAvailable) parts.push(el('p', { class: 'muted small' }, t('problems.noAlerts')));
$('#p-list').replaceChildren(...parts);
}
function goTo(n) {
if (n.kind === 'namespace') { scopeNs(n.label); return; }
if (n.kind === 'node') { scopeNode(n.label); openDetails(n.id); return; }
selectObject(n.id);
}
$('#problems-btn').addEventListener('click', () => (problemsPanel.hidden ? openProblems() : closeProblems()));
$('#p-close').addEventListener('click', closeProblems);
for (const b of document.querySelectorAll('.p-filter [role="tab"]')) {
b.addEventListener('click', () => {
problemsScope = b.dataset.scope;
for (const x of document.querySelectorAll('.p-filter [role="tab"]')) x.setAttribute('aria-selected', String(x === b));
renderProblems();
});
}
/* ---------- lock, export ---------- */
// Cards are locked by default so a stray drag does not rearrange the map;
// the padlock unlocks them until it is clicked again.
let locked = true;
const LOCK_ICON = {
true: '<svg viewBox="0 0 20 20" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" aria-hidden="true"><rect x="4" y="9" width="12" height="8" rx="1.5"/><path d="M7 9V6.5a3 3 0 0 1 6 0V9"/></svg>',
false: '<svg viewBox="0 0 20 20" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" aria-hidden="true"><rect x="4" y="9" width="12" height="8" rx="1.5"/><path d="M7 9V6.5a3 3 0 0 1 5.8-1"/></svg>',
};
function applyLock() {
cy.autoungrabify(locked);
const b = $('#lock');
b.innerHTML = LOCK_ICON[locked];
b.setAttribute('aria-pressed', String(locked));
b.title = t(locked ? 'html.lockedTitle' : 'html.unlockedTitle');
b.classList.toggle('unlocked', !locked);
}
$('#lock').addEventListener('click', () => { locked = !locked; applyLock(); toast(t(locked ? 'lock.on' : 'lock.off')); });
$('#export-png').addEventListener('click', () => {
try {
const blob = cy.png({ output: 'blob', full: true, scale: 2, maxWidth: 8000, maxHeight: 8000, bg: getComputedStyle(document.body).backgroundColor });
const scope = state.scope.mode === 'ns' ? state.scope.ns.join('+') : state.scope.mode === 'node' ? state.scope.node : 'cluster';
const d = new Date(), p2 = (x) => String(x).padStart(2, '0');
const stamp = `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())}-${p2(d.getHours())}${p2(d.getMinutes())}`;
const a = el('a', { href: URL.createObjectURL(blob), download: `cluster-map-${scope}-${stamp}.png` });
document.body.append(a);
a.click();
a.remove();
setTimeout(() => URL.revokeObjectURL(a.href), 10000);
} catch (err) {
toast(t('png.failed', { err: err.message }), true);
}
});
/* ---------- background refresh ---------- */
// Every minute the graph is re-read and cards, boxes, the tree and the
// Problems panel are redrawn in place. The layout is left alone; new or
// removed objects appear with the Refresh button.
async function refreshGraph(force = false) {
if (document.hidden && !force) return;
let raw;
try {
const r = await fetch('/api/graph');
if (!r.ok) return;
raw = await r.json();
} catch { return; }
indexGraph(raw);
$('#updated').textContent = t('updated', { time: new Date().toLocaleTimeString(LANG, { hour: '2-digit', minute: '2-digit' }) });
renderTree();
renderProblemsButton();
if (!problemsPanel.hidden) renderProblems();
cy.batch(() => {
cy.nodes().forEach((x) => {
const d = x.data();
if (d.kind === 'nscard') { x.data('img', nsCardImage(d.ns)); return; }
if (d.kind === 'nsbox') {
x.removeClass('sev-warning sev-critical');
if (!x.hasClass('ghost')) x.addClass(sevClass(nsSeverity(d.ns)).trim());
return;
}
if (d.kind === 'hostbox') {
x.removeClass('sev-warning sev-critical');
x.addClass(sevClass(cardSev(G.byId.get('node/' + d.id.slice('host:'.length)))).trim());
return;
}
const n = G.byId.get(d.ref);
if (n && !x.isParent()) x.data('img', cardNode(n, d.parent, x.hasClass('ghostcard')).data.img);
});
});
const n = detailsId && G.byId.get(detailsId);
if (n && !$('#details').hidden && document.querySelector('.tabs [data-tab="overview"]').getAttribute('aria-selected') === 'true') {
renderOverview(n);
renderActions(n);
}
}
setInterval(refreshGraph, 60000);
/* ---------- top bar ---------- */
$('#traffic-on').addEventListener('change', (e) => { state.traffic = e.target.checked; renderMap(); });
$('#traffic-window').addEventListener('change', (e) => { state.trafficWindow = Number(e.target.value); if (state.traffic) renderMap(); });
@@ -1161,6 +1600,8 @@ async function load() {
if (state.selected && !G.byId.has(state.selected)) state.selected = null;
$('#updated').textContent = t('updated', { time: new Date().toLocaleTimeString(LANG, { hour: '2-digit', minute: '2-digit' }) });
if (state.selected) revealInTree(state.selected);
renderProblemsButton();
if (!problemsPanel.hidden) renderProblems();
await renderMap();
if (state.selected) { openDetails(state.selected); focusOnMap(state.selected); }
}
@@ -1182,4 +1623,11 @@ cy.style(mapStyle());
readHash();
$('#view-ns').setAttribute('aria-selected', String(state.treeView === 'ns'));
$('#view-nodes').setAttribute('aria-selected', String(state.treeView === 'nodes'));
applyLock();
fetch('/api/me').then((r) => (r.ok ? r.json() : null)).then((m) => {
me = m;
if (me?.user) $('#whoami').textContent = me.user;
const n = detailsId && G.byId.get(detailsId);
if (n) renderActions(n);
}).catch(() => {});
load();
+106
View File
@@ -57,6 +57,59 @@ const I18N = {
'html.details': 'Object details', 'html.close': 'Close panel', 'html.sections': 'Sections',
'html.overview': 'Overview', 'html.links': 'Links', 'html.logs': 'Logs', 'html.pod': 'Pod', 'html.container': 'Container',
'html.view': 'Current view', 'html.lang': 'Language',
'html.lock': 'Lock card positions', 'html.lockedTitle': 'Cards are locked. Click to move them', 'html.unlockedTitle': 'Cards can be dragged. Click to lock',
'html.exportPng': 'Save the map as a picture', 'html.actions': 'Actions', 'html.events': 'Events',
'html.problems': 'Problems', 'html.problemsScope': 'Which problems', 'html.scopeAll': 'All',
'lock.on': 'Cards are locked', 'lock.off': 'Cards unlocked: drag them, then lock again',
'png.failed': 'could not save the picture: {err}',
'sev.critical': 'error', 'sev.warning': 'warning', 'sev.info': 'for information',
'legend.warning': 'warning', 'legend.critical': 'error',
'ago': '{d} ago',
'summary.ok': 'Everything works', 'summary.idle': 'Stopped: nothing is supposed to run',
'summary.critical': 'Not working properly: {n}', 'summary.warning': 'Works, with {n}',
'plural.problem': { one: '{n} problem', other: '{n} problems' },
'plural.critical': { one: '{n} error', other: '{n} errors' },
'plural.warning': { one: '{n} warning', other: '{n} warnings' },
'details.problems': 'Problems',
'problems.none': 'No problems', 'problems.button': 'Problems: {n}', 'problems.cluster': 'Cluster',
'problems.alert': 'alert', 'problems.sub': '{crit}, {warn}', 'problems.allGood': 'No problems right now.',
'problems.info': 'For information, no badge: {n}',
'problems.noAlerts': 'Prometheus alerts are not shown: the ClusterAlert resource is not served in this cluster.',
'problem.NotReady': 'No replica is ready', 'problem.PartlyReady': 'Not all replicas are ready',
'problem.CrashLoopBackOff': 'Container keeps crashing', 'problem.ImagePullBackOff': 'Image cannot be pulled',
'problem.ErrImagePull': 'Image cannot be pulled', 'problem.InvalidImageName': 'Invalid image name',
'problem.CreateContainerConfigError': 'Container configuration error (a missing Secret or ConfigMap?)',
'problem.CreateContainerError': 'Container cannot be created', 'problem.RunContainerError': 'Container cannot be started',
'problem.OOMKilled': 'Killed for running out of memory', 'problem.Restarted': 'Restarted recently',
'problem.Pending': 'Pod has been pending for over 5 minutes', 'problem.Unschedulable': 'Pod cannot be scheduled',
'problem.Evicted': 'Pod was evicted', 'problem.ProgressDeadlineExceeded': 'Rollout is stuck',
'problem.LastRunFailed': 'Last run did not succeed', 'problem.NoEndpoints': 'No ready pod behind the Service',
'problem.BackendMissing': 'Routes to a Service that does not exist', 'problem.NodeNotReady': 'Node is not ready',
'problem.MemoryPressure': 'Node is short of memory', 'problem.DiskPressure': 'Node is short of disk',
'problem.PIDPressure': 'Node is short of process IDs', 'problem.Cordoned': 'Node is cordoned: no new pods',
'usage.title': 'Load', 'usage.memory': 'Memory', 'usage.request': 'request {v}', 'usage.limit': 'limit {v}',
'usage.capacity': 'of {v}', 'usage.failed': 'could not read the load: HTTP {code}',
'usage.noMetrics': 'Current usage is unknown: the metrics.k8s.io API did not answer.',
'usage.pod': 'Pod', 'usage.restarts': 'Restarts', 'usage.ready': 'ready', 'usage.notReady': 'not ready',
'events.failed': 'could not read events: HTTP {code}', 'events.none': 'No events in the last hour.',
'action.restart': 'Restart', 'action.scale': 'Scale', 'action.run': 'Run now', 'action.suspend': 'Suspend',
'action.resume': 'Resume', 'action.cordon': 'Cordon', 'action.uncordon': 'Uncordon', 'action.delete-pod': 'Delete',
'action.deletePodHint': 'Delete this pod; its controller starts a new one',
'action.cancel': 'Cancel', 'action.replicas': 'Replicas',
'action.noRights': 'Your role allows no actions here.',
'action.unavailable.noToken': 'Actions need the user token from the DexAuthenticator; it is not in the request.',
'action.unavailable.rejected': 'The API server did not accept your token; sign in again.',
'action.unavailable.disabled': '',
'action.badReplicas': 'Replicas must be a whole number from 0 to 100.',
'action.failed': 'Not done: {err}', 'action.done': '{what}: {target} — done',
'confirm.restart': 'All pods of {target} are replaced one by one, as with kubectl rollout restart.',
'confirm.scale': 'How many replicas should {target} run?',
'confirm.run': 'A Job is created from the {target} template right now, outside the schedule.',
'confirm.suspend': 'No new runs of {target} start until it is resumed.',
'confirm.resume': '{target} runs on its schedule again.',
'confirm.cordon': 'No new pods are scheduled on {target}. Running pods stay.',
'confirm.uncordon': 'New pods can be scheduled on {target} again.',
'confirm.delete-pod': 'Pod {target} in {ns} is deleted; its controller starts a new one.',
},
ru: {
'kind.pod': 'Контроллер', 'kind.external': 'Внешний', 'folder.pod': 'Другие контроллеры',
@@ -111,6 +164,59 @@ const I18N = {
'html.details': 'Детали объекта', 'html.close': 'Закрыть панель', 'html.sections': 'Разделы',
'html.overview': 'Обзор', 'html.links': 'Связи', 'html.logs': 'Логи', 'html.pod': 'Под', 'html.container': 'Контейнер',
'html.view': 'Текущий вид', 'html.lang': 'Язык',
'html.lock': 'Закрепить карточки', 'html.lockedTitle': 'Карточки закреплены. Нажмите, чтобы двигать', 'html.unlockedTitle': 'Карточки можно перетаскивать. Нажмите, чтобы закрепить',
'html.exportPng': 'Сохранить карту картинкой', 'html.actions': 'Действия', 'html.events': 'События',
'html.problems': 'Проблемы', 'html.problemsScope': 'Какие проблемы', 'html.scopeAll': 'Все',
'lock.on': 'Карточки закреплены', 'lock.off': 'Карточки откреплены: передвиньте и закрепите снова',
'png.failed': 'не удалось сохранить картинку: {err}',
'sev.critical': 'ошибка', 'sev.warning': 'предупреждение', 'sev.info': 'для сведения',
'legend.warning': 'предупреждение', 'legend.critical': 'ошибка',
'ago': '{d} назад',
'summary.ok': 'Всё работает', 'summary.idle': 'Остановлено: ничего не должно работать',
'summary.critical': 'Работает с ошибками: {n}', 'summary.warning': 'Работает, но есть {n}',
'plural.problem': { one: '{n} проблема', few: '{n} проблемы', many: '{n} проблем', other: '{n} проблемы' },
'plural.critical': { one: '{n} ошибка', few: '{n} ошибки', many: '{n} ошибок', other: '{n} ошибки' },
'plural.warning': { one: '{n} предупреждение', few: '{n} предупреждения', many: '{n} предупреждений', other: '{n} предупреждения' },
'details.problems': 'Проблемы',
'problems.none': 'Проблем нет', 'problems.button': 'Проблемы: {n}', 'problems.cluster': 'Кластер',
'problems.alert': 'алерт', 'problems.sub': '{crit}, {warn}', 'problems.allGood': 'Сейчас проблем нет.',
'problems.info': 'Для сведения, без значка: {n}',
'problems.noAlerts': 'Алерты Prometheus не показаны: в кластере нет ресурса ClusterAlert.',
'problem.NotReady': 'Ни одна реплика не готова', 'problem.PartlyReady': 'Готовы не все реплики',
'problem.CrashLoopBackOff': 'Контейнер падает и перезапускается', 'problem.ImagePullBackOff': 'Не скачивается образ',
'problem.ErrImagePull': 'Не скачивается образ', 'problem.InvalidImageName': 'Неверное имя образа',
'problem.CreateContainerConfigError': 'Ошибка конфигурации контейнера (нет Secret или ConfigMap?)',
'problem.CreateContainerError': 'Контейнер не создаётся', 'problem.RunContainerError': 'Контейнер не запускается',
'problem.OOMKilled': 'Убит за нехватку памяти', 'problem.Restarted': 'Недавно перезапускался',
'problem.Pending': 'Под больше 5 минут ждёт запуска', 'problem.Unschedulable': 'Под некуда запустить',
'problem.Evicted': 'Под выселен с ноды', 'problem.ProgressDeadlineExceeded': 'Выкатка застряла',
'problem.LastRunFailed': 'Последний запуск не удался', 'problem.NoEndpoints': 'За сервисом нет готовых подов',
'problem.BackendMissing': 'Ведёт на несуществующий сервис', 'problem.NodeNotReady': 'Нода не готова',
'problem.MemoryPressure': 'На ноде не хватает памяти', 'problem.DiskPressure': 'На ноде не хватает диска',
'problem.PIDPressure': 'На ноде не хватает PID', 'problem.Cordoned': 'Нода закрыта для новых подов',
'usage.title': 'Нагрузка', 'usage.memory': 'Память', 'usage.request': 'запрос {v}', 'usage.limit': 'лимит {v}',
'usage.capacity': 'из {v}', 'usage.failed': 'не удалось получить нагрузку: HTTP {code}',
'usage.noMetrics': 'Текущее потребление неизвестно: API metrics.k8s.io не ответил.',
'usage.pod': 'Под', 'usage.restarts': 'Рестарты', 'usage.ready': 'готов', 'usage.notReady': 'не готов',
'events.failed': 'не удалось получить события: HTTP {code}', 'events.none': 'За последний час событий нет.',
'action.restart': 'Перезапустить', 'action.scale': 'Масштабировать', 'action.run': 'Запустить сейчас', 'action.suspend': 'Приостановить',
'action.resume': 'Возобновить', 'action.cordon': 'Закрыть для подов', 'action.uncordon': 'Открыть для подов', 'action.delete-pod': 'Удалить',
'action.deletePodHint': 'Удалить под; контроллер запустит новый',
'action.cancel': 'Отмена', 'action.replicas': 'Реплик',
'action.noRights': 'Ваша роль не разрешает здесь действий.',
'action.unavailable.noToken': 'Для действий нужен токен пользователя от DexAuthenticator, в запросе его нет.',
'action.unavailable.rejected': 'API-сервер не принял ваш токен, войдите заново.',
'action.unavailable.disabled': '',
'action.badReplicas': 'Число реплик — целое от 0 до 100.',
'action.failed': 'Не выполнено: {err}', 'action.done': '{what}: {target} — готово',
'confirm.restart': 'Все поды {target} заменяются по очереди, как при kubectl rollout restart.',
'confirm.scale': 'Сколько реплик должно работать у {target}?',
'confirm.run': 'Из шаблона {target} прямо сейчас создаётся Job, вне расписания.',
'confirm.suspend': 'Новые запуски {target} не начнутся, пока его не возобновят.',
'confirm.resume': '{target} снова запускается по расписанию.',
'confirm.cordon': 'На {target} не будут назначаться новые поды. Работающие остаются.',
'confirm.uncordon': 'На {target} снова можно назначать новые поды.',
'confirm.delete-pod': 'Под {target} в {ns} удаляется; контроллер запустит новый.',
},
};
+35 -1
View File
@@ -16,6 +16,7 @@
<div class="brand">cluster-map</div>
<nav class="crumbs" id="crumbs" data-i18n-attr="aria-label:html.view"></nav>
<div class="topbar-actions">
<button type="button" id="problems-btn" class="btn problems-btn" aria-controls="problems-panel" aria-expanded="false" hidden></button>
<label class="toggle"><input type="checkbox" id="traffic-on" checked> <span data-i18n="html.traffic"></span></label>
<select id="traffic-window" data-i18n-attr="aria-label:html.window">
<option value="300" data-i18n="html.min5"></option>
@@ -24,6 +25,7 @@
</select>
<button type="button" id="reload" class="btn" data-i18n="html.refresh"></button>
<span class="muted small" id="updated"></span>
<span class="muted small whoami" id="whoami"></span>
<select id="lang" data-i18n-attr="aria-label:html.lang">
<option value="en">EN</option>
<option value="ru">RU</option>
@@ -48,8 +50,11 @@
<div class="zoom" role="group" data-i18n-attr="aria-label:html.zoom">
<button type="button" class="btn icon" id="zoom-in" data-i18n-attr="aria-label:html.zoomIn">+</button>
<button type="button" class="btn icon" id="zoom-out" data-i18n-attr="aria-label:html.zoomOut">−</button>
<button type="button" class="btn icon" id="zoom-fit" data-i18n-attr="aria-label:html.fit">⤢</button>
<button type="button" class="btn icon" id="zoom-fit" data-i18n-attr="aria-label:html.fit;title:html.fit">⤢</button>
<button type="button" class="btn icon" id="lock" aria-pressed="true" data-i18n-attr="aria-label:html.lock;title:html.lockedTitle"></button>
<button type="button" class="btn icon" id="export-png" data-i18n-attr="aria-label:html.exportPng;title:html.exportPng">⤓</button>
</div>
<div class="toast" id="toast" role="status" aria-live="polite" hidden></div>
<div class="legend" id="legend"></div>
</main>
@@ -62,15 +67,18 @@
</div>
<button type="button" class="btn icon" id="d-close" data-i18n-attr="aria-label:html.close">×</button>
</div>
<div class="d-actions" id="d-actions" role="group" data-i18n-attr="aria-label:html.actions"></div>
<div class="tabs" role="tablist" data-i18n-attr="aria-label:html.sections">
<button type="button" role="tab" data-tab="overview" aria-selected="true" data-i18n="html.overview"></button>
<button type="button" role="tab" data-tab="links" aria-selected="false" data-i18n="html.links"></button>
<button type="button" role="tab" data-tab="yaml" aria-selected="false">YAML</button>
<button type="button" role="tab" data-tab="events" aria-selected="false" data-i18n="html.events"></button>
<button type="button" role="tab" data-tab="logs" aria-selected="false" data-i18n="html.logs"></button>
</div>
<section class="tab-panel" data-panel="overview" role="tabpanel"></section>
<section class="tab-panel" data-panel="links" role="tabpanel" hidden></section>
<section class="tab-panel" data-panel="yaml" role="tabpanel" hidden><pre class="code" id="d-yaml"></pre></section>
<section class="tab-panel" data-panel="events" role="tabpanel" hidden></section>
<section class="tab-panel" data-panel="logs" role="tabpanel" hidden>
<div class="logs-bar">
<select id="pod-select" data-i18n-attr="aria-label:html.pod"></select>
@@ -80,7 +88,33 @@
<pre class="code" id="d-logs"></pre>
</section>
</aside>
<aside class="details" id="problems-panel" data-i18n-attr="aria-label:html.problems" hidden>
<div class="details-head">
<div class="details-title">
<h2 data-i18n="html.problems"></h2>
<div class="muted small" id="p-sub"></div>
</div>
<button type="button" class="btn icon" id="p-close" data-i18n-attr="aria-label:html.close">×</button>
</div>
<div class="seg p-filter" role="tablist" data-i18n-attr="aria-label:html.problemsScope">
<button type="button" role="tab" data-scope="all" aria-selected="true" data-i18n="html.scopeAll"></button>
<button type="button" role="tab" data-scope="apps" aria-selected="false" data-i18n="tree.apps"></button>
<button type="button" role="tab" data-scope="system" aria-selected="false" data-i18n="group.system"></button>
</div>
<section class="tab-panel" id="p-list"></section>
</aside>
</div>
<dialog id="confirm" closedby="any" aria-labelledby="confirm-title">
<h2 id="confirm-title"></h2>
<p id="confirm-text"></p>
<label class="confirm-input" id="confirm-input-row" hidden><span data-i18n="action.replicas"></span> <input type="number" id="confirm-input" min="0" max="100" step="1"></label>
<div class="confirm-buttons">
<button type="button" class="btn" id="confirm-cancel" data-i18n="action.cancel"></button>
<button type="button" class="btn primary" id="confirm-ok"></button>
</div>
</dialog>
<script src="app.js"></script>
</body>
</html>