repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/helpers.go | internal/helpers.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package internal
import (
"regexp"
"strings"
"github.com/derailed/k9s/internal/view/cmd"
)
var (
fuzzyRx = regexp.MustCompile(`\A-f\s?([\w-]+)\b`)
labelRx = regexp.MustCompile(`\A\-l`)
)
// Helpers...
// IsInverseSelector checks if inverse char has been provided.
func IsInverseSelector(s string) bool {
if s == "" {
return false
}
return s[0] == '!'
}
// IsLabelSelector checks if query is a label query.
func IsLabelSelector(s string) bool {
if labelRx.MatchString(s) {
return true
}
return !strings.Contains(s, " ") && cmd.ToLabels(s) != nil
}
// IsFuzzySelector checks if query is fuzzy.
func IsFuzzySelector(s string) (string, bool) {
mm := fuzzyRx.FindStringSubmatch(s)
if len(mm) != 2 {
return "", false
}
return mm[1], true
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/slogs/child.go | internal/slogs/child.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package slogs
import "log/slog"
// CLog returns a child logger.
func CLog(subsys string) *slog.Logger {
return slog.With(Subsys, subsys)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/slogs/keys.go | internal/slogs/keys.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package slogs
const (
// Error tracks an error logger key.
Error = "error"
// Stack tracks a stack logger key.
Stack = "stack"
// Subsys tracks a subsystem logger key.
Subsys = "subsys"
// SchemaFile tracks a schema file logger key.
SchemaFile = "schema-file"
// RefType tracks a reference type.
RefType = "ref-type"
// GVR tracks a group version resource logger key.
GVR = "gvr"
// AuthorSpec tracks an author spec logger key.
AuthSpec = "auth-spec"
// AuthStatus tracks an auth status logger key.
AuthStatus = "auth-status"
// AuthReason tracks an auth reason logger key.
AuthReason = "auth-reason"
// Ports tracks a ports logger key.
Port = "port"
// Address tracks an address logger key.
Address = "address"
// ResName tracks a resource name logger key.
ResName = "res-name"
// Verb tracks a verb logger key.
Verb = "verb"
// ResType tracks a resource type logger key.
ResType = "res-type"
// View tracks a view logger key.
View = "view"
// GOR tracks a gor logger key.
GOR = "gor"
// Shortcut tracks a shortcut logger key.
Shortcut = "shortcut"
// Page tracks a page logger key.
Page = "page"
// Skin tracks a skin logger key.
Skin = "skin"
// CmdHist tracks a command history logger key.
CmdHist = "cmd-hist"
// Image tracks an image logger key.
Image = "image"
// FQN tracks a fully qualified name logger key.
FQN = "fqn"
// ConfigName tracks a config name logger key.
ConfigName = "config-name"
// CompName tracks a component name logger key.
CompName = "comp-name"
// Command tracks a command logger key.
Command = "cmd"
// Context tracks a context logger key.
Context = "context"
// Cluster tracks a cluster logger key.
Cluster = "cluster"
// Container tracks a container logger key.
Container = "container"
// Options tracks an options logger key.
Options = "options"
// Count tracks a count logger key.
Count = "count"
// MaxRetries tracks a max retries logger key.
MaxRetries = "max-retries"
// Retry tracks a retry logger key.
Retry = "retry"
// Message tracks a message logger key.
Message = "message"
// Index tracks an index logger key.
Index = "index"
// Path tracks a path logger key.
Path = "path"
// Dir tracks a directory logger key.
Dir = "dir"
// FileName tracks a file name logger key.
FileName = "file-name"
// Key tracks a key logger key.
Key = "key"
// Plugin tracks a plugin logger key.
Plugin = "plugin"
// Component tracks a component logger key.
Component = "component"
// RowID tracks a row id logger key.
RowID = "row-id"
// Cell tracks a cell logger key.
Cell = "cell"
// HeaderSize tracks a header size logger key.
HeaderSize = "row-size"
// Namespace tracks a namespace logger key.
Namespace = "ns"
// AllNS tracks all namespaces logger key.
AllNS = "all-ns"
// Max tracks a max logger key.
Max = "max"
// Elapsed tracks an elapsed logger key.
Elapsed = "elapsed"
// Log tracks a log logger key.
Log = "log"
// Annotation tracks an annotation logger key.
Annotation = "annotation"
// Bool tracks a boolean logger key.
Bool = "bool"
// Replicas tracks a replicas logger key.
Replicas = "replicas"
// Revision tracks a revision logger key.
Revision = "revision"
// ColName tracks a column name logger key.
ColName = "col-name"
// URL tracks a URL logger key.
URL = "url"
// Attr tracks an attribute logger key.
Attr = "attr"
// Name tracks a name logger key.
Name = "name"
// Matches tracks a matches logger key.
Matches = "matches"
// Line tracks a line logger key.
Line = "line"
// Sig tracks a signal logger key.
Sig = "signal"
// Bin tracks a binary logger key.
Bin = "binary"
// Args tracks an arguments logger key.
Args = "args"
// PodPhase tracks a pod phase logger key.
PodPhase = "pod-phase"
// ShellPodCfg tracks a shell pod config logger key.
ShellPodCfg = "shell-pod-cfg"
// PFID tracks a port forward id logger key.
PFID = "port-fwd-id"
// PFTunnel tracks a port forward tunnel logger key.
PFTunnel = "port-fwd-tunnel"
// Config tracks a config logger key.
Config = "config"
// ResKind tracks a resource kind logger key.
ResKind = "res-kind"
// ResGrpVersion tracks a resource group version logger key.
ResGrpVersion = "res-grp-version"
// ID tracks an id logger key.
ID = "id"
// ViewSetting tracks a view setting logger key.
ViewSetting = "view-setting"
// JQExp tracks a jq expression logger key.
JQExp = "jq-exp"
// Duration tracks a duration logger key.
Duration = "duration"
// Type tracks a type logger key.
Type = "type"
// Requested tracks a requested value logger key.
Requested = "requested"
// Minimum tracks a minimum value logger key.
Minimum = "minimum"
)
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/generic.go | internal/dao/generic.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/dynamic"
)
type Grace int64
const (
// DefaultGrace uses delete default termination policy.
DefaultGrace Grace = -1
// ForceGrace sets delete grace-period to 0.
ForceGrace Grace = 0
// NowGrace set delete grace-period to 1,
NowGrace Grace = 1
)
var _ Describer = (*Generic)(nil)
// Generic represents a generic resource.
type Generic struct {
NonResource
}
// List returns a collection of resources.
// BOZO!! no auth check??
func (g *Generic) List(ctx context.Context, ns string) ([]runtime.Object, error) {
labelSel, ok := ctx.Value(internal.KeyLabels).(labels.Selector)
if !ok {
labelSel = labels.Everything()
}
if client.IsAllNamespace(ns) {
ns = client.BlankNamespace
}
dial, err := g.dynClient()
if err != nil {
return nil, err
}
opts := metav1.ListOptions{LabelSelector: labelSel.String()}
var ll *unstructured.UnstructuredList
if client.IsClusterScoped(ns) {
ll, err = dial.List(ctx, opts)
} else {
ll, err = dial.Namespace(ns).List(ctx, opts)
}
if err != nil {
return nil, err
}
oo := make([]runtime.Object, len(ll.Items))
for i := range ll.Items {
oo[i] = &ll.Items[i]
}
return oo, nil
}
// Get returns a given resource.
func (g *Generic) Get(ctx context.Context, path string) (runtime.Object, error) {
ns, n := client.Namespaced(path)
dial, err := g.dynClient()
if err != nil {
return nil, err
}
var opts metav1.GetOptions
if client.IsClusterScoped(ns) {
return dial.Get(ctx, n, opts)
}
return dial.Namespace(ns).Get(ctx, n, opts)
}
// Describe describes a resource.
func (g *Generic) Describe(path string) (string, error) {
return Describe(g.Client(), g.gvr, path)
}
// ToYAML returns a resource yaml.
func (g *Generic) ToYAML(path string, showManaged bool) (string, error) {
o, err := g.Get(context.Background(), path)
if err != nil {
return "", err
}
raw, err := ToYAML(o, showManaged)
if err != nil {
return "", fmt.Errorf("unable to marshal resource %w", err)
}
return raw, nil
}
// Delete deletes a resource.
func (g *Generic) Delete(ctx context.Context, path string, propagation *metav1.DeletionPropagation, grace Grace) error {
ns, n := client.Namespaced(path)
auth, err := g.Client().CanI(ns, g.gvr, n, []string{client.DeleteVerb})
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to delete %s", path)
}
var gracePeriod *int64
if grace != DefaultGrace {
gracePeriod = (*int64)(&grace)
}
opts := metav1.DeleteOptions{
PropagationPolicy: propagation,
GracePeriodSeconds: gracePeriod,
}
dial, err := g.dynClient()
if err != nil {
return err
}
if client.IsClusterScoped(ns) {
return dial.Delete(ctx, n, opts)
}
ctx, cancel := context.WithTimeout(ctx, g.Client().Config().CallTimeout())
defer cancel()
return dial.Namespace(ns).Delete(ctx, n, opts)
}
func (g *Generic) dynClient() (dynamic.NamespaceableResourceInterface, error) {
dial, err := g.Client().DynDial()
if err != nil {
return nil, err
}
return dial.Resource(g.gvr.GVR()), nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/describe.go | internal/dao/describe.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
"k8s.io/kubectl/pkg/describe"
)
// Describe describes a resource.
func Describe(c client.Connection, gvr *client.GVR, path string) (string, error) {
mapper := RestMapper{Connection: c}
m, err := mapper.ToRESTMapper()
if err != nil {
slog.Error("No REST mapper for resource",
slogs.GVR, gvr,
slogs.Error, err,
)
return "", err
}
gvk, err := m.KindFor(gvr.GVR())
if err != nil {
slog.Error("No GVK for resource %s",
slogs.GVR, gvr,
slogs.Error, err,
)
return "", err
}
ns, n := client.Namespaced(path)
if client.IsClusterScoped(ns) {
ns = client.BlankNamespace
}
mapping, err := mapper.ResourceFor(gvr.AsResourceName(), gvk.Kind)
if err != nil {
slog.Error("Unable to find mapper",
slogs.GVR, gvr,
slogs.ResName, n,
slogs.Error, err,
)
return "", err
}
d, err := describe.Describer(c.Config().Flags(), mapping)
if err != nil {
slog.Error("Unable to find describer",
slogs.GVR, gvr.AsResourceName(),
slogs.Error, err,
)
return "", err
}
return d.Describe(ns, n, describe.DescriberSettings{ShowEvents: true})
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_options_test.go | internal/dao/log_options_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"testing"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
)
func TestLogOptionsToggleAllContainers(t *testing.T) {
uu := map[string]struct {
opts dao.LogOptions
co string
want bool
}{
"empty": {
opts: dao.LogOptions{},
want: true,
},
"container": {
opts: dao.LogOptions{Container: "blee"},
want: true,
},
"default-container": {
opts: dao.LogOptions{AllContainers: true},
co: "blee",
},
"single-container": {
opts: dao.LogOptions{Container: "blee", SingleContainer: true},
co: "blee",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
u.opts.DefaultContainer = "blee"
u.opts.ToggleAllContainers()
assert.Equal(t, u.want, u.opts.AllContainers)
assert.Equal(t, u.co, u.opts.Container)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/patch_test.go | internal/dao/patch_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestGetTemplateJsonPatch(t *testing.T) {
type args struct {
imageSpecs ImageSpecs
}
uu := map[string]struct {
args args
want string
wantErr bool
}{
"simple": {
args: args{
imageSpecs: ImageSpecs{
ImageSpec{
Index: 0,
Name: "init",
DockerImage: "busybox:latest",
Init: true,
},
ImageSpec{
Index: 0,
Name: "nginx",
DockerImage: "nginx:latest",
Init: false,
},
},
},
want: `{"spec":{"template":{"spec":{"$setElementOrder/initContainers":[{"name":"init"}],"$setElementOrder/containers":[{"name":"nginx"}],"initContainers":[{"image":"busybox:latest","name":"init"}],"containers":[{"image":"nginx:latest","name":"nginx"}]}}}}`,
wantErr: false,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
got, err := GetTemplateJsonPatch(u.args.imageSpecs)
if (err != nil) != u.wantErr {
t.Errorf("GetTemplateJsonPatch() error = %v, wantErr %v", err, u.wantErr)
return
}
require.JSONEq(t, u.want, string(got), "Json strings should be equal")
})
}
}
func TestGetJsonPatch(t *testing.T) {
type args struct {
imageSpecs ImageSpecs
}
uu := map[string]struct {
args args
want string
wantErr bool
}{
"simple": {
args: args{
imageSpecs: ImageSpecs{
ImageSpec{
Index: 0,
Name: "init",
DockerImage: "busybox:latest",
Init: true,
},
ImageSpec{
Index: 0,
Name: "nginx",
DockerImage: "nginx:latest",
Init: false,
},
},
},
want: `{"spec":{"$setElementOrder/initContainers":[{"name":"init"}],"initContainers":[{"image":"busybox:latest","name":"init"}],"$setElementOrder/containers":[{"name":"nginx"}],"containers":[{"image":"nginx:latest","name":"nginx"}]}}`,
wantErr: false,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
got, err := GetJsonPatch(u.args.imageSpecs)
if (err != nil) != u.wantErr {
t.Errorf("GetTemplateJsonPatch() error = %v, wantErr %v", err, u.wantErr)
return
}
require.JSONEq(t, u.want, string(got), "Json strings should be equal")
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/job.go | internal/dao/job.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
batchv1 "k8s.io/api/batch/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Job)(nil)
_ Nuker = (*Job)(nil)
_ Loggable = (*Job)(nil)
_ ImageLister = (*Deployment)(nil)
)
// Job represents a K8s job resource.
type Job struct {
Resource
}
// ListImages lists container images.
func (j *Job) ListImages(_ context.Context, fqn string) ([]string, error) {
job, err := j.GetInstance(fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&job.Spec.Template.Spec), nil
}
// List returns a collection of resources.
func (j *Job) List(ctx context.Context, ns string) ([]runtime.Object, error) {
oo, err := j.Resource.List(ctx, ns)
if err != nil {
return nil, err
}
ctrl, _ := ctx.Value(internal.KeyPath).(string)
_, n := client.Namespaced(ctrl)
ll := make([]runtime.Object, 0, 10)
for _, o := range oo {
var j batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &j)
if err != nil {
return nil, errors.New("expecting Job resource")
}
if n == "" {
ll = append(ll, o)
continue
}
for _, r := range j.OwnerReferences {
if r.Name == n {
ll = append(ll, o)
}
}
}
return ll, nil
}
// TailLogs tail logs for all pods represented by this Job.
func (j *Job) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
o, err := j.getFactory().Get(j.gvr, opts.Path, true, labels.Everything())
if err != nil {
return nil, err
}
var job batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &job)
if err != nil {
return nil, errors.New("expecting a job resource")
}
if job.Spec.Selector == nil || len(job.Spec.Selector.MatchLabels) == 0 {
return nil, fmt.Errorf("no valid selector found for job: %s", opts.Path)
}
return podLogs(ctx, job.Spec.Selector.MatchLabels, opts)
}
func (j *Job) GetInstance(fqn string) (*batchv1.Job, error) {
o, err := j.getFactory().Get(j.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var job batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &job)
if err != nil {
return nil, errors.New("expecting a job resource")
}
return &job, nil
}
// ScanSA scans for serviceaccount refs.
func (j *Job) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := j.getFactory().List(j.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var job batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &job)
if err != nil {
return nil, errors.New("expecting Job resource")
}
if serviceAccountMatches(job.Spec.Template.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: j.GVR(),
FQN: client.FQN(job.Namespace, job.Name),
})
}
}
return refs, nil
}
// Scan scans for resource references.
func (j *Job) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := j.getFactory().List(j.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var job batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &job)
if err != nil {
return nil, errors.New("expecting Job resource")
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&job.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: j.GVR(),
FQN: client.FQN(job.Namespace, job.Name),
})
case client.SecGVR:
found, err := hasSecret(j.Factory, &job.Spec.Template.Spec, job.Namespace, n, wait)
if err != nil {
slog.Warn("Locate secret failed",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: j.GVR(),
FQN: client.FQN(job.Namespace, job.Name),
})
case client.PcGVR:
if !hasPC(&job.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: j.GVR(),
FQN: client.FQN(job.Namespace, job.Name),
})
}
}
return refs, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/registry.go | internal/dao/registry.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"fmt"
"log/slog"
"maps"
"slices"
"strings"
"sync"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/sets"
)
const (
crdCat = "crd"
k9sCat = "k9s"
helmCat = "helm"
scaleCat = "scale"
)
var stdGroups = sets.New[string](
"apps/v1",
"autoscaling/v1",
"autoscaling/v2",
"autoscaling/v2beta1",
"autoscaling/v2beta2",
"batch/v1",
"batch/v1beta1",
"extensions/v1beta1",
"policy/v1beta1",
"policy/v1",
"v1",
)
// ResourceMetas represents a collection of resource metadata.
type ResourceMetas map[*client.GVR]*metav1.APIResource
func (m ResourceMetas) clear() {
for k := range m {
delete(m, k)
}
}
// MetaAccess tracks resources metadata.
var MetaAccess = NewMeta()
// Meta represents available resource metas.
type Meta struct {
resMetas ResourceMetas
mx sync.RWMutex
}
// NewMeta returns a resource meta.
func NewMeta() *Meta {
return &Meta{resMetas: make(ResourceMetas)}
}
func (m *Meta) Lookup(cmd string) *client.GVR {
m.mx.RLock()
defer m.mx.RUnlock()
for gvr, meta := range m.resMetas {
if slices.Contains(meta.ShortNames, cmd) {
return gvr
}
if meta.Name == cmd || meta.SingularName == cmd || meta.Kind == cmd {
return gvr
}
}
return client.NoGVR
}
// RegisterMeta registers a new resource meta object.
func (m *Meta) RegisterMeta(gvr string, res *metav1.APIResource) {
m.mx.Lock()
defer m.mx.Unlock()
m.resMetas[client.NewGVR(gvr)] = res
}
// AllGVRs returns all sorted cluster resources.
func (m *Meta) AllGVRs() client.GVRs {
m.mx.RLock()
defer m.mx.RUnlock()
kk := slices.Collect(maps.Keys(m.resMetas))
return client.GVRs(kk)
}
// GVK2GVR convert gvk to gvr
func (m *Meta) GVK2GVR(gv schema.GroupVersion, kind string) (*client.GVR, bool, bool) {
m.mx.RLock()
defer m.mx.RUnlock()
for gvr, meta := range m.resMetas {
if gv.Group == meta.Group && gv.Version == meta.Version && kind == meta.Kind {
return gvr, meta.Namespaced, true
}
}
return client.NoGVR, false, false
}
// IsNamespaced checks if a given resource is namespaced.
func (m *Meta) IsNamespaced(gvr *client.GVR) (bool, error) {
res, err := m.MetaFor(gvr)
if err != nil {
return false, err
}
return res.Namespaced, nil
}
// MetaFor returns a resource metadata for a given gvr.
func (m *Meta) MetaFor(gvr *client.GVR) (*metav1.APIResource, error) {
m.mx.RLock()
defer m.mx.RUnlock()
if meta, ok := m.resMetas[gvr]; ok {
return meta, nil
}
return new(metav1.APIResource), fmt.Errorf("no resource meta defined for\n %q", gvr)
}
// IsCRD checks if resource represents a CRD
func IsCRD(r *metav1.APIResource) bool {
return slices.Contains(r.Categories, crdCat)
}
// IsK8sMeta checks for non resource meta.
func IsK8sMeta(m *metav1.APIResource) bool {
return !slices.ContainsFunc(m.Categories, func(category string) bool {
return category == k9sCat || category == helmCat
})
}
// IsK9sMeta checks for non resource meta.
func IsK9sMeta(m *metav1.APIResource) bool {
return slices.Contains(m.Categories, k9sCat)
}
// IsScalable check if the resource can be scaled
func IsScalable(m *metav1.APIResource) bool {
return slices.Contains(m.Categories, scaleCat)
}
// LoadResources hydrates server preferred+CRDs resource metadata.
func (m *Meta) LoadResources(f Factory) error {
m.mx.Lock()
defer m.mx.Unlock()
m.resMetas.clear()
if err := loadPreferred(f, m.resMetas); err != nil {
return err
}
loadNonResource(m.resMetas)
// We've actually loaded all the CRDs in loadPreferred, and we're now adding
// some additional CRD properties on top of that.
loadCRDs(f, m.resMetas)
return nil
}
// BOZO!! Need countermeasures for direct commands!
func loadNonResource(m ResourceMetas) {
loadK9s(m)
loadRBAC(m)
loadHelm(m)
}
func loadK9s(m ResourceMetas) {
m[client.WkGVR] = &metav1.APIResource{
Name: "workloads",
Kind: "Workload",
SingularName: "workload",
Namespaced: true,
ShortNames: []string{"wk"},
Categories: []string{k9sCat},
}
m[client.PuGVR] = &metav1.APIResource{
Name: "pulses",
Kind: "Pulse",
SingularName: "pulse",
ShortNames: []string{"hz", "pu"},
Categories: []string{k9sCat},
}
m[client.DirGVR] = &metav1.APIResource{
Name: "dirs",
Kind: "Dir",
SingularName: "dir",
Categories: []string{k9sCat},
}
m[client.XGVR] = &metav1.APIResource{
Name: "xrays",
Kind: "XRays",
SingularName: "xray",
Categories: []string{k9sCat},
}
m[client.RefGVR] = &metav1.APIResource{
Name: "references",
Kind: "References",
SingularName: "reference",
Verbs: []string{},
Categories: []string{k9sCat},
}
m[client.AliGVR] = &metav1.APIResource{
Name: "aliases",
Kind: "Aliases",
SingularName: "alias",
Verbs: []string{},
Categories: []string{k9sCat},
}
m[client.CtGVR] = &metav1.APIResource{
Name: client.CtGVR.String(),
Kind: "Contexts",
SingularName: "context",
ShortNames: []string{"ctx"},
Verbs: []string{},
Categories: []string{k9sCat},
}
m[client.SdGVR] = &metav1.APIResource{
Name: "screendumps",
Kind: "ScreenDumps",
SingularName: "screendump",
ShortNames: []string{"sd"},
Verbs: []string{"delete"},
Categories: []string{k9sCat},
}
m[client.BeGVR] = &metav1.APIResource{
Name: "benchmarks",
Kind: "Benchmarks",
SingularName: "benchmark",
ShortNames: []string{"be"},
Verbs: []string{"delete"},
Categories: []string{k9sCat},
}
m[client.PfGVR] = &metav1.APIResource{
Name: "portforwards",
Namespaced: true,
Kind: "PortForwards",
SingularName: "portforward",
ShortNames: []string{"pf"},
Verbs: []string{"delete"},
Categories: []string{k9sCat},
}
m[client.CoGVR] = &metav1.APIResource{
Name: "containers",
Kind: "Containers",
SingularName: "container",
Verbs: []string{},
Categories: []string{k9sCat},
}
m[client.ScnGVR] = &metav1.APIResource{
Name: "scans",
Kind: "Scans",
SingularName: "scan",
Verbs: []string{},
Categories: []string{k9sCat},
}
}
func loadHelm(m ResourceMetas) {
m[client.HmGVR] = &metav1.APIResource{
Name: "helm",
Kind: "Helm",
Namespaced: true,
Verbs: []string{"delete"},
Categories: []string{helmCat},
}
m[client.HmhGVR] = &metav1.APIResource{
Name: "history",
Kind: "History",
Namespaced: true,
Verbs: []string{"delete"},
Categories: []string{helmCat},
}
}
func loadRBAC(m ResourceMetas) {
m[client.RbacGVR] = &metav1.APIResource{
Name: "rbacs",
Kind: "Rules",
Categories: []string{k9sCat},
}
m[client.PolGVR] = &metav1.APIResource{
Name: "policies",
Kind: "Rules",
Namespaced: true,
Categories: []string{k9sCat},
}
m[client.UsrGVR] = &metav1.APIResource{
Name: "users",
Kind: "User",
Categories: []string{k9sCat},
}
m[client.GrpGVR] = &metav1.APIResource{
Name: "groups",
Kind: "Group",
Categories: []string{k9sCat},
}
}
func loadPreferred(f Factory, m ResourceMetas) error {
if f == nil || f.Client() == nil || !f.Client().ConnectionOK() {
slog.Error("Load cluster resources - No API server connection")
return nil
}
dial, err := f.Client().CachedDiscovery()
if err != nil {
return err
}
rr, err := dial.ServerPreferredResources()
if err != nil {
slog.Debug("Failed to load preferred resources", slogs.Error, err)
}
for _, r := range rr {
for i := range r.APIResources {
res := r.APIResources[i]
gvr := client.FromGVAndR(r.GroupVersion, res.Name)
if isDeprecated(gvr) {
continue
}
res.Group, res.Version = gvr.G(), gvr.V()
if res.SingularName == "" {
res.SingularName = strings.ToLower(res.Kind)
}
if !isStandardGroup(r.GroupVersion) {
res.Categories = append(res.Categories, crdCat)
}
if isScalable(gvr) {
res.Categories = append(res.Categories, scaleCat)
}
m[gvr] = &res
}
}
return nil
}
func isStandardGroup(gv string) bool {
return stdGroups.Has(gv) || strings.Contains(gv, ".k8s.io")
}
func isScalable(gvr *client.GVR) bool {
ss := sets.New(client.DpGVR, client.StsGVR, client.RsGVR)
return ss.Has(gvr)
}
var deprecatedGVRs = sets.New(
client.NewGVR("v1/events"),
client.NewGVR("extensions/v1beta1/ingresses"),
)
func isDeprecated(gvr *client.GVR) bool {
return deprecatedGVRs.Has(gvr) || gvr.V() == ""
}
// loadCRDs Wait for the cache to synced and then add some additional properties to CRD.
func loadCRDs(f Factory, m ResourceMetas) {
if f == nil || f.Client() == nil || !f.Client().ConnectionOK() {
return
}
oo, err := f.List(client.CrdGVR, client.ClusterScope, true, labels.Everything())
if err != nil {
slog.Warn("CRDs load Fail", slogs.Error, err)
return
}
for _, o := range oo {
var crd apiext.CustomResourceDefinition
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &crd)
if err != nil {
slog.Error("CRD conversion failed", slogs.Error, err)
continue
}
for gvr, version := range client.NewGVRFromCRD(&crd) {
if meta, ok := m[gvr]; ok && version.Subresources != nil && version.Subresources.Scale != nil {
if !slices.Contains(meta.Categories, scaleCat) {
meta.Categories = append(meta.Categories, scaleCat)
m[gvr] = meta
}
}
}
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/workload.go | internal/dao/workload.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"encoding/json"
"errors"
"fmt"
"log/slog"
"strconv"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
const (
StatusOK = "OK"
DegradedStatus = "DEGRADED"
)
var resList = []*client.GVR{
client.PodGVR,
client.SvcGVR,
client.DsGVR,
client.StsGVR,
client.DpGVR,
client.RsGVR,
}
// Workload tracks a select set of resources in a given namespace.
type Workload struct {
Table
}
func (w *Workload) Delete(ctx context.Context, path string, propagation *metav1.DeletionPropagation, grace Grace) error {
gvr, _ := ctx.Value(internal.KeyGVR).(*client.GVR)
ns, n := client.Namespaced(path)
auth, err := w.Client().CanI(ns, gvr, n, []string{client.DeleteVerb})
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to delete %s", path)
}
var gracePeriod *int64
if grace != DefaultGrace {
gracePeriod = (*int64)(&grace)
}
opts := metav1.DeleteOptions{
PropagationPolicy: propagation,
GracePeriodSeconds: gracePeriod,
}
ctx, cancel := context.WithTimeout(ctx, w.Client().Config().CallTimeout())
defer cancel()
d, err := w.Client().DynDial()
if err != nil {
return err
}
dial := d.Resource(gvr.GVR())
if client.IsClusterScoped(ns) {
return dial.Delete(ctx, n, opts)
}
return dial.Namespace(ns).Delete(ctx, n, opts)
}
func (a *Workload) fetch(ctx context.Context, gvr *client.GVR, ns string) (*metav1.Table, error) {
a.gvr = gvr
oo, err := a.Table.List(ctx, ns)
if err != nil {
return nil, err
}
if len(oo) == 0 {
return nil, fmt.Errorf("no table found for gvr: %s", gvr)
}
tt, ok := oo[0].(*metav1.Table)
if !ok {
return nil, errors.New("not a metav1.Table")
}
return tt, nil
}
// List fetch workloads.
func (a *Workload) List(ctx context.Context, ns string) ([]runtime.Object, error) {
oo := make([]runtime.Object, 0, 100)
for _, gvr := range resList {
table, err := a.fetch(ctx, gvr, ns)
if err != nil {
return nil, err
}
var (
ns string
ts metav1.Time
)
for _, r := range table.Rows {
if obj := r.Object.Object; obj != nil {
if m, err := meta.Accessor(obj); err == nil {
ns, ts = m.GetNamespace(), m.GetCreationTimestamp()
}
} else {
var m metav1.PartialObjectMetadata
if err := json.Unmarshal(r.Object.Raw, &m); err == nil {
ns, ts = m.GetNamespace(), m.CreationTimestamp
}
}
stat := status(gvr, &r, table.ColumnDefinitions)
oo = append(oo, &render.WorkloadRes{Row: metav1.TableRow{Cells: []any{
gvr.String(),
ns,
r.Cells[indexOf("Name", table.ColumnDefinitions)],
stat,
readiness(gvr, &r, table.ColumnDefinitions),
validity(stat),
ts,
}}})
}
}
return oo, nil
}
// Helpers...
func readiness(gvr *client.GVR, r *metav1.TableRow, h []metav1.TableColumnDefinition) string {
switch gvr {
case client.PodGVR, client.DpGVR, client.StsGVR:
return r.Cells[indexOf("Ready", h)].(string)
case client.RsGVR, client.DsGVR:
c := r.Cells[indexOf("Ready", h)].(int64)
d := r.Cells[indexOf("Desired", h)].(int64)
return fmt.Sprintf("%d/%d", c, d)
case client.SvcGVR:
return ""
}
return render.NAValue
}
func status(gvr *client.GVR, r *metav1.TableRow, h []metav1.TableColumnDefinition) string {
switch gvr {
case client.PodGVR:
if status := r.Cells[indexOf("Status", h)]; status == render.PhaseCompleted {
return StatusOK
} else if !isReady(r.Cells[indexOf("Ready", h)].(string)) || status != render.PhaseRunning {
return DegradedStatus
}
case client.DpGVR, client.StsGVR:
if !isReady(r.Cells[indexOf("Ready", h)].(string)) {
return DegradedStatus
}
case client.RsGVR, client.DsGVR:
rd, ok1 := r.Cells[indexOf("Ready", h)].(int64)
de, ok2 := r.Cells[indexOf("Desired", h)].(int64)
if ok1 && ok2 {
if !isReady(fmt.Sprintf("%d/%d", rd, de)) {
return DegradedStatus
}
break
}
rds, oks1 := r.Cells[indexOf("Ready", h)].(string)
des, oks2 := r.Cells[indexOf("Desired", h)].(string)
if oks1 && oks2 {
if !isReady(fmt.Sprintf("%s/%s", rds, des)) {
return DegradedStatus
}
}
case client.SvcGVR:
default:
return render.MissingValue
}
return StatusOK
}
func validity(status string) string {
if status != "DEGRADED" {
return ""
}
return status
}
func isReady(s string) bool {
tt := strings.Split(s, "/")
if len(tt) != 2 {
return false
}
r, err := strconv.Atoi(tt[0])
if err != nil {
slog.Error("Invalid ready count",
slogs.Error, err,
slogs.Count, tt[0],
)
return false
}
c, err := strconv.Atoi(tt[1])
if err != nil {
slog.Error("invalid expected count: %q",
slogs.Error, err,
slogs.Count, tt[1],
)
return false
}
if c == 0 {
return true
}
return r == c
}
func indexOf(n string, defs []metav1.TableColumnDefinition) int {
for i, d := range defs {
if d.Name == n {
return i
}
}
return -1
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/dir_test.go | internal/dao/dir_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNewDir(t *testing.T) {
d := dao.NewDir(nil)
ctx := context.WithValue(context.Background(), internal.KeyPath, "testdata/dir")
oo, err := d.List(ctx, "")
require.NoError(t, err)
assert.Len(t, oo, 2)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rbac.go | internal/dao/rbac.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
rbacv1 "k8s.io/api/rbac/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Rbac)(nil)
_ Nuker = (*Rbac)(nil)
)
// Rbac represents a model for listing rbac resources.
type Rbac struct {
Resource
}
// List lists out rbac resources.
func (r *Rbac) List(ctx context.Context, ns string) ([]runtime.Object, error) {
gvr, ok := ctx.Value(internal.KeyGVR).(*client.GVR)
if !ok {
return nil, fmt.Errorf("expecting a context gvr")
}
path, ok := ctx.Value(internal.KeyPath).(string)
if !ok || path == "" {
return r.Resource.List(ctx, ns)
}
switch gvr.R() {
case "clusterrolebindings":
return r.loadClusterRoleBinding(path)
case "rolebindings":
return r.loadRoleBinding(path)
case "clusterroles":
return r.loadClusterRole(path)
case "roles":
return r.loadRole(path)
default:
return nil, fmt.Errorf("expecting clusterrole/role but found %s", gvr.R())
}
}
func (r *Rbac) loadClusterRoleBinding(path string) ([]runtime.Object, error) {
crbo, err := r.getFactory().Get(client.CrbGVR, path, true, labels.Everything())
if err != nil {
return nil, err
}
var crb rbacv1.ClusterRoleBinding
err = runtime.DefaultUnstructuredConverter.FromUnstructured(crbo.(*unstructured.Unstructured).Object, &crb)
if err != nil {
return nil, err
}
cro, err := r.getFactory().Get(client.CrGVR, client.FQN("-", crb.RoleRef.Name), true, labels.Everything())
if err != nil {
return nil, err
}
var cr rbacv1.ClusterRole
err = runtime.DefaultUnstructuredConverter.FromUnstructured(cro.(*unstructured.Unstructured).Object, &cr)
if err != nil {
return nil, err
}
return asRuntimeObjects(parseRules(client.ClusterScope, "-", cr.Rules)), nil
}
func (r *Rbac) loadRoleBinding(path string) ([]runtime.Object, error) {
rbo, err := r.getFactory().Get(client.RobGVR, path, true, labels.Everything())
if err != nil {
return nil, err
}
var rb rbacv1.RoleBinding
if e := runtime.DefaultUnstructuredConverter.FromUnstructured(rbo.(*unstructured.Unstructured).Object, &rb); e != nil {
return nil, e
}
if rb.RoleRef.Kind == "ClusterRole" {
cro, e := r.getFactory().Get(client.CrGVR, client.FQN("-", rb.RoleRef.Name), true, labels.Everything())
if e != nil {
return nil, e
}
var cr rbacv1.ClusterRole
err = runtime.DefaultUnstructuredConverter.FromUnstructured(cro.(*unstructured.Unstructured).Object, &cr)
if err != nil {
return nil, err
}
return asRuntimeObjects(parseRules(client.ClusterScope, "-", cr.Rules)), nil
}
ro, err := r.getFactory().Get(client.RoGVR, client.FQN(rb.Namespace, rb.RoleRef.Name), true, labels.Everything())
if err != nil {
return nil, err
}
var role rbacv1.Role
err = runtime.DefaultUnstructuredConverter.FromUnstructured(ro.(*unstructured.Unstructured).Object, &role)
if err != nil {
return nil, err
}
return asRuntimeObjects(parseRules(client.ClusterScope, "-", role.Rules)), nil
}
func (r *Rbac) loadClusterRole(fqn string) ([]runtime.Object, error) {
o, err := r.getFactory().Get(client.CrGVR, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var cr rbacv1.ClusterRole
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cr)
if err != nil {
return nil, err
}
return asRuntimeObjects(parseRules(client.ClusterScope, "-", cr.Rules)), nil
}
func (r *Rbac) loadRole(path string) ([]runtime.Object, error) {
o, err := r.getFactory().Get(client.RoGVR, path, true, labels.Everything())
if err != nil {
return nil, err
}
var ro rbacv1.Role
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &ro)
if err != nil {
return nil, err
}
return asRuntimeObjects(parseRules(client.ClusterScope, "-", ro.Rules)), nil
}
func asRuntimeObjects(rr render.Policies) []runtime.Object {
oo := make([]runtime.Object, len(rr))
for i, r := range rr {
oo[i] = r
}
return oo
}
func parseRules(ns, binding string, rules []rbacv1.PolicyRule) render.Policies {
pp := make(render.Policies, 0, len(rules))
for _, rule := range rules {
for _, grp := range rule.APIGroups {
if grp == "" {
grp = "core"
}
for _, res := range rule.Resources {
for _, na := range rule.ResourceNames {
pp = pp.Upsert(render.NewPolicyRes(ns, binding, FQN(res, na), grp, rule.Verbs))
}
pp = pp.Upsert(render.NewPolicyRes(ns, binding, FQN(grp, res), grp, rule.Verbs))
}
}
for _, nres := range rule.NonResourceURLs {
if nres[0] != '/' {
nres = "/" + nres
}
pp = pp.Upsert(render.NewPolicyRes(ns, binding, nres, client.NA, rule.Verbs))
}
}
return pp
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_items.go | internal/dao/log_items.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"bytes"
"fmt"
"regexp"
"strings"
"sync"
"github.com/derailed/k9s/internal"
"github.com/sahilm/fuzzy"
)
type podColors map[string]string
var podPalette = []string{
"teal",
"green",
"purple",
"lime",
"blue",
"yellow",
"fushia",
"aqua",
}
// LogItems represents a collection of log items.
type LogItems struct {
items []*LogItem
podColors podColors
mx sync.RWMutex
}
// NewLogItems returns a new instance.
func NewLogItems() *LogItems {
return &LogItems{
podColors: make(map[string]string),
}
}
// Items returns the log items.
func (l *LogItems) Items() []*LogItem {
l.mx.RLock()
defer l.mx.RUnlock()
return l.items
}
// Len returns the items length.
func (l *LogItems) Len() int {
l.mx.RLock()
defer l.mx.RUnlock()
return len(l.items)
}
// Clear removes all items.
func (l *LogItems) Clear() {
l.mx.Lock()
defer l.mx.Unlock()
l.items = l.items[:0]
for k := range l.podColors {
delete(l.podColors, k)
}
}
// Shift scrolls the lines by one.
func (l *LogItems) Shift(i *LogItem) {
l.mx.Lock()
defer l.mx.Unlock()
l.items = append(l.items[1:], i)
}
// Subset return a subset of logitems.
func (l *LogItems) Subset(index int) *LogItems {
l.mx.RLock()
defer l.mx.RUnlock()
return &LogItems{
items: l.items[index:],
podColors: l.podColors,
}
}
// Merge merges two logitems list.
func (l *LogItems) Merge(n *LogItems) {
l.mx.Lock()
defer l.mx.Unlock()
l.items = append(l.items, n.items...)
for k, v := range n.podColors {
l.podColors[k] = v
}
}
// Add augments the items.
func (l *LogItems) Add(ii ...*LogItem) {
l.mx.Lock()
defer l.mx.Unlock()
l.items = append(l.items, ii...)
}
func (l *LogItems) podColorFor(id string) string {
color, ok := l.podColors[id]
if ok {
return color
}
var idx int
for i, r := range id {
idx += i * int(r)
}
l.podColors[id] = podPalette[idx%len(podPalette)]
return l.podColors[id]
}
// Lines returns a collection of log lines.
func (l *LogItems) Lines(index int, showTime bool, ll [][]byte) {
l.mx.Lock()
defer l.mx.Unlock()
for i, item := range l.items[index:] {
bb := bytes.NewBuffer(make([]byte, 0, item.Size()))
item.Render(l.podColorFor(item.ID()), showTime, bb)
ll[i] = bb.Bytes()
}
}
// StrLines returns a collection of log lines.
func (l *LogItems) StrLines(index int, showTime bool) []string {
l.mx.Lock()
defer l.mx.Unlock()
ll := make([]string, len(l.items[index:]))
for i, item := range l.items[index:] {
bb := bytes.NewBuffer(make([]byte, 0, item.Size()))
item.Render(l.podColorFor(item.ID()), showTime, bb)
ll[i] = bb.String()
}
return ll
}
// Render returns logs as a collection of strings.
func (l *LogItems) Render(index int, showTime bool, ll [][]byte) {
for i, item := range l.items[index:] {
bb := bytes.NewBuffer(make([]byte, 0, item.Size()))
item.Render(l.podColorFor(item.ID()), showTime, bb)
ll[i] = bb.Bytes()
}
}
// DumpDebug for debugging.
func (l *LogItems) DumpDebug(m string) {
fmt.Println(m + strings.Repeat("-", 50))
for i, line := range l.items {
fmt.Println(i, string(line.Bytes))
}
}
// Filter filters out log items based on given filter.
func (l *LogItems) Filter(index int, q string, showTime bool) (matches []int, indices [][]int, err error) {
if q == "" {
return
}
if f, ok := internal.IsFuzzySelector(q); ok {
matches, indices = l.fuzzyFilter(index, f, showTime)
return
}
matches, indices, err = l.filterLogs(index, q, showTime)
if err != nil {
return
}
return matches, indices, nil
}
func (l *LogItems) fuzzyFilter(index int, q string, showTime bool) (matches []int, indices [][]int) {
q = strings.TrimSpace(q)
matches, indices = make([]int, 0, len(l.items)), make([][]int, 0, len(l.items))
mm := fuzzy.Find(q, l.StrLines(index, showTime))
for _, m := range mm {
matches = append(matches, m.Index)
indices = append(indices, m.MatchedIndexes)
}
return matches, indices
}
func (l *LogItems) filterLogs(index int, q string, showTime bool) (matches []int, indices [][]int, err error) {
var invert bool
if internal.IsInverseSelector(q) {
invert = true
q = q[1:]
}
rx, err := regexp.Compile(`(?i)` + q)
if err != nil {
return nil, nil, err
}
matches, indices = make([]int, 0, len(l.items)), make([][]int, 0, len(l.items))
ll := make([][]byte, len(l.items[index:]))
l.Lines(index, showTime, ll)
for i, line := range ll {
locs := rx.FindAllIndex(line, -1)
if locs != nil && invert {
continue
}
if locs == nil && !invert {
continue
}
matches = append(matches, i)
ii := make([]int, 0, 10)
for _, loc := range locs {
for j := loc[0]; j < loc[1]; j++ {
ii = append(ii, j)
}
}
indices = append(indices, ii)
}
return matches, indices, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/table.go | internal/dao/table.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"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/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/serializer"
"k8s.io/client-go/rest"
)
const (
gvFmt = "application/json;as=Table;v=%s;g=%s, application/json"
includeMeta = "Metadata"
includeObj = "Object"
includeNone = "None"
header = "application/json;as=Table;v=v1;g=meta.k8s.io,application/json;as=Table;v=v1beta1;g=meta.k8s.io,application/json"
)
var genScheme = runtime.NewScheme()
// Table retrieves K8s resources as tabular data.
type Table struct {
Generic
}
// Get returns a given resource.
func (t *Table) Get(ctx context.Context, path string) (runtime.Object, error) {
f, p := t.codec()
c, err := t.getClient(f)
if err != nil {
return nil, err
}
ns, n := client.Namespaced(path)
a := fmt.Sprintf(gvFmt, metav1.SchemeGroupVersion.Version, metav1.GroupName)
req := c.Get().
SetHeader("Accept", a).
Name(n).
Resource(t.gvr.R()).
VersionedParams(&metav1.TableOptions{}, p)
if ns != client.ClusterScope {
req = req.Namespace(ns)
}
return req.Do(ctx).Get()
}
// List all Resources in a given namespace.
func (t *Table) List(ctx context.Context, ns string) ([]runtime.Object, error) {
sel := labels.Everything()
if labelSel, ok := ctx.Value(internal.KeyLabels).(labels.Selector); ok {
sel = labelSel
}
fieldSel, _ := ctx.Value(internal.KeyFields).(string)
includeObject := includeMeta
if t.includeObj {
includeObject = includeObj
}
f, _ := t.codec()
c, err := t.getClient(f)
if err != nil {
return nil, err
}
o, err := c.Get().
SetHeader("Accept", header).
Param("includeObject", includeObject).
Namespace(ns).
Resource(t.gvr.R()).
VersionedParams(&metav1.ListOptions{
LabelSelector: sel.String(),
FieldSelector: fieldSel,
}, metav1.ParameterCodec).
Do(ctx).Get()
if err != nil {
return nil, err
}
namespaced := true
if res, e := MetaAccess.MetaFor(t.gvr); e == nil && !res.Namespaced {
namespaced = false
}
ta, err := decodeTable(ctx, o.(*metav1.Table), namespaced)
if err != nil {
return nil, err
}
return []runtime.Object{ta}, nil
}
// ----------------------------------------------------------------------------
// Helpers...
func decodeTable(ctx context.Context, table *metav1.Table, namespaced bool) (runtime.Object, error) {
if namespaced {
table.ColumnDefinitions = append([]metav1.TableColumnDefinition{{Name: "Namespace", Type: "string"}}, table.ColumnDefinitions...)
}
pool := internal.NewWorkerPool(ctx, internal.DefaultPoolSize)
for i := range table.Rows {
pool.Add(func(_ context.Context) error {
row := &table.Rows[i]
if row.Object.Raw == nil || row.Object.Object != nil {
return nil
}
converted, err := runtime.Decode(unstructured.UnstructuredJSONScheme, row.Object.Raw)
if err != nil {
return err
}
row.Object.Object = converted
var m metav1.Object
if obj := row.Object.Object; obj != nil {
m, _ = meta.Accessor(obj)
}
var ns string
if m != nil {
ns = m.GetNamespace()
}
if namespaced {
row.Cells = append([]any{ns}, row.Cells...)
}
return nil
})
}
errs := pool.Drain()
if len(errs) > 0 {
return nil, fmt.Errorf("failed to decode table rows: %w", errs[0])
}
return table, nil
}
func (t *Table) getClient(f serializer.CodecFactory) (*rest.RESTClient, error) {
cfg, err := t.Client().RestConfig()
if err != nil {
return nil, err
}
gv := t.gvr.GV()
cfg.GroupVersion = &gv
cfg.APIPath = "/apis"
if t.gvr.G() == "" {
cfg.APIPath = "/api"
}
cfg.NegotiatedSerializer = f.WithoutConversion()
crRestClient, err := rest.RESTClientFor(cfg)
if err != nil {
return nil, err
}
return crRestClient, nil
}
func (t *Table) codec() (serializer.CodecFactory, runtime.ParameterCodec) {
var tt metav1.Table
opts := metav1.TableOptions{IncludeObject: metav1.IncludeObject}
gv := t.gvr.GV()
metav1.AddToGroupVersion(genScheme, gv)
genScheme.AddKnownTypes(gv, &tt, &opts)
genScheme.AddKnownTypes(metav1.SchemeGroupVersion, &tt, &opts)
return serializer.NewCodecFactory(genScheme), runtime.NewParameterCodec(genScheme)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/pod_test.go | internal/dao/pod_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"testing"
"github.com/stretchr/testify/assert"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestGetDefaultContainer(t *testing.T) {
uu := map[string]struct {
po *v1.Pod
wantContainer string
wantOk bool
}{
"no_annotation": {
po: &v1.Pod{
Spec: v1.PodSpec{
Containers: []v1.Container{{Name: "container1"}},
},
},
wantContainer: "",
wantOk: false,
},
"container_not_present": {
po: &v1.Pod{
ObjectMeta: metav1.ObjectMeta{
Annotations: map[string]string{DefaultContainerAnnotation: "container1"},
},
},
wantContainer: "",
wantOk: false,
},
"container_found": {
po: &v1.Pod{
ObjectMeta: metav1.ObjectMeta{
Annotations: map[string]string{DefaultContainerAnnotation: "container1"},
},
Spec: v1.PodSpec{
Containers: []v1.Container{{Name: "container1"}},
},
},
wantContainer: "container1",
wantOk: true,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
container, ok := GetDefaultContainer(&u.po.ObjectMeta, &u.po.Spec)
assert.Equal(t, u.wantContainer, container)
assert.Equal(t, u.wantOk, ok)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/container.go | internal/dao/container.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"strconv"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
var (
_ Accessor = (*Container)(nil)
_ Loggable = (*Container)(nil)
)
const (
initIDX = "I"
mainIDX = "M"
ephIDX = "E"
)
// Container represents a pod's container dao.
type Container struct {
NonResource
}
// List returns a collection of containers.
func (c *Container) List(ctx context.Context, _ string) ([]runtime.Object, error) {
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, fmt.Errorf("no context path for %q", c.gvr)
}
var (
cmx client.ContainersMetrics
err error
)
if withMx, ok := ctx.Value(internal.KeyWithMetrics).(bool); ok && withMx {
cmx, _ = client.DialMetrics(c.Client()).FetchContainersMetrics(ctx, fqn)
}
po, err := c.fetchPod(fqn)
if err != nil {
return nil, err
}
res := make([]runtime.Object, 0, len(po.Spec.InitContainers)+len(po.Spec.Containers)+len(po.Spec.EphemeralContainers))
for i := range po.Spec.InitContainers {
res = append(res, makeContainerRes(
initIDX,
i,
&(po.Spec.InitContainers[i]),
po,
cmx[po.Spec.InitContainers[i].Name]),
)
}
for i := range po.Spec.Containers {
res = append(res, makeContainerRes(
mainIDX,
i,
&(po.Spec.Containers[i]),
po,
cmx[po.Spec.Containers[i].Name]),
)
}
for i := range po.Spec.EphemeralContainers {
co := v1.Container(po.Spec.EphemeralContainers[i].EphemeralContainerCommon)
res = append(res, makeContainerRes(
ephIDX,
i,
&co,
po,
cmx[co.Name]),
)
}
return res, nil
}
// TailLogs tails a given container logs.
func (c *Container) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
po := Pod{}
po.Init(c.Factory, client.PodGVR)
return po.TailLogs(ctx, opts)
}
// ----------------------------------------------------------------------------
// Helpers...
func makeContainerRes(kind string, idx int, co *v1.Container, po *v1.Pod, cmx *mv1beta1.ContainerMetrics) render.ContainerRes {
return render.ContainerRes{
Idx: kind + strconv.Itoa(idx+1),
Container: co,
Status: getContainerStatus(kind, co.Name, &po.Status),
MX: cmx,
Age: po.GetCreationTimestamp(),
}
}
func getContainerStatus(kind, name string, status *v1.PodStatus) *v1.ContainerStatus {
switch kind {
case mainIDX:
for i := range status.ContainerStatuses {
if status.ContainerStatuses[i].Name == name {
return &status.ContainerStatuses[i]
}
}
case initIDX:
for i := range status.InitContainerStatuses {
if status.InitContainerStatuses[i].Name == name {
return &status.InitContainerStatuses[i]
}
}
case ephIDX:
for i := range status.EphemeralContainerStatuses {
if status.EphemeralContainerStatuses[i].Name == name {
return &status.EphemeralContainerStatuses[i]
}
}
}
return nil
}
func (c *Container) fetchPod(fqn string) (*v1.Pod, error) {
o, err := c.getFactory().Get(client.PodGVR, fqn, true, labels.Everything())
if err != nil {
return nil, fmt.Errorf("failed to locate pod %q: %w", fqn, err)
}
var po v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &po)
return &po, err
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/node.go | internal/dao/node.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"io"
"log/slog"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/kubernetes"
"k8s.io/kubectl/pkg/drain"
"k8s.io/kubectl/pkg/scheme"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
var (
_ Accessor = (*Node)(nil)
_ NodeMaintainer = (*Node)(nil)
)
// NodeMetricsFunc retrieves node metrics.
type NodeMetricsFunc func() (*mv1beta1.NodeMetricsList, error)
// Node represents a node model.
type Node struct {
Resource
}
// ToggleCordon toggles cordon/uncordon a node.
func (n *Node) ToggleCordon(fqn string, cordon bool) error {
slog.Debug("Toggle cordon on node",
slogs.GVR, n.GVR(),
slogs.FQN, fqn,
slogs.Bool, cordon,
)
o, err := FetchNode(context.Background(), n.Factory, fqn)
if err != nil {
return err
}
h, err := drain.NewCordonHelperFromRuntimeObject(o, scheme.Scheme, n.gvr.GVK())
if err != nil {
slog.Debug("Fail to toggle cordon on node",
slogs.FQN, fqn,
slogs.Error, err,
)
return err
}
if !h.UpdateIfRequired(cordon) {
if cordon {
return fmt.Errorf("node is already cordoned")
}
return fmt.Errorf("node is already uncordoned")
}
dial, err := n.getFactory().Client().Dial()
if err != nil {
return err
}
err, patchErr := h.PatchOrReplace(dial, false)
if patchErr != nil {
return patchErr
}
if err != nil {
return err
}
return nil
}
func (o DrainOptions) toDrainHelper(k kubernetes.Interface, w io.Writer) drain.Helper {
return drain.Helper{
Client: k,
GracePeriodSeconds: o.GracePeriodSeconds,
Timeout: o.Timeout,
DeleteEmptyDirData: o.DeleteEmptyDirData,
IgnoreAllDaemonSets: o.IgnoreAllDaemonSets,
DisableEviction: o.DisableEviction,
Out: w,
ErrOut: w,
Force: o.Force,
}
}
// Drain drains a node.
func (n *Node) Drain(path string, opts DrainOptions, w io.Writer) error {
cordoned, err := n.ensureCordoned(path)
if err != nil {
return err
}
if !cordoned {
if e := n.ToggleCordon(path, true); e != nil {
return e
}
}
dial, err := n.getFactory().Client().Dial()
if err != nil {
return err
}
h := opts.toDrainHelper(dial, w)
dd, errs := h.GetPodsForDeletion(path)
if len(errs) != 0 {
for _, e := range errs {
if _, err := fmt.Fprintf(h.ErrOut, "[%s] %s\n", path, e.Error()); err != nil {
return err
}
}
return errors.Join(errs...)
}
if err := h.DeleteOrEvictPods(dd.Pods()); err != nil {
return err
}
_, _ = fmt.Fprintf(h.Out, "Node %s drained!", path)
return nil
}
// Get returns a node resource.
func (n *Node) Get(ctx context.Context, path string) (runtime.Object, error) {
oo, err := n.Resource.List(ctx, "")
if err != nil {
return nil, err
}
var raw *unstructured.Unstructured
for _, o := range oo {
if u, ok := o.(*unstructured.Unstructured); ok && u.GetName() == path {
raw = u
}
}
if raw == nil {
return nil, fmt.Errorf("unable to locate node %s", path)
}
var nmx *mv1beta1.NodeMetrics
if withMx, ok := ctx.Value(internal.KeyWithMetrics).(bool); ok && withMx {
nmx, _ = client.DialMetrics(n.Client()).FetchNodeMetrics(ctx, path)
}
return &render.NodeWithMetrics{Raw: raw, MX: nmx}, nil
}
// List returns a collection of node resources.
func (n *Node) List(ctx context.Context, ns string) ([]runtime.Object, error) {
oo, err := n.Resource.List(ctx, ns)
if err != nil {
return oo, err
}
var nmx client.NodesMetricsMap
if withMx, ok := ctx.Value(internal.KeyWithMetrics).(bool); withMx || !ok {
nmx, _ = client.DialMetrics(n.Client()).FetchNodesMetricsMap(ctx)
}
shouldCountPods, _ := ctx.Value(internal.KeyPodCounting).(bool)
var pods []runtime.Object
if shouldCountPods {
pods, err = n.getFactory().List(client.PodGVR, client.BlankNamespace, false, labels.Everything())
if err != nil {
slog.Error("Unable to list pods", slogs.Error, err)
}
}
res := make([]runtime.Object, 0, len(oo))
for _, o := range oo {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return res, fmt.Errorf("expecting *unstructured.Unstructured but got `%T", o)
}
fqn := extractFQN(o)
_, name := client.Namespaced(fqn)
podCount := -1
if shouldCountPods {
podCount, err = n.CountPods(pods, name)
if err != nil {
slog.Error("Unable to get pods count",
slogs.ResName, name,
slogs.Error, err,
)
}
}
res = append(res, &render.NodeWithMetrics{
Raw: u,
MX: nmx[name],
PodCount: podCount,
})
}
return res, nil
}
// CountPods counts the pods scheduled on a given node.
func (*Node) CountPods(oo []runtime.Object, nodeName string) (int, error) {
var count int
for _, o := range oo {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return count, fmt.Errorf("expecting *Unstructured but got `%T", o)
}
spec, ok := u.Object["spec"].(map[string]any)
if !ok {
return count, fmt.Errorf("expecting spec interface map but got `%T", o)
}
if node, ok := spec["nodeName"]; ok && node == nodeName {
count++
}
}
return count, nil
}
// GetPods returns all pods running on given node.
func (n *Node) GetPods(nodeName string) ([]*v1.Pod, error) {
oo, err := n.getFactory().List(client.PodGVR, client.BlankNamespace, false, labels.Everything())
if err != nil {
return nil, err
}
pp := make([]*v1.Pod, 0, len(oo))
for _, o := range oo {
po := new(v1.Pod)
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, po); err != nil {
return nil, err
}
if po.Spec.NodeName == nodeName {
pp = append(pp, po)
}
}
return pp, nil
}
// ensureCordoned returns whether the given node has been cordoned
func (n *Node) ensureCordoned(path string) (bool, error) {
o, err := FetchNode(context.Background(), n.Factory, path)
if err != nil {
return false, err
}
return o.Spec.Unschedulable, nil
}
// ----------------------------------------------------------------------------
// Helpers...
// FetchNode retrieves a node.
func FetchNode(_ context.Context, f Factory, path string) (*v1.Node, error) {
_, n := client.Namespaced(path)
auth, err := f.Client().CanI(client.ClusterScope, client.NodeGVR, n, client.GetAccess)
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to list nodes")
}
o, err := f.Get(client.NodeGVR, client.FQN(client.ClusterScope, path), true, labels.Everything())
if err != nil {
return nil, err
}
var node v1.Node
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &node)
if err != nil {
return nil, err
}
return &node, nil
}
// FetchNodes retrieves all nodes.
func FetchNodes(_ context.Context, f Factory, _ string) (*v1.NodeList, error) {
auth, err := f.Client().CanI(client.ClusterScope, client.NodeGVR, "", client.ListAccess)
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to list nodes")
}
oo, err := f.List(client.NodeGVR, "", false, labels.Everything())
if err != nil {
return nil, err
}
nn := make([]v1.Node, 0, len(oo))
for _, o := range oo {
var node v1.Node
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &node)
if err != nil {
return nil, err
}
nn = append(nn, node)
}
return &v1.NodeList{Items: nn}, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/non_resource.go | internal/dao/non_resource.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"sync"
"github.com/derailed/k9s/internal/client"
"k8s.io/apimachinery/pkg/runtime"
)
// NonResource represents a non k8s resource.
type NonResource struct {
Factory
gvr *client.GVR
mx sync.RWMutex
includeObj bool
}
// Init initializes the resource.
func (n *NonResource) Init(f Factory, gvr *client.GVR) {
n.mx.Lock()
n.Factory, n.gvr = f, gvr
n.mx.Unlock()
}
// SetIncludeObject sets if resource object should be included in the api server response.
func (n *NonResource) SetIncludeObject(f bool) {
n.includeObj = f
}
func (n *NonResource) gvrStr() string {
n.mx.RLock()
defer n.mx.RUnlock()
return n.gvr.String()
}
func (n *NonResource) getFactory() Factory {
n.mx.RLock()
defer n.mx.RUnlock()
return n.Factory
}
// GVR returns a gvr.
func (n *NonResource) GVR() string {
n.mx.RLock()
defer n.mx.RUnlock()
return n.gvrStr()
}
// Get returns the given resource.
func (*NonResource) Get(context.Context, string) (runtime.Object, error) {
return nil, fmt.Errorf("nyi")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/alias.go | internal/dao/alias.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"sort"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/render"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/sets"
)
var _ Accessor = (*Alias)(nil)
// Alias tracks standard and custom command aliases.
type Alias struct {
NonResource
*config.Aliases
}
// NewAlias returns a new set of aliases.
func NewAlias(f Factory) *Alias {
a := Alias{
Aliases: config.NewAliases(),
}
a.Init(f, client.AliGVR)
return &a
}
// AliasesFor returns a set of aliases for a given gvr.
func (a *Alias) AliasesFor(gvr *client.GVR) sets.Set[string] {
return a.Aliases.AliasesFor(gvr)
}
// List returns a collection of aliases.
func (*Alias) List(ctx context.Context, _ string) ([]runtime.Object, error) {
aa, ok := ctx.Value(internal.KeyAliases).(*Alias)
if !ok {
return nil, fmt.Errorf("expecting *Alias but got %T", ctx.Value(internal.KeyAliases))
}
m := aa.ShortNames()
oo := make([]runtime.Object, 0, len(m))
for gvr, aliases := range m {
sort.StringSlice(aliases).Sort()
oo = append(oo, render.AliasRes{
GVR: gvr,
Aliases: aliases,
})
}
return oo, nil
}
// Get fetch a resource.
func (*Alias) Get(_ context.Context, _ string) (runtime.Object, error) {
return nil, errors.New("nyi")
}
// Ensure makes sure alias are loaded.
func (a *Alias) Ensure(path string) (config.Alias, error) {
if err := MetaAccess.LoadResources(a.Factory); err != nil {
return config.Alias{}, err
}
return a.Alias, a.load(path)
}
func (a *Alias) load(path string) error {
if err := a.Load(path); err != nil {
return err
}
crdGVRS := make(client.GVRs, 0, 50)
for _, gvr := range MetaAccess.AllGVRs() {
meta, err := MetaAccess.MetaFor(gvr)
if err != nil {
return err
}
if IsK9sMeta(meta) {
continue
}
if IsCRD(meta) {
crdGVRS = append(crdGVRS, gvr)
continue
}
a.Define(gvr, gvr.AsResourceName())
// Allow single shot commands for k8s resources only expect for metrics resource which override pods and nodes ;(!
if isStandardGroup(gvr.GVSub()) && gvr.G() != "metrics.k8s.io" {
a.Define(gvr, meta.Name, meta.SingularName)
}
if len(meta.ShortNames) > 0 {
a.Define(gvr, meta.ShortNames...)
}
a.Define(gvr, gvr.String())
}
for _, gvr := range crdGVRS {
meta, err := MetaAccess.MetaFor(gvr)
if err != nil {
return err
}
a.Define(gvr, strings.ToLower(meta.Kind), meta.Name)
a.Define(gvr, meta.SingularName)
if len(meta.ShortNames) > 0 {
a.Define(gvr, meta.ShortNames...)
}
a.Define(gvr, gvr.String())
a.Define(gvr, meta.Name+"."+meta.Group)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/types.go | internal/dao/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"io"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/watch"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
restclient "k8s.io/client-go/rest"
)
// Factory represents a resource factory.
type Factory interface {
// Client retrieves an api client.
Client() client.Connection
// Get fetch a given resource.
Get(gvr *client.GVR, path string, wait bool, sel labels.Selector) (runtime.Object, error)
// List fetch a collection of resources.
List(gvr *client.GVR, ns string, wait bool, sel labels.Selector) ([]runtime.Object, error)
// ForResource fetch an informer for a given resource.
ForResource(ns string, gvr *client.GVR) (informers.GenericInformer, error)
// CanForResource fetch an informer for a given resource if authorized
CanForResource(ns string, gvr *client.GVR, verbs []string) (informers.GenericInformer, error)
// WaitForCacheSync synchronize the cache.
WaitForCacheSync()
// DeleteForwarder deletes a pod forwarder.
DeleteForwarder(path string)
// Forwarders returns all portforwards.
Forwarders() watch.Forwarders
}
// ImageLister tracks resources with container images.
type ImageLister interface {
// ListImages lists container images.
ListImages(ctx context.Context, path string) ([]string, error)
}
// Getter represents a resource getter.
type Getter interface {
// Get return a given resource.
Get(ctx context.Context, path string) (runtime.Object, error)
}
// Lister represents a resource lister.
type Lister interface {
// List returns a resource collection.
List(ctx context.Context, ns string) ([]runtime.Object, error)
}
// Accessor represents an accessible k8s resource.
type Accessor interface {
Lister
Getter
// Init the resource with a factory object.
Init(Factory, *client.GVR)
// GVR returns a gvr a string.
GVR() string
// SetIncludeObject toggles object inclusion.
SetIncludeObject(bool)
}
// DrainOptions tracks drain attributes.
type DrainOptions struct {
GracePeriodSeconds int
Timeout time.Duration
IgnoreAllDaemonSets bool
DeleteEmptyDirData bool
Force bool
DisableEviction bool
}
// NodeMaintainer performs node maintenance operations.
type NodeMaintainer interface {
// ToggleCordon toggles cordon/uncordon a node.
ToggleCordon(path string, cordon bool) error
// Drain drains the given node.
Drain(path string, opts DrainOptions, w io.Writer) error
}
// Loggable represents resources with logs.
type Loggable interface {
// TailLogs streams resource logs.
TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error)
}
// Describer describes a resource.
type Describer interface {
// Describe describes a resource.
Describe(path string) (string, error)
// ToYAML dumps a resource to YAML.
ToYAML(path string, showManaged bool) (string, error)
}
// Scalable represents resources that can scale.
type Scalable interface {
// Scale scales a resource up or down.
Scale(ctx context.Context, path string, replicas int32) error
}
// ReplicasGetter represents a resource with replicas.
type ReplicasGetter interface {
// Replicas returns the number of replicas for the resource located at the given path.
Replicas(ctx context.Context, path string) (int32, error)
}
// Controller represents a pod controller.
type Controller interface {
// Pod returns a pod instance matching the selector.
Pod(path string) (string, error)
}
// Nuker represents a resource deleter.
type Nuker interface {
// Delete removes a resource from the api server.
Delete(context.Context, string, *metav1.DeletionPropagation, Grace) error
}
// Switchable represents a switchable resource.
type Switchable interface {
// Switch changes the active context.
Switch(ctx string) error
}
// Restartable represents a restartable resource.
type Restartable interface {
// Restart performs a rollout restart.
Restart(context.Context, string, *metav1.PatchOptions) error
}
// Runnable represents a runnable resource.
type Runnable interface {
// Run triggers a run.
Run(path string) error
}
// Logger represents a resource that exposes logs.
type Logger interface {
// Logs tails a resource logs.
Logs(path string, opts *v1.PodLogOptions) (*restclient.Request, error)
}
// ContainsPodSpec represents a resource with a pod template.
type ContainsPodSpec interface {
// GetPodSpec returns a podspec for the resource.
GetPodSpec(path string) (*v1.PodSpec, error)
// SetImages sets container image.
SetImages(ctx context.Context, path string, imageSpecs ImageSpecs) error
}
// Sanitizer represents a resource sanitizer.
type Sanitizer interface {
// Sanitize nukes all resources in unhappy state.
Sanitize(context.Context, string) (int, error)
}
// Valuer represents a resource with values.
type Valuer interface {
// GetValues returns values for a resource.
GetValues(path string, allValues bool) ([]byte, error)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/cluster.go | internal/dao/cluster.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"sync"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
)
// RefScanner represents a resource reference scanner.
type RefScanner interface {
// Init initializes the scanner
Init(Factory, *client.GVR)
// Scan scan the resource for references.
Scan(ctx context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error)
// ScanSA scan the resource for serviceaccount references.
ScanSA(ctx context.Context, fqn string, wait bool) (Refs, error)
}
// Ref represents a resource reference.
type Ref struct {
GVR string
FQN string
}
// Refs represents a collection of resource references.
type Refs []Ref
var (
_ RefScanner = (*Deployment)(nil)
_ RefScanner = (*StatefulSet)(nil)
_ RefScanner = (*DaemonSet)(nil)
_ RefScanner = (*Job)(nil)
_ RefScanner = (*CronJob)(nil)
)
func scanners() map[*client.GVR]RefScanner {
return map[*client.GVR]RefScanner{
client.DpGVR: new(Deployment),
client.DsGVR: new(DaemonSet),
client.StsGVR: new(StatefulSet),
client.CjGVR: new(CronJob),
client.JobGVR: new(Job),
}
}
// ScanForRefs scans cluster resources for resource references.
func ScanForRefs(ctx context.Context, f Factory) (Refs, error) {
rgvr, ok := ctx.Value(internal.KeyGVR).(*client.GVR)
if !ok {
return nil, errors.New("expecting context GVR")
}
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("expecting context Path")
}
wait, ok := ctx.Value(internal.KeyWait).(bool)
if !ok {
slog.Warn("Expecting context Wait key. Using default")
}
var wg sync.WaitGroup
out := make(chan Refs)
for gvr, scanner := range scanners() {
wg.Add(1)
go func(ctx context.Context, gvr *client.GVR, s RefScanner, out chan Refs, wait bool) {
defer wg.Done()
s.Init(f, gvr)
refs, err := s.Scan(ctx, rgvr, fqn, wait)
if err != nil {
slog.Error("Reference scan failed for",
slogs.RefType, fmt.Sprintf("%T", s),
slogs.Error, err,
)
return
}
select {
case out <- refs:
case <-ctx.Done():
return
}
}(ctx, gvr, scanner, out, wait)
}
go func() {
wg.Wait()
close(out)
}()
res := make(Refs, 0, 10)
for refs := range out {
res = append(res, refs...)
}
return res, nil
}
// ScanForSARefs scans cluster resources for serviceaccount refs.
func ScanForSARefs(ctx context.Context, f Factory) (Refs, error) {
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("expecting context Path")
}
wait, ok := ctx.Value(internal.KeyWait).(bool)
if !ok {
return nil, errors.New("expecting context Wait")
}
var wg sync.WaitGroup
out := make(chan Refs)
for gvr, scanner := range scanners() {
wg.Add(1)
go func(ctx context.Context, gvr *client.GVR, s RefScanner, out chan Refs, wait bool) {
defer wg.Done()
s.Init(f, gvr)
refs, err := s.ScanSA(ctx, fqn, wait)
if err != nil {
slog.Error("ServiceAccount scan failed",
slogs.RefType, fmt.Sprintf("%T", s),
slogs.Error, err,
)
return
}
select {
case out <- refs:
case <-ctx.Done():
return
}
}(ctx, gvr, scanner, out, wait)
}
go func() {
wg.Wait()
close(out)
}()
res := make(Refs, 0, 10)
for refs := range out {
res = append(res, refs...)
}
return res, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/crd.go | internal/dao/crd.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
var (
_ Accessor = (*CustomResourceDefinition)(nil)
_ Nuker = (*CustomResourceDefinition)(nil)
)
// CustomResourceDefinition represents a CRD resource model.
type CustomResourceDefinition struct {
Resource
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/benchmark.go | internal/dao/benchmark.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"os"
"path/filepath"
"regexp"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/render"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Benchmark)(nil)
_ Nuker = (*Benchmark)(nil)
BenchRx = regexp.MustCompile(`[:|]+`)
)
// Benchmark represents a benchmark resource.
type Benchmark struct {
NonResource
}
// Delete nukes a resource.
func (*Benchmark) Delete(_ context.Context, path string, _ *metav1.DeletionPropagation, _ Grace) error {
return os.Remove(path)
}
// Get returns a resource.
func (*Benchmark) Get(context.Context, string) (runtime.Object, error) {
panic("NYI")
}
// List returns a collection of resources.
func (*Benchmark) List(ctx context.Context, _ string) ([]runtime.Object, error) {
dir, ok := ctx.Value(internal.KeyDir).(string)
if !ok {
return nil, errors.New("no benchmark dir found in context")
}
path, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("no path specified in context")
}
pathMatch := BenchRx.ReplaceAllString(strings.Replace(path, "/", "_", 1), "_")
ff, err := os.ReadDir(dir)
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(ff))
for _, f := range ff {
if !strings.HasPrefix(f.Name(), pathMatch) {
continue
}
if fi, err := f.Info(); err == nil {
oo = append(oo, render.BenchInfo{File: fi, Path: filepath.Join(dir, f.Name())})
}
}
return oo, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/pod.go | internal/dao/pod.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"log/slog"
"sync"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/watch"
"github.com/derailed/tview"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/sets"
restclient "k8s.io/client-go/rest"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
var (
_ Accessor = (*Pod)(nil)
_ Nuker = (*Pod)(nil)
_ Loggable = (*Pod)(nil)
_ Controller = (*Pod)(nil)
_ ContainsPodSpec = (*Pod)(nil)
_ ImageLister = (*Pod)(nil)
)
type streamResult int
const (
logRetryCount = 20
logBackoffInitial = 500 * time.Millisecond
logBackoffMax = 30 * time.Second
logChannelBuffer = 50 // Buffer size for log channel to reduce drops
streamEOF streamResult = iota // legit container log close (no retry)
streamError // retryable error (network, auth, etc.)
streamCanceled // context canceled
)
// Pod represents a pod resource.
type Pod struct {
Resource
}
// shouldStopRetrying checks if we should stop retrying log streaming based on pod status.
func (p *Pod) shouldStopRetrying(path string) bool {
pod, err := p.GetInstance(path)
if err != nil {
return true
}
if pod.DeletionTimestamp != nil {
return true
}
switch pod.Status.Phase {
case v1.PodSucceeded, v1.PodFailed:
return true
default:
return false
}
}
// Get returns a resource instance if found, else an error.
func (p *Pod) Get(ctx context.Context, path string) (runtime.Object, error) {
o, err := p.Resource.Get(ctx, path)
if err != nil {
return o, err
}
u, ok := o.(*unstructured.Unstructured)
if !ok {
return nil, fmt.Errorf("expecting *unstructured.Unstructured but got `%T", o)
}
var pmx *mv1beta1.PodMetrics
if withMx, ok := ctx.Value(internal.KeyWithMetrics).(bool); ok && withMx {
pmx, _ = client.DialMetrics(p.Client()).FetchPodMetrics(ctx, path)
}
return &render.PodWithMetrics{Raw: u, MX: pmx}, nil
}
// ListImages lists container images.
func (p *Pod) ListImages(_ context.Context, path string) ([]string, error) {
pod, err := p.GetInstance(path)
if err != nil {
return nil, err
}
return render.ExtractImages(&pod.Spec), nil
}
// List returns a collection of nodes.
func (p *Pod) List(ctx context.Context, ns string) ([]runtime.Object, error) {
oo, err := p.Resource.List(ctx, ns)
if err != nil {
return oo, err
}
var pmx client.PodsMetricsMap
if withMx, ok := ctx.Value(internal.KeyWithMetrics).(bool); ok && withMx {
pmx, _ = client.DialMetrics(p.Client()).FetchPodsMetricsMap(ctx, ns)
}
sel, _ := ctx.Value(internal.KeyFields).(string)
fsel, err := labels.ConvertSelectorToLabelsMap(sel)
if err != nil {
return nil, err
}
nodeName := fsel["spec.nodeName"]
res := make([]runtime.Object, 0, len(oo))
for _, o := range oo {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return res, fmt.Errorf("expecting *unstructured.Unstructured but got `%T", o)
}
fqn := extractFQN(o)
if nodeName == "" {
res = append(res, &render.PodWithMetrics{Raw: u, MX: pmx[fqn]})
continue
}
spec, ok := u.Object["spec"].(map[string]any)
if !ok {
return res, fmt.Errorf("expecting interface map but got `%T", o)
}
if spec["nodeName"] == nodeName {
res = append(res, &render.PodWithMetrics{Raw: u, MX: pmx[fqn]})
}
}
return res, nil
}
// Logs fetch container logs for a given pod and container.
func (p *Pod) Logs(path string, opts *v1.PodLogOptions) (*restclient.Request, error) {
ns, n := client.Namespaced(path)
auth, err := p.Client().CanI(ns, client.NewGVR(client.PodGVR.String()+":log"), n, client.GetAccess)
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to view pod logs")
}
dial, err := p.Client().DialLogs()
if err != nil {
return nil, err
}
return dial.CoreV1().Pods(ns).GetLogs(n, opts), nil
}
// Containers returns all container names on pod.
func (p *Pod) Containers(path string, includeInit bool) ([]string, error) {
pod, err := p.GetInstance(path)
if err != nil {
return nil, err
}
cc := make([]string, 0, len(pod.Spec.Containers)+len(pod.Spec.InitContainers))
for i := range pod.Spec.Containers {
cc = append(cc, pod.Spec.Containers[i].Name)
}
if includeInit {
for i := range pod.Spec.InitContainers {
cc = append(cc, pod.Spec.InitContainers[i].Name)
}
}
return cc, nil
}
// Pod returns a pod victim by name.
func (*Pod) Pod(fqn string) (string, error) {
return fqn, nil
}
// GetInstance returns a pod instance.
func (p *Pod) GetInstance(fqn string) (*v1.Pod, error) {
o, err := p.getFactory().Get(p.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, err
}
return &pod, nil
}
// TailLogs tails a given container logs.
func (p *Pod) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
fac, ok := ctx.Value(internal.KeyFactory).(*watch.Factory)
if !ok {
return nil, errors.New("no factory in context")
}
o, err := fac.Get(p.gvr, opts.Path, true, labels.Everything())
if err != nil {
return nil, err
}
var po v1.Pod
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &po); err != nil {
return nil, err
}
coCounts := len(po.Spec.InitContainers) + len(po.Spec.Containers) + len(po.Spec.EphemeralContainers)
if coCounts == 1 {
opts.SingleContainer = true
}
outs := make([]LogChan, 0, coCounts)
if co, ok := GetDefaultContainer(&po.ObjectMeta, &po.Spec); ok && !opts.AllContainers {
opts.DefaultContainer = co
return append(outs, tailLogs(ctx, p, opts)), nil
}
if opts.HasContainer() && !opts.AllContainers {
return append(outs, tailLogs(ctx, p, opts)), nil
}
for i := range po.Spec.InitContainers {
cfg := opts.Clone()
cfg.Container = po.Spec.InitContainers[i].Name
outs = append(outs, tailLogs(ctx, p, cfg))
}
for i := range po.Spec.Containers {
cfg := opts.Clone()
cfg.Container = po.Spec.Containers[i].Name
outs = append(outs, tailLogs(ctx, p, cfg))
}
for i := range po.Spec.EphemeralContainers {
cfg := opts.Clone()
cfg.Container = po.Spec.EphemeralContainers[i].Name
outs = append(outs, tailLogs(ctx, p, cfg))
}
return outs, nil
}
// ScanSA scans for ServiceAccount refs.
func (p *Pod) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := p.getFactory().List(p.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, errors.New("expecting Deployment resource")
}
// Just pick controller less pods...
if len(pod.OwnerReferences) > 0 {
continue
}
if serviceAccountMatches(pod.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: p.GVR(),
FQN: client.FQN(pod.Namespace, pod.Name),
})
}
}
return refs, nil
}
// Scan scans for cluster resource refs.
func (p *Pod) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := p.getFactory().List(p.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, errors.New("expecting Pod resource")
}
// Just pick controller less pods...
if len(pod.OwnerReferences) > 0 {
continue
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&pod.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: p.GVR(),
FQN: client.FQN(pod.Namespace, pod.Name),
})
case client.SecGVR:
found, err := hasSecret(p.Factory, &pod.Spec, pod.Namespace, n, wait)
if err != nil {
slog.Warn("Locate secret failed",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: p.GVR(),
FQN: client.FQN(pod.Namespace, pod.Name),
})
case client.PvcGVR:
if !hasPVC(&pod.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: p.GVR(),
FQN: client.FQN(pod.Namespace, pod.Name),
})
case client.PcGVR:
if !hasPC(&pod.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: p.GVR(),
FQN: client.FQN(pod.Namespace, pod.Name),
})
}
}
return refs, nil
}
// ----------------------------------------------------------------------------
// Helpers...
func tailLogs(ctx context.Context, logger Logger, opts *LogOptions) LogChan {
out := make(LogChan, logChannelBuffer)
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
podOpts := opts.ToPodLogOptions()
// Setup exponential backoff following project pattern
bf := backoff.NewExponentialBackOff()
bf.InitialInterval = logBackoffInitial
bf.MaxElapsedTime = 0
bf.MaxInterval = logBackoffMax / 2
backoffCtx := backoff.WithContext(bf, ctx)
delay := logBackoffInitial
for range logRetryCount {
req, err := logger.Logs(opts.Path, podOpts)
if err != nil {
slog.Error("Log request failed",
slogs.Container, opts.Info(),
slogs.Error, err,
)
// Check if we should stop retrying based on pod status
if pod, ok := logger.(*Pod); ok && pod.shouldStopRetrying(opts.Path) {
slog.Debug("Stopping log retry - pod is terminating or deleted",
slogs.Container, opts.Info(),
)
return
}
select {
case <-ctx.Done():
return
case <-time.After(delay):
if delay = backoffCtx.NextBackOff(); delay == backoff.Stop {
return
}
}
continue
}
stream, e := req.Stream(ctx)
if e != nil {
slog.Error("Stream logs failed",
slogs.Error, e,
slogs.Container, opts.Info(),
)
// Check if we should stop retrying based on pod status
if pod, ok := logger.(*Pod); ok && pod.shouldStopRetrying(opts.Path) {
slog.Debug("Stopping log retry - pod is terminating or deleted",
slogs.Container, opts.Info(),
)
return
}
select {
case <-ctx.Done():
return
case <-time.After(delay):
if delay = backoffCtx.NextBackOff(); delay == backoff.Stop {
return
}
}
continue
}
// Process logs until completion
result := readLogs(ctx, stream, out, opts)
switch result {
case streamEOF:
slog.Debug("Log stream ended cleanly",
slogs.Container, opts.Info(),
)
return
case streamError:
// Check if we should stop retrying based on pod status
if pod, ok := logger.(*Pod); ok && pod.shouldStopRetrying(opts.Path) {
slog.Debug("Stopping log retry after stream error - pod is terminating or deleted",
slogs.Container, opts.Info(),
)
return
}
slog.Debug("Log stream error, retrying",
slogs.Container, opts.Info(),
)
select {
case <-ctx.Done():
return
case <-time.After(delay):
if delay = backoffCtx.NextBackOff(); delay == backoff.Stop {
return
}
}
continue
case streamCanceled:
return
}
// Reset backoff and delay on successful connection
bf.Reset()
delay = logBackoffInitial
}
// Out of retries
out <- opts.ToErrLogItem(fmt.Errorf("failed to maintain log stream after %d retries", logRetryCount))
}()
go func() {
wg.Wait()
close(out)
}()
return out
}
func readLogs(ctx context.Context, stream io.ReadCloser, out chan<- *LogItem, opts *LogOptions) streamResult {
defer func() {
if err := stream.Close(); err != nil && !errors.Is(err, io.ErrClosedPipe) {
slog.Error("Failed to close stream",
slogs.Container, opts.Info(),
slogs.Error, err,
)
}
}()
r := bufio.NewReader(stream)
for {
bytes, err := r.ReadBytes('\n')
if err == nil {
item := opts.ToLogItem(tview.EscapeBytes(bytes))
select {
case <-ctx.Done():
return streamCanceled
case out <- item:
default:
// Avoid deadlock if consumer is too slow
slog.Warn("Dropping log line due to slow consumer",
slogs.Container, opts.Info(),
)
}
continue
}
if errors.Is(err, io.EOF) {
if len(bytes) > 0 {
// Emit trailing partial line before EOF
out <- opts.ToLogItem(tview.EscapeBytes(bytes))
}
slog.Debug("Log reader reached EOF", slogs.Container, opts.Info())
out <- opts.ToErrLogItem(fmt.Errorf("stream closed: %w for %s", err, opts.Info()))
return streamEOF
}
// Non-EOF error
slog.Debug("Log stream error, will retry connection",
slogs.Container, opts.Info(),
slogs.Error, fmt.Errorf("stream error: %w for %s", err, opts.Info()),
)
// Don't send stream errors to user - they will be retried
// Only final retry exhaustion message is shown
return streamError
}
}
// MetaFQN returns a fully qualified resource name.
func MetaFQN(m *metav1.ObjectMeta) string {
if m.Namespace == "" {
return m.Name
}
return FQN(m.Namespace, m.Name)
}
// GetPodSpec returns a pod spec given a resource.
func (p *Pod) GetPodSpec(path string) (*v1.PodSpec, error) {
pod, err := p.GetInstance(path)
if err != nil {
return nil, err
}
podSpec := pod.Spec
return &podSpec, nil
}
// SetImages sets container images.
func (p *Pod) SetImages(ctx context.Context, path string, imageSpecs ImageSpecs) error {
ns, n := client.Namespaced(path)
auth, err := p.Client().CanI(ns, p.gvr, n, client.PatchAccess)
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to patch a deployment")
}
manager, isManaged, err := p.isControlled(path)
if err != nil {
return err
}
if isManaged {
return fmt.Errorf("unable to set image. This pod is managed by %s. Please set the image on the controller", manager)
}
jsonPatch, err := GetJsonPatch(imageSpecs)
if err != nil {
return err
}
dial, err := p.Client().Dial()
if err != nil {
return err
}
_, err = dial.CoreV1().Pods(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
jsonPatch,
metav1.PatchOptions{},
)
return err
}
func (p *Pod) isControlled(path string) (fqn string, ok bool, err error) {
pod, err := p.GetInstance(path)
if err != nil {
return "", false, err
}
references := pod.GetObjectMeta().GetOwnerReferences()
if len(references) > 0 {
return fmt.Sprintf("%s/%s", references[0].Kind, references[0].Name), true, nil
}
return "", false, nil
}
var toastPhases = sets.New(
render.PhaseCompleted,
render.PhasePending,
render.PhaseCrashLoop,
render.PhaseError,
render.PhaseImagePullBackOff,
render.PhaseContainerStatusUnknown,
render.PhaseEvicted,
render.PhaseOOMKilled,
)
func (p *Pod) Sanitize(ctx context.Context, ns string) (int, error) {
oo, err := p.Resource.List(ctx, ns)
if err != nil {
return 0, err
}
var count int
for _, o := range oo {
u, ok := o.(*unstructured.Unstructured)
if !ok {
continue
}
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, &pod)
if err != nil {
continue
}
if toastPhases.Has(render.PodStatus(&pod)) {
// !!BOZO!! Might need to bump timeout otherwise rev limit if too many??
fqn := client.FQN(pod.Namespace, pod.Name)
slog.Debug("Sanitizing resource", slogs.FQN, fqn)
if err := p.Delete(ctx, fqn, nil, 0); err != nil {
slog.Debug("Aborted! Sanitizer delete failed",
slogs.FQN, fqn,
slogs.Count, count,
slogs.Error, err,
)
return count, err
}
count++
}
}
slog.Debug("Sanitizer deleted pods", slogs.Count, count)
return count, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/container_test.go | internal/dao/container_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/watch"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/version"
"k8s.io/client-go/discovery/cached/disk"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes"
restclient "k8s.io/client-go/rest"
versioned "k8s.io/metrics/pkg/client/clientset/versioned"
"sigs.k8s.io/yaml"
)
func TestContainerList(t *testing.T) {
c := dao.Container{}
c.Init(makePodFactory(), client.CoGVR)
ctx := context.WithValue(context.Background(), internal.KeyPath, "fred/p1")
oo, err := c.List(ctx, "")
require.NoError(t, err)
assert.Len(t, oo, 1)
}
// ----------------------------------------------------------------------------
// Helpers...
type conn struct{}
func makeConn() *conn {
return &conn{}
}
func (*conn) Config() *client.Config { return nil }
func (*conn) Dial() (kubernetes.Interface, error) { return nil, nil }
func (*conn) DialLogs() (kubernetes.Interface, error) { return nil, nil }
func (*conn) ConnectionOK() bool { return true }
func (*conn) SwitchContext(string) error { return nil }
func (*conn) CachedDiscovery() (*disk.CachedDiscoveryClient, error) { return nil, nil }
func (*conn) RestConfig() (*restclient.Config, error) { return nil, nil }
func (*conn) MXDial() (*versioned.Clientset, error) { return nil, nil }
func (*conn) DynDial() (dynamic.Interface, error) { return nil, nil }
func (*conn) HasMetrics() bool { return false }
func (*conn) CheckConnectivity() bool { return false }
func (*conn) IsNamespaced(string) bool { return false }
func (*conn) SupportsResource(string) bool { return false }
func (*conn) ValidNamespaces() ([]v1.Namespace, error) { return nil, nil }
func (*conn) SupportsRes(string, []string) (a string, b bool, e error) { return "", false, nil }
func (*conn) ServerVersion() (*version.Info, error) { return nil, nil }
func (*conn) CurrentNamespaceName() (string, error) { return "", nil }
func (*conn) CanI(string, *client.GVR, string, []string) (bool, error) { return true, nil }
func (*conn) ActiveContext() string { return "" }
func (*conn) ActiveNamespace() string { return "" }
func (*conn) IsValidNamespace(string) bool { return true }
func (*conn) ValidNamespaceNames() (client.NamespaceNames, error) { return nil, nil }
func (*conn) IsActiveNamespace(string) bool { return false }
type podFactory struct{}
var _ dao.Factory = &testFactory{}
func (podFactory) Client() client.Connection {
return makeConn()
}
func (podFactory) Get(*client.GVR, string, bool, labels.Selector) (runtime.Object, error) {
var m map[string]any
if err := yaml.Unmarshal([]byte(poYaml()), &m); err != nil {
return nil, err
}
return &unstructured.Unstructured{Object: m}, nil
}
func (podFactory) List(*client.GVR, string, bool, labels.Selector) ([]runtime.Object, error) {
return nil, nil
}
func (podFactory) ForResource(string, *client.GVR) (informers.GenericInformer, error) {
return nil, nil
}
func (podFactory) CanForResource(string, *client.GVR, []string) (informers.GenericInformer, error) {
return nil, nil
}
func (podFactory) WaitForCacheSync() {}
func (podFactory) Forwarders() watch.Forwarders { return nil }
func (podFactory) DeleteForwarder(string) {}
func makePodFactory() dao.Factory {
return podFactory{}
}
func poYaml() string {
return `apiVersion: v1
kind: Pod
metadata:
creationTimestamp: "2018-12-14T17:36:43Z"
labels:
blee: duh
name: fred
namespace: blee
spec:
containers:
- env:
- name: fred
value: "1"
valueFrom:
configMapKeyRef:
key: blee
image: blee
name: fred
resources: {}
priority: 1
priorityClassName: bozo
volumes:
- hostPath:
path: /blee
type: Directory
name: fred
status:
containerStatuses:
- image: ""
imageID: ""
lastState: {}
name: fred
ready: false
restartCount: 0
state:
running:
startedAt: null
phase: Running
`
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/dp.go | internal/dao/dp.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
appsv1 "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/strategicpatch"
"k8s.io/kubectl/pkg/polymorphichelpers"
"k8s.io/kubectl/pkg/scheme"
)
var (
_ Accessor = (*Deployment)(nil)
_ Nuker = (*Deployment)(nil)
_ Loggable = (*Deployment)(nil)
_ Restartable = (*Deployment)(nil)
_ Scalable = (*Deployment)(nil)
_ Controller = (*Deployment)(nil)
_ ContainsPodSpec = (*Deployment)(nil)
_ ImageLister = (*Deployment)(nil)
)
// Deployment represents a deployment K8s resource.
type Deployment struct {
Resource
}
// ListImages lists container images.
func (d *Deployment) ListImages(_ context.Context, fqn string) ([]string, error) {
dp, err := d.GetInstance(fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&dp.Spec.Template.Spec), nil
}
// Scale a Deployment.
func (d *Deployment) Scale(ctx context.Context, path string, replicas int32) error {
return scaleRes(ctx, d.getFactory(), client.DpGVR, path, replicas)
}
// Restart a Deployment rollout.
func (d *Deployment) Restart(ctx context.Context, path string, opts *metav1.PatchOptions) error {
return restartRes[*appsv1.Deployment](ctx, d.getFactory(), client.DpGVR, path, opts)
}
// TailLogs tail logs for all pods represented by this Deployment.
func (d *Deployment) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
dp, err := d.GetInstance(opts.Path)
if err != nil {
return nil, err
}
if dp.Spec.Selector == nil || len(dp.Spec.Selector.MatchLabels) == 0 {
return nil, fmt.Errorf("no valid selector found on deployment: %s", opts.Path)
}
return podLogs(ctx, dp.Spec.Selector.MatchLabels, opts)
}
// Pod returns a pod victim by name.
func (d *Deployment) Pod(fqn string) (string, error) {
dp, err := d.GetInstance(fqn)
if err != nil {
return "", err
}
return podFromSelector(d.Factory, dp.Namespace, dp.Spec.Selector.MatchLabels)
}
// GetInstance fetch a matching deployment.
func (d *Deployment) GetInstance(fqn string) (*appsv1.Deployment, error) {
o, err := d.Factory.Get(d.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var dp appsv1.Deployment
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &dp)
if err != nil {
return nil, errors.New("expecting Deployment resource")
}
return &dp, nil
}
// ScanSA scans for serviceaccount refs.
func (d *Deployment) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := d.getFactory().List(d.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var dp appsv1.Deployment
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &dp)
if err != nil {
return nil, errors.New("expecting Deployment resource")
}
if serviceAccountMatches(dp.Spec.Template.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(dp.Namespace, dp.Name),
})
}
}
return refs, nil
}
// Scan scans for resource references.
func (d *Deployment) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := d.getFactory().List(d.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var dp appsv1.Deployment
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &dp)
if err != nil {
return nil, errors.New("expecting Deployment resource")
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&dp.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(dp.Namespace, dp.Name),
})
case client.SecGVR:
found, err := hasSecret(d.Factory, &dp.Spec.Template.Spec, dp.Namespace, n, wait)
if err != nil {
slog.Warn("Fail to locate secret",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(dp.Namespace, dp.Name),
})
case client.PvcGVR:
if !hasPVC(&dp.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(dp.Namespace, dp.Name),
})
case client.PcGVR:
if !hasPC(&dp.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(dp.Namespace, dp.Name),
})
}
}
return refs, nil
}
// GetPodSpec returns a pod spec given a resource.
func (d *Deployment) GetPodSpec(path string) (*v1.PodSpec, error) {
dp, err := d.GetInstance(path)
if err != nil {
return nil, err
}
podSpec := dp.Spec.Template.Spec
return &podSpec, nil
}
// SetImages sets container images.
func (d *Deployment) SetImages(ctx context.Context, path string, imageSpecs ImageSpecs) error {
ns, n := client.Namespaced(path)
auth, err := d.Client().CanI(ns, d.gvr, n, client.PatchAccess)
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to patch a deployment")
}
jsonPatch, err := GetTemplateJsonPatch(imageSpecs)
if err != nil {
return err
}
dial, err := d.Client().Dial()
if err != nil {
return err
}
_, err = dial.AppsV1().Deployments(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
jsonPatch,
metav1.PatchOptions{},
)
return err
}
// Helpers...
func hasPVC(spec *v1.PodSpec, name string) bool {
for i := range spec.Volumes {
if spec.Volumes[i].PersistentVolumeClaim != nil && spec.Volumes[i].PersistentVolumeClaim.ClaimName == name {
return true
}
}
return false
}
func hasPC(spec *v1.PodSpec, name string) bool {
return spec.PriorityClassName == name
}
func hasConfigMap(spec *v1.PodSpec, name string) bool {
for i := range spec.InitContainers {
if containerHasConfigMap(spec.InitContainers[i].EnvFrom, spec.InitContainers[i].Env, name) {
return true
}
}
for i := range spec.Containers {
if containerHasConfigMap(spec.Containers[i].EnvFrom, spec.Containers[i].Env, name) {
return true
}
}
for i := range spec.EphemeralContainers {
if containerHasConfigMap(spec.EphemeralContainers[i].EnvFrom, spec.EphemeralContainers[i].Env, name) {
return true
}
}
for i := range spec.Volumes {
if cm := spec.Volumes[i].ConfigMap; cm != nil {
if cm.Name == name {
return true
}
}
}
return false
}
func hasSecret(f Factory, spec *v1.PodSpec, ns, name string, wait bool) (bool, error) {
for i := range spec.InitContainers {
if containerHasSecret(spec.InitContainers[i].EnvFrom, spec.InitContainers[i].Env, name) {
return true, nil
}
}
for i := range spec.Containers {
if containerHasSecret(spec.Containers[i].EnvFrom, spec.Containers[i].Env, name) {
return true, nil
}
}
for i := range spec.EphemeralContainers {
if containerHasSecret(spec.EphemeralContainers[i].EnvFrom, spec.EphemeralContainers[i].Env, name) {
return true, nil
}
}
for _, s := range spec.ImagePullSecrets {
if s.Name == name {
return true, nil
}
}
if saName := spec.ServiceAccountName; saName != "" {
o, err := f.Get(client.SaGVR, client.FQN(ns, saName), wait, labels.Everything())
if err != nil {
return false, err
}
var sa v1.ServiceAccount
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &sa)
if err != nil {
return false, errors.New("expecting ServiceAccount resource")
}
for _, ref := range sa.Secrets {
if ref.Namespace == ns && ref.Name == name {
return true, nil
}
}
}
for i := range spec.Volumes {
if sec := spec.Volumes[i].Secret; sec != nil {
if sec.SecretName == name {
return true, nil
}
}
}
return false, nil
}
func containerHasSecret(envFrom []v1.EnvFromSource, env []v1.EnvVar, name string) bool {
for _, e := range envFrom {
if e.SecretRef != nil && e.SecretRef.Name == name {
return true
}
}
for _, e := range env {
if e.ValueFrom == nil || e.ValueFrom.SecretKeyRef == nil {
continue
}
if e.ValueFrom.SecretKeyRef.Name == name {
return true
}
}
return false
}
func containerHasConfigMap(envFrom []v1.EnvFromSource, env []v1.EnvVar, name string) bool {
for _, e := range envFrom {
if e.ConfigMapRef != nil && e.ConfigMapRef.Name == name {
return true
}
}
for _, e := range env {
if e.ValueFrom == nil || e.ValueFrom.ConfigMapKeyRef == nil {
continue
}
if e.ValueFrom.ConfigMapKeyRef.Name == name {
return true
}
}
return false
}
func scaleRes(ctx context.Context, f Factory, gvr *client.GVR, path string, replicas int32) error {
ns, n := client.Namespaced(path)
auth, err := f.Client().CanI(ns, client.NewGVR(gvr.String()+":scale"), n, []string{client.GetVerb, client.UpdateVerb})
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to scale: %s", gvr)
}
dial, err := f.Client().Dial()
if err != nil {
return err
}
switch gvr {
case client.DpGVR:
scale, e := dial.AppsV1().Deployments(ns).GetScale(ctx, n, metav1.GetOptions{})
if e != nil {
return e
}
scale.Spec.Replicas = replicas
_, e = dial.AppsV1().Deployments(ns).UpdateScale(ctx, n, scale, metav1.UpdateOptions{})
return e
case client.StsGVR:
scale, e := dial.AppsV1().StatefulSets(ns).GetScale(ctx, n, metav1.GetOptions{})
if e != nil {
return e
}
scale.Spec.Replicas = replicas
_, e = dial.AppsV1().StatefulSets(ns).UpdateScale(ctx, n, scale, metav1.UpdateOptions{})
return e
default:
return fmt.Errorf("unsupported resource for scaling: %s", gvr)
}
}
func restartRes[T runtime.Object](ctx context.Context, f Factory, gvr *client.GVR, path string, opts *metav1.PatchOptions) error {
o, err := f.Get(gvr, path, true, labels.Everything())
if err != nil {
return err
}
var r = new(T)
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, r)
if err != nil {
return err
}
ns, n := client.Namespaced(path)
auth, err := f.Client().CanI(ns, gvr, n, client.PatchAccess)
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to restart %q", gvr)
}
dial, err := f.Client().Dial()
if err != nil {
return err
}
before, err := runtime.Encode(scheme.Codecs.LegacyCodec(appsv1.SchemeGroupVersion), *r)
if err != nil {
return err
}
after, err := polymorphichelpers.ObjectRestarterFn(*r)
if err != nil {
return err
}
diff, err := strategicpatch.CreateTwoWayMergePatch(before, after, *r)
if err != nil {
return err
}
switch gvr {
case client.DpGVR:
_, err = dial.AppsV1().Deployments(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
diff,
*opts,
)
case client.DsGVR:
_, err = dial.AppsV1().DaemonSets(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
diff,
*opts,
)
case client.StsGVR:
_, err = dial.AppsV1().StatefulSets(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
diff,
*opts,
)
}
return err
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/helm_history.go | internal/dao/helm_history.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"strconv"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/render/helm"
"helm.sh/helm/v3/pkg/action"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*HelmHistory)(nil)
_ Nuker = (*HelmHistory)(nil)
_ Describer = (*HelmHistory)(nil)
_ Valuer = (*HelmHistory)(nil)
)
// HelmHistory represents a helm chart.
type HelmHistory struct {
NonResource
}
// List returns a collection of resources.
func (h *HelmHistory) List(ctx context.Context, _ string) ([]runtime.Object, error) {
path, ok := ctx.Value(internal.KeyFQN).(string)
if !ok {
return nil, fmt.Errorf("expecting FQN in context")
}
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return nil, err
}
hh, err := action.NewHistory(cfg).Run(n)
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(hh))
for _, r := range hh {
oo = append(oo, helm.ReleaseRes{Release: r})
}
return oo, nil
}
// Get returns a resource.
func (h *HelmHistory) Get(_ context.Context, path string) (runtime.Object, error) {
fqn, rev, found := strings.Cut(path, ":")
if !found || rev == "" {
return nil, fmt.Errorf("invalid path %q", path)
}
ns, n := client.Namespaced(fqn)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return nil, err
}
getter := action.NewGet(cfg)
getter.Version, err = strconv.Atoi(rev)
if err != nil {
return nil, err
}
resp, err := getter.Run(n)
if err != nil {
return nil, err
}
return helm.ReleaseRes{Release: resp}, nil
}
// Describe returns the chart notes.
func (h *HelmHistory) Describe(path string) (string, error) {
rel, err := h.Get(context.Background(), path)
if err != nil {
return "", err
}
resp, ok := rel.(helm.ReleaseRes)
if !ok {
return "", fmt.Errorf("expected helm.ReleaseRes, but got %T", rel)
}
return resp.Release.Info.Notes, nil
}
// ToYAML returns the chart manifest.
func (h *HelmHistory) ToYAML(path string, _ bool) (string, error) {
rel, err := h.Get(context.Background(), path)
if err != nil {
return "", err
}
resp, ok := rel.(helm.ReleaseRes)
if !ok {
return "", fmt.Errorf("expected helm.ReleaseRes, but got %T", rel)
}
return resp.Release.Manifest, nil
}
// GetValues return the config for this chart.
func (h *HelmHistory) GetValues(path string, allValues bool) ([]byte, error) {
rel, err := h.Get(context.Background(), path)
if err != nil {
return nil, err
}
resp, ok := rel.(helm.ReleaseRes)
if !ok {
return nil, fmt.Errorf("expected helm.ReleaseRes, but got %T", rel)
}
var content any
if allValues {
content = resp.Release.Chart.Values
} else {
content = resp.Release.Config
}
return data.WriteYAML(content)
}
func (h *HelmHistory) Rollback(_ context.Context, path, rev string) error {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return err
}
ver, err := strconv.Atoi(rev)
if err != nil {
return fmt.Errorf("could not convert revision to a number: %w", err)
}
clt := action.NewRollback(cfg)
clt.Version = ver
return clt.Run(n)
}
// Delete uninstall a Helm.
func (h *HelmHistory) Delete(_ context.Context, path string, _ *metav1.DeletionPropagation, _ Grace) error {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return err
}
res, err := action.NewUninstall(cfg).Run(n)
if err != nil {
return err
}
if res != nil && res.Info != "" {
return fmt.Errorf("%s", res.Info)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/screen_dump.go | internal/dao/screen_dump.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"os"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/render"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*ScreenDump)(nil)
_ Nuker = (*ScreenDump)(nil)
)
// ScreenDump represents a scraped resources.
type ScreenDump struct {
NonResource
}
// Delete a ScreenDump.
func (*ScreenDump) Delete(_ context.Context, path string, _ *metav1.DeletionPropagation, _ Grace) error {
return os.Remove(path)
}
// List returns a collection of screen dumps.
func (*ScreenDump) List(ctx context.Context, _ string) ([]runtime.Object, error) {
dir, ok := ctx.Value(internal.KeyDir).(string)
if !ok {
return nil, errors.New("no screendump dir found in context")
}
ff, err := os.ReadDir(dir)
if err != nil {
return nil, err
}
oo := make([]runtime.Object, len(ff))
for i, f := range ff {
if fi, err := f.Info(); err == nil {
oo[i] = render.FileRes{File: fi, Dir: dir}
}
}
return oo, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/ds.go | internal/dao/ds.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/watch"
appsv1 "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
)
var (
_ Accessor = (*DaemonSet)(nil)
_ Nuker = (*DaemonSet)(nil)
_ Loggable = (*DaemonSet)(nil)
_ Restartable = (*DaemonSet)(nil)
_ Controller = (*DaemonSet)(nil)
_ ContainsPodSpec = (*DaemonSet)(nil)
_ ImageLister = (*DaemonSet)(nil)
)
// DaemonSet represents a K8s daemonset.
type DaemonSet struct {
Resource
}
// ListImages lists container images.
func (d *DaemonSet) ListImages(_ context.Context, fqn string) ([]string, error) {
ds, err := d.GetInstance(fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&ds.Spec.Template.Spec), nil
}
// Restart a DaemonSet rollout.
func (d *DaemonSet) Restart(ctx context.Context, path string, opts *metav1.PatchOptions) error {
return restartRes[*appsv1.DaemonSet](ctx, d.getFactory(), client.DsGVR, path, opts)
}
// TailLogs tail logs for all pods represented by this DaemonSet.
func (d *DaemonSet) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
ds, err := d.GetInstance(opts.Path)
if err != nil {
return nil, err
}
if ds.Spec.Selector == nil || len(ds.Spec.Selector.MatchLabels) == 0 {
return nil, fmt.Errorf("no valid selector found on daemonset %q", opts.Path)
}
return podLogs(ctx, ds.Spec.Selector.MatchLabels, opts)
}
func podLogs(ctx context.Context, sel map[string]string, opts *LogOptions) ([]LogChan, error) {
f, ok := ctx.Value(internal.KeyFactory).(*watch.Factory)
if !ok {
return nil, errors.New("expecting a context factory")
}
ls, err := metav1.ParseToLabelSelector(toSelector(sel))
if err != nil {
return nil, err
}
lsel, err := metav1.LabelSelectorAsSelector(ls)
if err != nil {
return nil, err
}
ns, _ := client.Namespaced(opts.Path)
oo, err := f.List(client.PodGVR, ns, true, lsel)
if err != nil {
return nil, err
}
opts.MultiPods = true
var po Pod
po.Init(f, client.PodGVR)
outs := make([]LogChan, 0, len(oo))
for _, o := range oo {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return nil, fmt.Errorf("expected unstructured got %t", o)
}
opts = opts.Clone()
opts.Path = client.FQN(u.GetNamespace(), u.GetName())
cc, err := po.TailLogs(ctx, opts)
if err != nil {
return nil, err
}
outs = append(outs, cc...)
}
return outs, nil
}
// Pod returns a pod victim by name.
func (d *DaemonSet) Pod(fqn string) (string, error) {
ds, err := d.GetInstance(fqn)
if err != nil {
return "", err
}
return podFromSelector(d.Factory, ds.Namespace, ds.Spec.Selector.MatchLabels)
}
// GetInstance returns a daemonset instance.
func (d *DaemonSet) GetInstance(fqn string) (*appsv1.DaemonSet, error) {
o, err := d.getFactory().Get(d.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var ds appsv1.DaemonSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &ds)
if err != nil {
return nil, errors.New("expecting DaemonSet resource")
}
return &ds, nil
}
// ScanSA scans for serviceaccount refs.
func (d *DaemonSet) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := d.getFactory().List(d.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var ds appsv1.DaemonSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &ds)
if err != nil {
return nil, errors.New("expecting DaemonSet resource")
}
if serviceAccountMatches(ds.Spec.Template.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(ds.Namespace, ds.Name),
})
}
}
return refs, nil
}
// Scan scans for cluster refs.
func (d *DaemonSet) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := d.getFactory().List(d.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var ds appsv1.DaemonSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &ds)
if err != nil {
return nil, errors.New("expecting StatefulSet resource")
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&ds.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(ds.Namespace, ds.Name),
})
case client.SecGVR:
found, err := hasSecret(d.Factory, &ds.Spec.Template.Spec, ds.Namespace, n, wait)
if err != nil {
slog.Warn("Unable to locate secret",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(ds.Namespace, ds.Name),
})
case client.PvcGVR:
if !hasPVC(&ds.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(ds.Namespace, ds.Name),
})
case client.PcGVR:
if !hasPC(&ds.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: d.GVR(),
FQN: client.FQN(ds.Namespace, ds.Name),
})
}
}
return refs, nil
}
// GetPodSpec returns a pod spec given a resource.
func (d *DaemonSet) GetPodSpec(path string) (*v1.PodSpec, error) {
ds, err := d.GetInstance(path)
if err != nil {
return nil, err
}
podSpec := ds.Spec.Template.Spec
return &podSpec, nil
}
// SetImages sets container images.
func (d *DaemonSet) SetImages(ctx context.Context, path string, imageSpecs ImageSpecs) error {
ns, n := client.Namespaced(path)
auth, err := d.Client().CanI(ns, d.gvr, n, client.PatchAccess)
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to patch a daemonset")
}
jsonPatch, err := GetTemplateJsonPatch(imageSpecs)
if err != nil {
return err
}
dial, err := d.Client().Dial()
if err != nil {
return err
}
_, err = dial.AppsV1().DaemonSets(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
jsonPatch,
metav1.PatchOptions{},
)
return err
}
// ----------------------------------------------------------------------------
// Helpers...
func toSelector(m map[string]string) string {
s := make([]string, 0, len(m))
for k, v := range m {
s = append(s, k+"="+v)
}
return strings.Join(s, ",")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rest_mapper.go | internal/dao/rest_mapper.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"fmt"
"strings"
"github.com/derailed/k9s/internal/client"
"k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/restmapper"
)
// RestMapping holds k8s resource mapping.
var RestMapping = &RestMapper{}
// RestMapper map resource to REST mapping ie kind, group, version.
type RestMapper struct {
client.Connection
}
// ToRESTMapper map resources to kind, and map kind and version to interfaces for manipulating K8s objects.
func (r *RestMapper) ToRESTMapper() (meta.RESTMapper, error) {
dial, err := r.CachedDiscovery()
if err != nil {
return nil, err
}
mapper := restmapper.NewDeferredDiscoveryRESTMapper(dial)
expander := restmapper.NewShortcutExpander(mapper, dial, nil)
return expander, nil
}
// ResourceFor produces a rest mapping from a given resource.
// Support full res name ie deployment.v1.apps.
func (r *RestMapper) ResourceFor(resourceArg, kind string) (*meta.RESTMapping, error) {
res, err := r.resourceFor(resourceArg)
if err != nil {
return nil, err
}
return r.toRESTMapping(res, kind), nil
}
func (r *RestMapper) resourceFor(resourceArg string) (schema.GroupVersionResource, error) {
if resourceArg == "*" {
return schema.GroupVersionResource{Resource: resourceArg}, nil
}
var (
gvr schema.GroupVersionResource
err error
)
mapper, err := r.ToRESTMapper()
if err != nil {
return gvr, err
}
fullGVR, gr := schema.ParseResourceArg(strings.ToLower(resourceArg))
if fullGVR != nil {
return mapper.ResourceFor(*fullGVR)
}
gvr, err = mapper.ResourceFor(gr.WithVersion(""))
if err != nil {
if gr.Group == "" {
return gvr, fmt.Errorf("the server doesn't have a resource type '%s'", gr.Resource)
}
return gvr, fmt.Errorf("the server doesn't have a resource type '%s' in group '%s'", gr.Resource, gr.Group)
}
return gvr, nil
}
func (*RestMapper) toRESTMapping(gvr schema.GroupVersionResource, kind string) *meta.RESTMapping {
return &meta.RESTMapping{
Resource: gvr,
GroupVersionKind: schema.GroupVersionKind{
Group: gvr.Group,
Version: gvr.Version,
Kind: kind,
},
Scope: RestMapping,
}
}
// Name protocol returns rest scope name.
func (*RestMapper) Name() meta.RESTScopeName {
return meta.RESTScopeNameNamespace
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/helpers_test.go | internal/dao/helpers_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"testing"
"github.com/stretchr/testify/assert"
v1 "k8s.io/api/core/v1"
)
func TestToPerc(t *testing.T) {
uu := []struct {
v1, v2, e float64
}{
{0, 0, 0},
{100, 200, 50},
{200, 100, 200},
}
for _, u := range uu {
//nolint:testifylint
assert.Equal(t, u.e, toPerc(u.v1, u.v2))
}
}
func TestServiceAccountMatches(t *testing.T) {
uu := []struct {
podTemplate *v1.PodSpec
saName string
expect bool
}{
{podTemplate: &v1.PodSpec{
ServiceAccountName: "",
},
saName: defaultServiceAccount,
expect: true,
},
{podTemplate: &v1.PodSpec{
ServiceAccountName: "",
},
saName: "foo",
expect: false,
},
{podTemplate: &v1.PodSpec{
ServiceAccountName: "foo",
},
saName: "foo",
expect: true,
},
{podTemplate: &v1.PodSpec{
ServiceAccountName: "foo",
},
saName: "bar",
expect: false,
},
}
for _, u := range uu {
assert.Equal(t, u.expect, serviceAccountMatches(u.podTemplate.ServiceAccountName, u.saName))
}
}
func TestContinuousRanges(t *testing.T) {
tests := []struct {
Indexes []int
Ranges [][]int
}{
{
Indexes: []int{0},
Ranges: [][]int{{0, 1}},
},
{
Indexes: []int{1},
Ranges: [][]int{{1, 2}},
},
{
Indexes: []int{0, 1, 2},
Ranges: [][]int{{0, 3}},
},
{
Indexes: []int{4, 5, 6},
Ranges: [][]int{{4, 7}},
},
{
Indexes: []int{0, 2, 4, 5, 6},
Ranges: [][]int{{0, 1}, {2, 3}, {4, 7}},
},
}
for _, tt := range tests {
assert.Equal(t, tt.Ranges, ContinuousRanges(tt.Indexes))
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rbac_policy.go | internal/dao/rbac_policy.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
rbacv1 "k8s.io/api/rbac/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Policy)(nil)
_ Nuker = (*Policy)(nil)
)
// Policy represent rbac policy.
type Policy struct {
Resource
}
// List returns available policies.
func (p *Policy) List(ctx context.Context, _ string) ([]runtime.Object, error) {
kind, ok := ctx.Value(internal.KeySubjectKind).(string)
if !ok {
return nil, fmt.Errorf("expecting a context subject kind")
}
name, ok := ctx.Value(internal.KeySubjectName).(string)
if !ok {
return nil, fmt.Errorf("expecting a context subject name")
}
crps, err := p.loadClusterRoleBinding(kind, name)
if err != nil {
return nil, err
}
rps, err := p.loadRoleBinding(kind, name)
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(crps)+len(rps))
for _, p := range crps {
oo = append(oo, p)
}
for _, p := range rps {
oo = append(oo, p)
}
return oo, nil
}
func (p *Policy) loadClusterRoleBinding(kind, name string) (render.Policies, error) {
crbs, err := fetchClusterRoleBindings(p.Factory)
if err != nil {
return nil, err
}
ns, n := client.Namespaced(name)
var nn []string
for i := range crbs {
for _, s := range crbs[i].Subjects {
if isSameSubject(kind, ns, crbs[i].Namespace, n, &s) {
nn = append(nn, crbs[i].RoleRef.Name)
}
}
}
crs, err := p.fetchClusterRoles()
if err != nil {
return nil, err
}
rows := make(render.Policies, 0, len(nn))
for i := range crs {
if !inList(nn, crs[i].Name) {
continue
}
rows = append(rows, parseRules(client.NotNamespaced, "CR:"+crs[i].Name, crs[i].Rules)...)
}
return rows, nil
}
func (p *Policy) loadRoleBinding(kind, name string) (render.Policies, error) {
rbsMap, err := p.fetchRoleBindingNamespaces(kind, name)
if err != nil {
return nil, err
}
crs, err := p.fetchClusterRoles()
if err != nil {
return nil, err
}
rows := make(render.Policies, 0, len(crs))
for i := range crs {
if rbNs, ok := rbsMap["ClusterRole:"+crs[i].Name]; ok {
slog.Debug("Loading rules for clusterrole",
slogs.Namespace, rbNs,
slogs.ResName, crs[i].Name,
)
rows = append(rows, parseRules(rbNs, "CR:"+crs[i].Name, crs[i].Rules)...)
}
}
ros, err := p.fetchRoles()
if err != nil {
return nil, err
}
for i := range ros {
if _, ok := rbsMap["Role:"+ros[i].Name]; !ok {
continue
}
slog.Debug("Loading rules for role",
slogs.Namespace, ros[i].Namespace,
slogs.ResName, ros[i].Name,
)
rows = append(rows, parseRules(ros[i].Namespace, "RO:"+ros[i].Name, ros[i].Rules)...)
}
return rows, nil
}
func fetchClusterRoleBindings(f Factory) ([]rbacv1.ClusterRoleBinding, error) {
oo, err := f.List(client.CrbGVR, client.ClusterScope, false, labels.Everything())
if err != nil {
return nil, err
}
crbs := make([]rbacv1.ClusterRoleBinding, len(oo))
for i, o := range oo {
var crb rbacv1.ClusterRoleBinding
if e := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &crb); e != nil {
return nil, e
}
crbs[i] = crb
}
return crbs, nil
}
func fetchRoleBindings(f Factory) ([]rbacv1.RoleBinding, error) {
oo, err := f.List(client.RobGVR, client.ClusterScope, false, labels.Everything())
if err != nil {
return nil, err
}
rbs := make([]rbacv1.RoleBinding, 0, len(oo))
for _, o := range oo {
var rb rbacv1.RoleBinding
if e := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &rb); e != nil {
return nil, e
}
rbs = append(rbs, rb)
}
return rbs, nil
}
func (p *Policy) fetchRoleBindingNamespaces(kind, name string) (map[string]string, error) {
rbs, err := fetchRoleBindings(p.Factory)
if err != nil {
return nil, err
}
ns, n := client.Namespaced(name)
ss := make(map[string]string, len(rbs))
for i := range rbs {
for _, s := range rbs[i].Subjects {
if isSameSubject(kind, ns, rbs[i].Namespace, n, &s) {
ss[rbs[i].RoleRef.Kind+":"+rbs[i].RoleRef.Name] = rbs[i].Namespace
}
}
}
return ss, nil
}
// isSameSubject verifies if the incoming type name and namespace match a subject from a
// cluster/roleBinding. A ServiceAccount will always have a namespace and needs to be validated to ensure
// we don't display permissions for a ServiceAccount with the same name in a different namespace
func isSameSubject(kind, ns, bns, name string, subject *rbacv1.Subject) bool {
if subject.Kind != kind || subject.Name != name {
return false
}
if kind == rbacv1.ServiceAccountKind {
// Kind and name were checked above, check the namespace
cns := subject.Namespace
if cns == "" {
cns = bns
}
return client.IsAllNamespaces(ns) || cns == ns
}
return true
}
func (p *Policy) fetchClusterRoles() ([]rbacv1.ClusterRole, error) {
oo, err := p.getFactory().List(client.CrGVR, client.ClusterScope, false, labels.Everything())
if err != nil {
return nil, err
}
crs := make([]rbacv1.ClusterRole, len(oo))
for i, o := range oo {
var cr rbacv1.ClusterRole
if e := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cr); e != nil {
return nil, e
}
crs[i] = cr
}
return crs, nil
}
func (p *Policy) fetchRoles() ([]rbacv1.Role, error) {
oo, err := p.getFactory().List(client.RoGVR, client.BlankNamespace, false, labels.Everything())
if err != nil {
return nil, err
}
rr := make([]rbacv1.Role, len(oo))
for i, o := range oo {
var ro rbacv1.Role
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &ro); err != nil {
return nil, err
}
rr[i] = ro
}
return rr, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/port_forward.go | internal/dao/port_forward.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"log/slog"
"regexp"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*PortForward)(nil)
_ Nuker = (*PortForward)(nil)
)
// PortForward represents a port forward dao.
type PortForward struct {
NonResource
}
// Delete deletes a portforward.
func (p *PortForward) Delete(_ context.Context, path string, _ *metav1.DeletionPropagation, _ Grace) error {
p.getFactory().DeleteForwarder(path)
return nil
}
// List returns a collection of port forwards.
func (p *PortForward) List(ctx context.Context, _ string) ([]runtime.Object, error) {
benchFile, ok := ctx.Value(internal.KeyBenchCfg).(string)
if !ok || benchFile == "" {
return nil, fmt.Errorf("no benchmark config file found in context")
}
path, _ := ctx.Value(internal.KeyPath).(string)
bcfg, err := config.NewBench(benchFile)
if err != nil {
slog.Debug("No custom benchmark config file found", slogs.FileName, benchFile)
}
ff, cc := p.getFactory().Forwarders(), bcfg.Benchmarks.Containers
oo := make([]runtime.Object, 0, len(ff))
for k, f := range ff {
if !strings.HasPrefix(k, path) {
continue
}
cfg := render.BenchCfg{
C: bcfg.Benchmarks.Defaults.C,
N: bcfg.Benchmarks.Defaults.N,
}
if cust, ok := cc[PodToKey(k)]; ok {
cfg.C, cfg.N = cust.C, cust.N
cfg.Host, cfg.Path = cust.HTTP.Host, cust.HTTP.Path
}
oo = append(oo, render.ForwardRes{
Forwarder: f,
Config: cfg,
})
}
return oo, nil
}
// ----------------------------------------------------------------------------
// Helpers...
var podNameRX = regexp.MustCompile(`\A(.+)\-(\w{10})\-(\w{5})\z`)
// PodToKey converts a pod path to a generic bench config key.
func PodToKey(path string) string {
tokens := strings.Split(path, "|")
ns, po := client.Namespaced(tokens[0])
sections := podNameRX.FindStringSubmatch(po)
if len(sections) >= 1 {
po = sections[1]
}
return client.FQN(ns, po) + ":" + tokens[1]
}
// BenchConfigFor returns a custom bench spec if defined otherwise returns the default one.
func BenchConfigFor(benchFile, path string) config.BenchConfig {
def := config.DefaultBenchSpec()
cust, err := config.NewBench(benchFile)
if err != nil {
slog.Debug("No custom benchmark config file found. Using default",
slogs.FileName, benchFile,
slogs.Error, err,
)
return def
}
if b, ok := cust.Benchmarks.Containers[PodToKey(path)]; ok {
return b
}
def.C, def.N = cust.Benchmarks.Defaults.C, cust.Benchmarks.Defaults.N
return def
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/ns.go | internal/dao/ns.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
var _ Accessor = (*Namespace)(nil)
// Namespace represents a namespace resource.
type Namespace struct {
Resource
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/utils_test.go | internal/dao/utils_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"encoding/json"
"fmt"
"os"
"path"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/watch"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
)
type testFactory struct {
inventory map[string]map[*client.GVR][]runtime.Object
}
func makeFactory() dao.Factory {
return &testFactory{
inventory: map[string]map[*client.GVR][]runtime.Object{
"kube-system": {
client.SecGVR: {
load("secret"),
},
},
},
}
}
var _ dao.Factory = &testFactory{}
func (*testFactory) Client() client.Connection {
return nil
}
func (f *testFactory) Get(gvr *client.GVR, fqn string, _ bool, _ labels.Selector) (runtime.Object, error) {
ns, po := path.Split(fqn)
ns = strings.Trim(ns, "/")
for _, o := range f.inventory[ns][gvr] {
if o.(*unstructured.Unstructured).GetName() == po {
return o, nil
}
}
return nil, nil
}
func (f *testFactory) List(gvr *client.GVR, ns string, _ bool, _ labels.Selector) ([]runtime.Object, error) {
return f.inventory[ns][gvr], nil
}
func (*testFactory) ForResource(string, *client.GVR) (informers.GenericInformer, error) {
return nil, nil
}
func (*testFactory) CanForResource(string, *client.GVR, []string) (informers.GenericInformer, error) {
return nil, nil
}
func (*testFactory) WaitForCacheSync() {}
func (*testFactory) Forwarders() watch.Forwarders {
return nil
}
func (*testFactory) DeleteForwarder(string) {}
func load(n string) *unstructured.Unstructured {
raw, _ := os.ReadFile(fmt.Sprintf("testdata/%s.json", n))
var o unstructured.Unstructured
_ = json.Unmarshal(raw, &o)
return &o
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/port_forward_test.go | internal/dao/port_forward_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"testing"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
)
func TestBenchForConfig(t *testing.T) {
uu := map[string]struct {
file, key string
spec config.BenchConfig
}{
"no_file": {file: "", key: "", spec: config.DefaultBenchSpec()},
"spec": {file: "testdata/benchspec.yaml", key: "default/nginx-123-456|nginx", spec: config.BenchConfig{
C: 2,
N: 3000,
HTTP: config.HTTP{
Method: "GET",
Path: "/",
},
}},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.NotNil(t, u.spec, dao.BenchConfigFor(u.file, u.key))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/alias_test.go | internal/dao/alias_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestAliasList(t *testing.T) {
a := dao.Alias{}
a.Init(makeFactory(), client.AliGVR)
ctx := context.WithValue(context.Background(), internal.KeyAliases, makeAliases())
oo, err := a.List(ctx, "-")
require.NoError(t, err)
assert.Len(t, oo, 2)
assert.Len(t, oo[0].(render.AliasRes).Aliases, 2)
}
// ----------------------------------------------------------------------------
// Helpers...
func makeAliases() *dao.Alias {
gvr1 := client.NewGVR("v1/fred")
gvr2 := client.NewGVR("v1/blee")
return &dao.Alias{
Aliases: &config.Aliases{
Alias: config.Alias{
"fred": gvr1,
"f": gvr1,
"blee": gvr2,
"b": gvr2,
},
},
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/svc.go | internal/dao/svc.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"github.com/derailed/k9s/internal/client"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Service)(nil)
_ Loggable = (*Service)(nil)
_ Controller = (*Service)(nil)
)
// Service represents a k8s service.
type Service struct {
Resource
}
// TailLogs tail logs for all pods represented by this Service.
func (s *Service) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
svc, err := s.GetInstance(opts.Path)
if err != nil {
return nil, err
}
if len(svc.Spec.Selector) == 0 {
return nil, fmt.Errorf("no valid selector found on Service %s", opts.Path)
}
return podLogs(ctx, svc.Spec.Selector, opts)
}
// Pod returns a pod victim by name.
func (s *Service) Pod(fqn string) (string, error) {
svc, err := s.GetInstance(fqn)
if err != nil {
return "", err
}
return podFromSelector(s.Factory, svc.Namespace, svc.Spec.Selector)
}
// GetInstance returns a service instance.
func (s *Service) GetInstance(fqn string) (*v1.Service, error) {
o, err := s.getFactory().Get(s.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var svc v1.Service
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &svc)
if err != nil {
return nil, errors.New("expecting Service resource")
}
return &svc, nil
}
// ----------------------------------------------------------------------------
// Helpers...
func podFromSelector(f Factory, ns string, sel map[string]string) (string, error) {
oo, err := f.List(client.PodGVR, ns, true, labels.Set(sel).AsSelector())
if err != nil {
return "", err
}
if len(oo) == 0 {
return "", fmt.Errorf("no matching pods for %v", sel)
}
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(oo[0].(*unstructured.Unstructured).Object, &pod)
if err != nil {
return "", err
}
return client.FQN(pod.Namespace, pod.Name), nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/recorder.go | internal/dao/recorder.go | package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"sync"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/cache"
)
var MxRecorder *Recorder
const (
seriesCacheSize = 600
seriesCacheExpiry = 3 * time.Hour
seriesRecordRate = 1 * time.Minute
nodeMetrics = "node"
podMetrics = "pod"
)
type MetricsChan chan TimeSeries
type TimeSeries []Point
type Point struct {
Time time.Time
Tags map[string]string
Value client.NodeMetrics
}
type Recorder struct {
conn client.Connection
series *cache.LRUExpireCache
mxChan MetricsChan
mx sync.RWMutex
}
func DialRecorder(c client.Connection) *Recorder {
if MxRecorder != nil {
return MxRecorder
}
MxRecorder = &Recorder{
conn: c,
series: cache.NewLRUExpireCache(seriesCacheSize),
}
return MxRecorder
}
func ResetRecorder(c client.Connection) {
MxRecorder = nil
DialRecorder(c)
}
func (r *Recorder) Clear() {
r.mx.Lock()
defer r.mx.Unlock()
kk := r.series.Keys()
for _, k := range kk {
r.series.Remove(k)
}
}
func (r *Recorder) dispatchSeries(kind, ns string) {
if r.mxChan == nil {
return
}
kk := r.series.Keys()
hour := time.Now().Add(-1 * time.Hour)
ts := make(TimeSeries, 0, len(kk))
for _, k := range kk {
if v, ok := r.series.Get(k); ok {
if pt, cool := v.(Point); cool {
if pt.Tags["type"] != kind || pt.Time.Sub(hour) < 0 {
continue
}
switch kind {
case nodeMetrics:
ts = append(ts, pt)
case podMetrics:
if client.IsAllNamespaces(ns) || pt.Tags["namespace"] == ns {
ts = append(ts, pt)
}
}
}
}
}
if len(ts) > 0 {
r.mxChan <- ts
}
}
func (r *Recorder) Watch(ctx context.Context, ns string) MetricsChan {
r.mx.Lock()
if r.mxChan != nil {
close(r.mxChan)
r.mxChan = nil
}
r.mxChan = make(MetricsChan, 2)
r.mx.Unlock()
go func() {
kind := podMetrics
if client.IsAllNamespaces(ns) {
kind = nodeMetrics
}
switch kind {
case podMetrics:
if err := r.recordPodMetrics(ctx, ns); err != nil {
slog.Error("Record pod metrics failed", slogs.Error, err)
}
case nodeMetrics:
if err := r.recordNodeMetrics(ctx); err != nil {
slog.Error("Record node metrics failed", slogs.Error, err)
}
}
r.dispatchSeries(kind, ns)
<-ctx.Done()
r.mx.Lock()
if r.mxChan != nil {
close(r.mxChan)
r.mxChan = nil
}
r.mx.Unlock()
}()
return r.mxChan
}
func (r *Recorder) Record(ctx context.Context) error {
if err := r.recordNodeMetrics(ctx); err != nil {
return err
}
return r.recordPodMetrics(ctx, client.NamespaceAll)
}
func (r *Recorder) recordNodeMetrics(ctx context.Context) error {
f, ok := ctx.Value(internal.KeyFactory).(Factory)
if !ok {
return errors.New("expecting factory in context")
}
nn, err := FetchNodes(ctx, f, "")
if err != nil {
return err
}
go func() {
r.recordClusterMetrics(ctx, nn)
for {
select {
case <-ctx.Done():
return
case <-time.After(seriesRecordRate):
r.recordClusterMetrics(ctx, nn)
}
}
}()
return nil
}
func (r *Recorder) recordClusterMetrics(ctx context.Context, nn *v1.NodeList) {
dial := client.DialMetrics(r.conn)
nmx, err := dial.FetchNodesMetrics(ctx)
if err != nil {
slog.Error("Fetch node metrics failed", slogs.Error, err)
return
}
mx := make(client.NodesMetrics, len(nn.Items))
dial.NodesMetrics(nn, nmx, mx)
var cmx client.NodeMetrics
for _, m := range mx {
cmx.CurrentCPU += m.CurrentCPU
cmx.CurrentMEM += m.CurrentMEM
cmx.AllocatableCPU += m.AllocatableCPU
cmx.AllocatableMEM += m.AllocatableMEM
cmx.TotalCPU += m.TotalCPU
cmx.TotalMEM += m.TotalMEM
}
pt := Point{
Time: time.Now(),
Value: cmx,
Tags: map[string]string{
"type": nodeMetrics,
},
}
if len(nn.Items) > 0 {
r.series.Add(pt.Time, pt, seriesCacheExpiry)
}
r.mx.Lock()
defer r.mx.Unlock()
if r.mxChan != nil {
r.mxChan <- TimeSeries{pt}
}
}
func (r *Recorder) recordPodMetrics(ctx context.Context, ns string) error {
go func() {
if err := r.recordPodsMetrics(ctx, ns); err != nil {
slog.Error("Record pod metrics failed", slogs.Error, err)
}
for {
select {
case <-ctx.Done():
return
case <-time.After(seriesRecordRate):
// case <-time.After(5 * time.Second):
if err := r.recordPodsMetrics(ctx, ns); err != nil {
slog.Error("Record pod metrics failed", slogs.Error, err)
}
}
}
}()
return nil
}
func (r *Recorder) recordPodsMetrics(ctx context.Context, ns string) error {
f, ok := ctx.Value(internal.KeyFactory).(Factory)
if !ok {
return errors.New("expecting factory in context")
}
pp, err := FetchPods(ctx, f, ns)
if err != nil {
return err
}
pt := Point{
Time: time.Now(),
Value: client.NodeMetrics{},
Tags: map[string]string{
"namespace": ns,
"type": podMetrics,
},
}
dial := client.DialMetrics(r.conn)
for i := range pp.Items {
p := pp.Items[i]
fqn := client.FQN(p.Namespace, p.Name)
pmx, err := dial.FetchPodMetrics(ctx, fqn)
if err != nil {
continue
}
for _, c := range pmx.Containers {
pt.Value.CurrentCPU += c.Usage.Cpu().MilliValue()
pt.Value.CurrentMEM += client.ToMB(c.Usage.Memory().Value())
}
}
if len(pp.Items) > 0 {
pt.Value.AllocatableCPU = pt.Value.CurrentCPU
pt.Value.AllocatableMEM = pt.Value.CurrentMEM
r.series.Add(pt.Time, pt, seriesCacheExpiry)
r.mx.Lock()
defer r.mx.Unlock()
if r.mxChan != nil {
r.mxChan <- TimeSeries{pt}
}
}
return nil
}
// FetchPods retrieves all pods in a given namespace.
func FetchPods(_ context.Context, f Factory, ns string) (*v1.PodList, error) {
auth, err := f.Client().CanI(ns, client.PodGVR, "pods", []string{client.ListVerb})
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to list pods")
}
oo, err := f.List(client.PodGVR, ns, false, labels.Everything())
if err != nil {
return nil, err
}
pp := make([]v1.Pod, 0, len(oo))
for _, o := range oo {
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, err
}
pp = append(pp, pod)
}
return &v1.PodList{Items: pp}, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/secret.go | internal/dao/secret.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"bytes"
"context"
"fmt"
"log/slog"
"strings"
"github.com/derailed/k9s/internal/slogs"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/cli-runtime/pkg/printers"
)
// Secret represents a secret K8s resource.
type Secret struct {
Resource
decodeData bool
}
// Describe describes a secret that can be encoded or decoded.
func (s *Secret) Describe(path string) (string, error) {
encodedDescription, err := s.Generic.Describe(path)
if err != nil {
return "", err
}
if s.decodeData {
return s.Decode(encodedDescription, path)
}
return encodedDescription, nil
}
// ToYAML returns a resource yaml.
func (s *Secret) ToYAML(path string, showManaged bool) (string, error) {
if s.decodeData {
return s.decodeYAML(path, showManaged)
}
return s.Generic.ToYAML(path, showManaged)
}
func (s *Secret) decodeYAML(path string, showManaged bool) (string, error) {
o, err := s.Get(context.Background(), path)
if err != nil {
return "", err
}
o = o.DeepCopyObject()
u, ok := o.(*unstructured.Unstructured)
if !ok {
return "", fmt.Errorf("expecting unstructured but got %T", o)
}
if u.Object == nil {
return "", fmt.Errorf("expecting unstructured object but got nil")
}
if !showManaged {
if meta, ok := u.Object["metadata"].(map[string]any); ok {
delete(meta, "managedFields")
}
}
if decoded, err := ExtractSecrets(o); err == nil {
u.Object["data"] = decoded
}
var (
buff bytes.Buffer
p printers.YAMLPrinter
)
if err := p.PrintObj(o, &buff); err != nil {
slog.Error("PrintObj failed", slogs.Error, err)
return "", err
}
return buff.String(), nil
}
// SetDecodeData toggles decode mode.
func (s *Secret) SetDecodeData(b bool) {
s.decodeData = b
}
// Decode removes the encoded part from the secret's description and appends the
// secret's decoded data.
func (s *Secret) Decode(encodedDescription, path string) (string, error) {
dataEndIndex := strings.Index(encodedDescription, "====")
if dataEndIndex == -1 {
return "", fmt.Errorf("unable to find data section in secret description")
}
dataEndIndex += 4
if dataEndIndex >= len(encodedDescription) {
return "", fmt.Errorf("data section in secret description is invalid")
}
// Remove the encoded part from k8s's describe API
// More details about the reasoning of index: https://github.com/kubernetes/kubectl/blob/v0.29.0/pkg/describe/describe.go#L2542
body := encodedDescription[0:dataEndIndex]
o, err := s.Get(context.Background(), path)
if err != nil {
return "", err
}
data, err := ExtractSecrets(o)
if err != nil {
return "", err
}
decodedSecrets := make([]string, 0, len(data))
for k, v := range data {
line := fmt.Sprintf("%s: %s", k, v)
decodedSecrets = append(decodedSecrets, strings.TrimSpace(line))
}
return body + "\n" + strings.Join(decodedSecrets, "\n"), nil
}
// ExtractSecrets takes an unstructured object and attempts to convert it into a
// Kubernetes Secret.
// It returns a map where the keys are the secret data keys and the values are
// the corresponding secret data values.
// If the conversion fails, it returns an error.
func ExtractSecrets(o runtime.Object) (map[string]string, error) {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return nil, fmt.Errorf("expecting *unstructured.Unstructured but got %T", o)
}
var secret v1.Secret
err := runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, &secret)
if err != nil {
return nil, err
}
secretData := make(map[string]string, len(secret.Data))
for k, val := range secret.Data {
secretData[k] = string(val)
}
return secretData, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_item_test.go | internal/dao/log_item_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"bytes"
"fmt"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/tview"
"github.com/stretchr/testify/assert"
)
func TestLogItemEmpty(t *testing.T) {
uu := map[string]struct {
s string
e bool
}{
"empty": {s: "", e: true},
"full": {s: "Testing 1,2,3..."},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
i := dao.NewLogItemFromString(u.s)
assert.Equal(t, u.e, i.IsEmpty())
})
}
}
func TestLogItemRender(t *testing.T) {
uu := map[string]struct {
opts dao.LogOptions
log string
e string
}{
"empty": {
opts: dao.LogOptions{},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."),
e: "Testing 1,2,3...\n",
},
"container": {
opts: dao.LogOptions{
Container: "fred",
},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."),
e: "[yellow::b]fred[-::-] Testing 1,2,3...\n",
},
"pod": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "blee",
SingleContainer: true,
},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."),
e: "[yellow::]fred [yellow::b]blee[-::-] Testing 1,2,3...\n",
},
"full": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "blee",
SingleContainer: true,
ShowTimestamp: true,
},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."),
e: "[gray::b]2018-12-14T10:36:43.326972-07:00 [-::-][yellow::]fred [yellow::b]blee[-::-] Testing 1,2,3...\n",
},
"log-level": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "",
SingleContainer: false,
ShowTimestamp: false,
},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "2021-10-28T13:06:37Z [INFO] [blah-blah] Testing 1,2,3..."),
e: "[yellow::]fred[-::] 2021-10-28T13:06:37Z [INFO[] [blah-blah[] Testing 1,2,3...\n",
},
"escape": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "",
SingleContainer: false,
ShowTimestamp: false,
},
log: fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", `{"foo":["bar"]} Server listening on: [::]:5000`),
e: `[yellow::]fred[-::] {"foo":["bar"[]} Server listening on: [::[]:5000` + "\n",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
i := dao.NewLogItem([]byte(tview.Escape(u.log)))
_, n := client.Namespaced(u.opts.Path)
i.Pod, i.Container = n, u.opts.Container
bb := bytes.NewBuffer(make([]byte, 0, i.Size()))
i.Render("yellow", u.opts.ShowTimestamp, bb)
assert.Equal(t, u.e, bb.String())
})
}
}
func BenchmarkLogItemRenderTS(b *testing.B) {
s := []byte(fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."))
i := dao.NewLogItem(s)
i.Pod, i.Container = "fred", "blee"
b.ResetTimer()
b.ReportAllocs()
for range b.N {
bb := bytes.NewBuffer(make([]byte, 0, i.Size()))
i.Render("yellow", true, bb)
}
}
func BenchmarkLogItemRenderNoTS(b *testing.B) {
s := []byte(fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."))
i := dao.NewLogItem(s)
i.Pod, i.Container = "fred", "blee"
b.ResetTimer()
b.ReportAllocs()
for range b.N {
bb := bytes.NewBuffer(make([]byte, 0, i.Size()))
i.Render("yellow", false, bb)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/img_scan.go | internal/dao/img_scan.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/vul"
"k8s.io/apimachinery/pkg/runtime"
)
var _ Accessor = (*ImageScan)(nil)
// ImageScan represents vulnerability scans.
type ImageScan struct {
NonResource
}
func (is *ImageScan) listImages(ctx context.Context, gvr *client.GVR, path string) ([]string, error) {
res, err := AccessorFor(is.Factory, gvr)
if err != nil {
return nil, err
}
s, ok := res.(ImageLister)
if !ok {
return nil, fmt.Errorf("resource %s is not image lister: %T", gvr, res)
}
return s.ListImages(ctx, path)
}
// List returns a collection of scans.
func (is *ImageScan) List(ctx context.Context, _ string) ([]runtime.Object, error) {
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, fmt.Errorf("no context path for %q", is.gvr)
}
gvr, ok := ctx.Value(internal.KeyGVR).(*client.GVR)
if !ok {
return nil, fmt.Errorf("no context gvr for %q", is.gvr)
}
ii, err := is.listImages(ctx, gvr, fqn)
if err != nil {
return nil, err
}
res := make([]runtime.Object, 0, len(ii))
for _, img := range ii {
s, ok := vul.ImgScanner.GetScan(img)
if !ok {
continue
}
for _, r := range s.Table.Rows {
res = append(res, render.ImageScanRes{Image: img, Row: r})
}
}
return res, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/resource.go | internal/dao/resource.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Resource)(nil)
_ Describer = (*Resource)(nil)
_ Nuker = (*Resource)(nil)
)
// Resource represents an informer based resource.
type Resource struct {
Generic
}
// List returns a collection of resources.
func (r *Resource) List(ctx context.Context, ns string) ([]runtime.Object, error) {
lsel := labels.Everything()
if sel, ok := ctx.Value(internal.KeyLabels).(labels.Selector); ok {
lsel = sel
}
return r.getFactory().List(r.gvr, ns, false, lsel)
}
// Get returns a resource instance if found, else an error.
func (r *Resource) Get(_ context.Context, path string) (runtime.Object, error) {
return r.getFactory().Get(r.gvr, path, true, labels.Everything())
}
// ToYAML returns a resource yaml.
func (r *Resource) ToYAML(path string, showManaged bool) (string, error) {
o, err := r.Get(context.Background(), path)
if err != nil {
return "", err
}
raw, err := ToYAML(o, showManaged)
if err != nil {
return "", fmt.Errorf("unable to marshal resource %w", err)
}
return raw, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/cruiser_test.go | internal/dao/cruiser_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"encoding/json"
"fmt"
"os"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)
func TestCruiserMeta(t *testing.T) {
o := loadJSON(t, "crb")
m := mustMap(o, "metadata")
assert.Equal(t, "blee", mustField(m, "name"))
}
func TestCruiserSlice(t *testing.T) {
o := loadJSON(t, "crb")
s := mustSlice(o, "subjects")
assert.Len(t, s, 1)
assert.Equal(t, "fernand", mustField(s[0].(map[string]any), "name"))
assert.Equal(t, "User", mustField(s[0].(map[string]any), "kind"))
}
// Helpers...
func loadJSON(t require.TestingT, n string) *unstructured.Unstructured {
raw, err := os.ReadFile(fmt.Sprintf("testdata/%s.json", n))
require.NoError(t, err)
var o unstructured.Unstructured
err = json.Unmarshal(raw, &o)
require.NoError(t, err)
return &o
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/benchmark_test.go | internal/dao/benchmark_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestBenchmarkList(t *testing.T) {
a := dao.Benchmark{}
a.Init(makeFactory(), client.BeGVR)
ctx := context.WithValue(context.Background(), internal.KeyDir, "testdata/bench")
ctx = context.WithValue(ctx, internal.KeyPath, "")
oo, err := a.List(ctx, "-")
require.NoError(t, err)
assert.Len(t, oo, 1)
assert.Equal(t, "testdata/bench/default_fred_1577308050814961000.txt", oo[0].(render.BenchInfo).Path)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/port_forwarder.go | internal/dao/port_forwarder.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"fmt"
"net/http"
"net/url"
"strings"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/port"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/runtime/serializer"
"k8s.io/apimachinery/pkg/util/httpstream"
"k8s.io/cli-runtime/pkg/genericclioptions"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/portforward"
"k8s.io/client-go/transport/spdy"
cmdutil "k8s.io/kubectl/pkg/cmd/util"
)
const defaultTimeout = 30 * time.Second
// PortForwarder tracks a port forward stream.
type PortForwarder struct {
Factory
genericclioptions.IOStreams
stopChan, readyChan chan struct{}
active bool
path string
tunnel port.PortTunnel
age time.Time
}
// NewPortForwarder returns a new port forward streamer.
func NewPortForwarder(f Factory) *PortForwarder {
return &PortForwarder{
Factory: f,
stopChan: make(chan struct{}),
readyChan: make(chan struct{}),
}
}
// String dumps as string.
func (p *PortForwarder) String() string {
return fmt.Sprintf("%s|%s", p.path, p.tunnel)
}
// Age returns the port forward age.
func (p *PortForwarder) Age() time.Time {
return p.age
}
// Active returns the forward status.
func (p *PortForwarder) Active() bool {
return p.active
}
// SetActive mark a portforward as active.
func (p *PortForwarder) SetActive(b bool) {
p.active = b
}
// Port returns the port mapping.
func (p *PortForwarder) Port() string {
return p.tunnel.PortMap()
}
// Address returns the port Address.
func (p *PortForwarder) Address() string {
return p.tunnel.Address
}
// ContainerPort returns the container port.
func (p *PortForwarder) ContainerPort() string {
return p.tunnel.ContainerPort
}
// LocalPort returns the local port.
func (p *PortForwarder) LocalPort() string {
return p.tunnel.LocalPort
}
// ID returns a pf id.
func (p *PortForwarder) ID() string {
return PortForwardID(p.path, p.tunnel.Container, p.tunnel.PortMap())
}
// Container returns the target's container.
func (p *PortForwarder) Container() string {
return p.tunnel.Container
}
// Stop terminates a port forward.
func (p *PortForwarder) Stop() {
p.active = false
if p.stopChan != nil {
close(p.stopChan)
p.stopChan = nil
}
}
// FQN returns the portforward unique id.
func (p *PortForwarder) FQN() string {
return p.path + ":" + p.tunnel.Container
}
// HasPortMapping checks if port mapping is defined for this fwd.
func (p *PortForwarder) HasPortMapping(portMap string) bool {
return p.tunnel.PortMap() == portMap
}
// Start initiates a port forward session for a given pod and ports.
func (p *PortForwarder) Start(path string, tt port.PortTunnel) (*portforward.PortForwarder, error) {
p.path, p.tunnel, p.age = path, tt, time.Now()
ns, n := client.Namespaced(path)
auth, err := p.Client().CanI(ns, client.PodGVR, n, client.GetAccess)
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to get pods")
}
podName := strings.Split(n, "|")[0]
var res Pod
res.Init(p, client.PodGVR)
pod, err := res.GetInstance(client.FQN(ns, podName))
if err != nil {
return nil, err
}
if pod.Status.Phase != v1.PodRunning {
return nil, fmt.Errorf("unable to forward port because pod is not running. Current status=%v", pod.Status.Phase)
}
auth, err = p.Client().CanI(ns, client.PodGVR.WithSubResource("portforward"), "", []string{client.CreateVerb})
if err != nil {
return nil, err
}
if !auth {
return nil, fmt.Errorf("user is not authorized to update portforward")
}
cfg, err := p.Client().RestConfig()
if err != nil {
return nil, err
}
cfg.GroupVersion = &schema.GroupVersion{Group: "", Version: "v1"}
cfg.APIPath = "/api"
codec, _ := codec()
cfg.NegotiatedSerializer = codec.WithoutConversion()
clt, err := rest.RESTClientFor(cfg)
if err != nil {
return nil, err
}
req := clt.Post().
Resource("pods").
Namespace(ns).
Name(podName).
SubResource("portforward")
return p.forwardPorts("POST", req.URL(), tt.Address, tt.PortMap())
}
func (p *PortForwarder) forwardPorts(method string, u *url.URL, addr, portMap string) (*portforward.PortForwarder, error) {
cfg, err := p.Client().Config().RESTConfig()
if err != nil {
return nil, err
}
transport, upgrader, err := spdy.RoundTripperFor(cfg)
if err != nil {
return nil, err
}
dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport, Timeout: defaultTimeout}, method, u)
if !cmdutil.PortForwardWebsockets.IsDisabled() {
tunnelingDialer, err := portforward.NewSPDYOverWebsocketDialer(u, cfg)
if err != nil {
return nil, err
}
// First attempt tunneling (websocket) dialer, then fallback to spdy dialer.
dialer = portforward.NewFallbackDialer(tunnelingDialer, dialer, func(err error) bool {
return httpstream.IsUpgradeFailure(err) || httpstream.IsHTTPSProxyError(err)
})
}
return portforward.NewOnAddresses(dialer, []string{addr}, []string{portMap}, p.stopChan, p.readyChan, p.Out, p.ErrOut)
}
// ----------------------------------------------------------------------------
// Helpers...
// PortForwardID computes port-forward identifier.
func PortForwardID(path, co, portMap string) string {
if strings.Contains(path, "|") {
return path + "|" + portMap
}
return path + "|" + co + "|" + portMap
}
func codec() (serializer.CodecFactory, runtime.ParameterCodec) {
scheme := runtime.NewScheme()
gv := schema.GroupVersion{Group: "", Version: "v1"}
metav1.AddToGroupVersion(scheme, gv)
scheme.AddKnownTypes(gv, &metav1.Table{}, &metav1.TableOptions{})
scheme.AddKnownTypes(metav1.SchemeGroupVersion, &metav1.Table{}, &metav1.TableOptions{})
return serializer.NewCodecFactory(scheme), runtime.NewParameterCodec(scheme)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/cruiser.go | internal/dao/cruiser.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"fmt"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
func mustMap(o runtime.Object, field string) map[string]any {
u, ok := o.(*unstructured.Unstructured)
if !ok {
panic("no unstructured")
}
m, ok := u.Object[field].(map[string]any)
if !ok {
panic(fmt.Sprintf("map extract failed for %q", field))
}
return m
}
func mustSlice(o runtime.Object, field string) []any {
u, ok := o.(*unstructured.Unstructured)
if !ok {
return nil
}
s, ok := u.Object[field].([]any)
if !ok {
return nil
}
return s
}
func mustField(o map[string]any, field string) any {
f, ok := o[field]
if !ok {
panic(fmt.Sprintf("no field for %q", field))
}
return f
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/context.go | internal/dao/context.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Context)(nil)
_ Switchable = (*Context)(nil)
)
// Context represents a kubernetes context.
type Context struct {
NonResource
}
func (c *Context) config() *client.Config {
return c.getFactory().Client().Config()
}
// Get a Context.
func (c *Context) Get(_ context.Context, path string) (runtime.Object, error) {
co, err := c.config().GetContext(path)
if err != nil {
return nil, err
}
return &render.NamedContext{Name: path, Context: co}, nil
}
// List all Contexts on the current cluster.
func (c *Context) List(context.Context, string) ([]runtime.Object, error) {
ctxs, err := c.config().Contexts()
if err != nil {
return nil, err
}
cc := make([]runtime.Object, 0, len(ctxs))
for k, v := range ctxs {
cc = append(cc, render.NewNamedContext(c.config(), k, v))
}
return cc, nil
}
// MustCurrentContextName return the active context name.
func (c *Context) MustCurrentContextName() string {
cl, err := c.config().CurrentContextName()
if err != nil {
slog.Error("Fetching current context", slogs.Error, err)
}
return cl
}
// Switch to another context.
func (c *Context) Switch(ctx string) error {
return c.getFactory().Client().SwitchContext(ctx)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/dynamic.go | internal/dao/dynamic.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/client-go/rest"
cmdutil "k8s.io/kubectl/pkg/cmd/util"
)
type Dynamic struct {
Generic
}
// Get returns a given resource as a table object.
func (d *Dynamic) Get(ctx context.Context, path string) (runtime.Object, error) {
oo, err := d.toTable(ctx, path)
if err != nil || len(oo) == 0 {
return nil, err
}
return oo[0], nil
}
// List returns a collection of resources as one or more table objects.
func (d *Dynamic) List(ctx context.Context, ns string) ([]runtime.Object, error) {
return d.toTable(ctx, ns+"/")
}
func (d *Dynamic) toTable(ctx context.Context, fqn string) ([]runtime.Object, error) {
sel := labels.Everything()
if s, ok := ctx.Value(internal.KeyLabels).(labels.Selector); ok {
sel = s
}
opts := []string{d.gvr.AsResourceName()}
ns, n := client.Namespaced(fqn)
if n != "" {
opts = append(opts, n)
}
allNS := client.IsAllNamespaces(ns)
flags := cmdutil.NewMatchVersionFlags(d.getFactory().Client().Config().Flags())
f := cmdutil.NewFactory(flags)
b := f.NewBuilder().
Unstructured().
NamespaceParam(ns).DefaultNamespace().AllNamespaces(allNS).
LabelSelectorParam(sel.String()).
FieldSelectorParam("").
RequestChunksOf(0).
ResourceTypeOrNameArgs(true, opts...).
ContinueOnError().
Latest().
Flatten().
TransformRequests(d.transformRequests).
Do()
if err := b.Err(); err != nil {
return nil, err
}
infos, err := b.Infos()
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(infos))
for _, info := range infos {
o, err := decodeIntoTable(info.Object, allNS)
if err != nil {
return nil, err
}
oo = append(oo, o.(*metav1.Table))
}
return oo, nil
}
var recognizedTableVersions = map[schema.GroupVersionKind]bool{
metav1beta1.SchemeGroupVersion.WithKind("Table"): true,
metav1.SchemeGroupVersion.WithKind("Table"): true,
}
func decodeIntoTable(obj runtime.Object, allNs bool) (runtime.Object, error) {
event, isEvent := obj.(*metav1.WatchEvent)
if isEvent {
obj = event.Object.Object
}
if !recognizedTableVersions[obj.GetObjectKind().GroupVersionKind()] {
return nil, fmt.Errorf("attempt to decode non-Table object: %v", obj.GetObjectKind().GroupVersionKind())
}
u, ok := obj.(*unstructured.Unstructured)
if !ok {
return nil, fmt.Errorf("attempt to decode non-Unstructured object")
}
var table metav1.Table
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(u.Object, &table); err != nil {
return nil, err
}
if allNs {
defs := make([]metav1.TableColumnDefinition, 0, len(table.ColumnDefinitions)+1)
defs = append(defs, metav1.TableColumnDefinition{Name: "Namespace", Type: "string"})
defs = append(defs, table.ColumnDefinitions...)
table.ColumnDefinitions = defs
}
for i := range table.Rows {
row := &table.Rows[i]
if row.Object.Raw == nil || row.Object.Object != nil {
continue
}
converted, err := runtime.Decode(unstructured.UnstructuredJSONScheme, row.Object.Raw)
if err != nil {
return nil, err
}
row.Object.Object = converted
var m metav1.Object
if obj := row.Object.Object; obj != nil {
m, _ = meta.Accessor(obj)
}
var ns string
if m != nil {
ns = m.GetNamespace()
}
if allNs {
cells := make([]any, 0, len(row.Cells)+1)
cells = append(cells, ns)
cells = append(cells, row.Cells...)
row.Cells = cells
}
}
if isEvent {
event.Object.Object = &table
return event, nil
}
return &table, nil
}
func (d *Dynamic) transformRequests(req *rest.Request) {
req.SetHeader("Accept", strings.Join([]string{
fmt.Sprintf("application/json;as=Table;v=%s;g=%s", metav1.SchemeGroupVersion.Version, metav1.GroupName),
fmt.Sprintf("application/json;as=Table;v=%s;g=%s", metav1beta1.SchemeGroupVersion.Version, metav1beta1.GroupName),
"application/json",
}, ","))
if d.includeObj {
req.Param("includeObject", "Object")
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/helm_chart.go | internal/dao/helm_chart.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"log/slog"
"os"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/render/helm"
"github.com/derailed/k9s/internal/slogs"
"helm.sh/helm/v3/pkg/action"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/cli-runtime/pkg/genericclioptions"
)
var (
_ Accessor = (*HelmChart)(nil)
_ Nuker = (*HelmChart)(nil)
_ Describer = (*HelmChart)(nil)
_ Valuer = (*HelmChart)(nil)
)
// HelmChart represents a helm chart.
type HelmChart struct {
NonResource
}
// List returns a collection of resources.
func (h *HelmChart) List(_ context.Context, ns string) ([]runtime.Object, error) {
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return nil, err
}
list := action.NewList(cfg)
list.All = true
list.SetStateMask()
rr, err := list.Run()
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(rr))
for _, r := range rr {
oo = append(oo, helm.ReleaseRes{Release: r})
}
return oo, nil
}
// Get returns a resource.
func (h *HelmChart) Get(_ context.Context, path string) (runtime.Object, error) {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return nil, err
}
resp, err := action.NewGet(cfg).Run(n)
if err != nil {
return nil, err
}
return helm.ReleaseRes{Release: resp}, nil
}
// GetValues returns values for a release
func (h *HelmChart) GetValues(path string, allValues bool) ([]byte, error) {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return nil, err
}
vals := action.NewGetValues(cfg)
vals.AllValues = allValues
resp, err := vals.Run(n)
if err != nil {
return nil, err
}
return data.WriteYAML(resp)
}
// Describe returns the chart notes.
func (h *HelmChart) Describe(path string) (string, error) {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return "", err
}
resp, err := action.NewGet(cfg).Run(n)
if err != nil {
return "", err
}
return resp.Info.Notes, nil
}
// ToYAML returns the chart manifest.
func (h *HelmChart) ToYAML(path string, _ bool) (string, error) {
ns, n := client.Namespaced(path)
cfg, err := ensureHelmConfig(h.Client().Config().Flags(), ns)
if err != nil {
return "", err
}
resp, err := action.NewGet(cfg).Run(n)
if err != nil {
return "", err
}
return resp.Manifest, nil
}
// Delete uninstall a HelmChart.
func (h *HelmChart) Delete(_ context.Context, path string, _ *metav1.DeletionPropagation, _ Grace) error {
return h.Uninstall(path, false)
}
// Uninstall uninstalls a HelmChart.
func (h *HelmChart) Uninstall(path string, keepHist bool) error {
ns, n := client.Namespaced(path)
flags := h.Client().Config().Flags()
cfg, err := ensureHelmConfig(flags, ns)
if err != nil {
return err
}
u := action.NewUninstall(cfg)
u.KeepHistory = keepHist
res, err := u.Run(n)
if err != nil {
return err
}
if res != nil && res.Info != "" {
return fmt.Errorf("%s", res.Info)
}
return nil
}
// ensureHelmConfig return a new configuration.
func ensureHelmConfig(flags *genericclioptions.ConfigFlags, ns string) (*action.Configuration, error) {
settings := &genericclioptions.ConfigFlags{
Namespace: &ns,
Context: flags.Context,
BearerToken: flags.BearerToken,
APIServer: flags.APIServer,
CAFile: flags.CAFile,
KubeConfig: flags.KubeConfig,
Impersonate: flags.Impersonate,
Insecure: flags.Insecure,
TLSServerName: flags.TLSServerName,
ImpersonateGroup: flags.ImpersonateGroup,
WrapConfigFn: flags.WrapConfigFn,
}
cfg := new(action.Configuration)
err := cfg.Init(settings, ns, os.Getenv("HELM_DRIVER"), helmLogger)
return cfg, err
}
func helmLogger(fmat string, args ...any) {
slog.Debug("Log",
slogs.Log, fmt.Sprintf(fmat, args...),
slogs.Subsys, "helm",
)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/accessor.go | internal/dao/accessor.go | package dao
import (
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
)
var accessors = Accessors{
client.WkGVR: new(Workload),
client.CtGVR: new(Context),
client.CoGVR: new(Container),
client.ScnGVR: new(ImageScan),
client.SdGVR: new(ScreenDump),
client.BeGVR: new(Benchmark),
client.PfGVR: new(PortForward),
client.DirGVR: new(Dir),
client.SvcGVR: new(Service),
client.PodGVR: new(Pod),
client.NodeGVR: new(Node),
client.NsGVR: new(Namespace),
client.CmGVR: new(ConfigMap),
client.SecGVR: new(Secret),
client.DpGVR: new(Deployment),
client.DsGVR: new(DaemonSet),
client.StsGVR: new(StatefulSet),
client.RsGVR: new(ReplicaSet),
client.CjGVR: new(CronJob),
client.JobGVR: new(Job),
client.HmGVR: new(HelmChart),
client.HmhGVR: new(HelmHistory),
client.CrdGVR: new(CustomResourceDefinition),
}
// Accessors represents a collection of dao accessors.
type Accessors map[*client.GVR]Accessor
// AccessorFor returns a client accessor for a resource if registered.
// Otherwise it returns a generic accessor.
// Customize here for non resource types or types with metrics or logs.
func AccessorFor(f Factory, gvr *client.GVR) (Accessor, error) {
r, ok := accessors[gvr]
if !ok {
r = new(Scaler)
slog.Debug("No DAO registry entry. Using generics!", slogs.GVR, gvr)
}
r.Init(f, gvr)
return r, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_items_test.go | internal/dao/log_items_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"fmt"
"log/slog"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestLogItemsFilter(t *testing.T) {
uu := map[string]struct {
q string
opts dao.LogOptions
e []int
indices [][]int
err error
}{
"empty": {
opts: dao.LogOptions{},
},
"pod-name": {
q: "blee",
opts: dao.LogOptions{
Path: "fred/blee",
Container: "c1",
},
e: []int{0, 1, 2},
},
"container-name": {
q: "c1",
opts: dao.LogOptions{
Path: "fred/blee",
Container: "c1",
},
e: []int{0, 1, 2},
indices: [][]int{{26, 27}, {26, 27}, {26, 27}}, // matches container name "c1" at positions 26-27 in rendered format each line
},
"message": {
q: "zorg",
opts: dao.LogOptions{
Path: "fred/blee",
Container: "c1",
},
e: []int{2},
},
"fuzzy": {
q: "-f zorg",
opts: dao.LogOptions{
Path: "fred/blee",
Container: "c1",
},
e: []int{2},
},
"multi-origin-text-match": {
q: "will",
opts: dao.LogOptions{
Path: "fred/blee",
Container: "c1",
},
e: []int{1, 2},
indices: [][]int{{45, 46, 47, 48, 59, 60, 61, 62}, {64, 65, 66, 67, 70, 71, 72, 73, 76, 77, 78, 79}},
},
}
for k := range uu {
u := uu[k]
ii := dao.NewLogItems()
ii.Add(
dao.NewLogItem([]byte(fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."))),
dao.NewLogItemFromString("Bumble bee tuna. will be back. will win."),
dao.NewLogItemFromString("Jean Batiste Emmanuel Zorg. wili, will. will, will"),
)
t.Run(k, func(t *testing.T) {
_, n := client.Namespaced(u.opts.Path)
for _, i := range ii.Items() {
i.Pod, i.Container = n, u.opts.Container
}
res, indices, err := ii.Filter(0, u.q, false)
assert.Equal(t, u.err, err)
if err == nil {
assert.Equal(t, u.e, res)
if u.indices != nil {
assert.Equal(t, u.indices, indices)
}
}
})
}
}
func TestLogItemsRender(t *testing.T) {
uu := map[string]struct {
opts dao.LogOptions
e string
}{
"empty": {
opts: dao.LogOptions{},
e: "Testing 1,2,3...\n",
},
"container": {
opts: dao.LogOptions{
Container: "fred",
},
e: "[teal::b]fred[-::-] Testing 1,2,3...\n",
},
"pod-container": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "blee",
},
e: "[teal::]fred [teal::b]blee[-::-] Testing 1,2,3...\n",
},
"full": {
opts: dao.LogOptions{
Path: "blee/fred",
Container: "blee",
ShowTimestamp: true,
},
e: "[gray::b]2018-12-14T10:36:43.326972-07:00 [-::-][teal::]fred [teal::b]blee[-::-] Testing 1,2,3...\n",
},
}
s := []byte(fmt.Sprintf("%s %s\n", "2018-12-14T10:36:43.326972-07:00", "Testing 1,2,3..."))
for k := range uu {
ii := dao.NewLogItems()
ii.Add(dao.NewLogItem(s))
u := uu[k]
_, n := client.Namespaced(u.opts.Path)
ii.Items()[0].Pod, ii.Items()[0].Container = n, u.opts.Container
t.Run(k, func(t *testing.T) {
res := make([][]byte, 1)
ii.Render(0, u.opts.ShowTimestamp, res)
assert.Equal(t, u.e, string(res[0]))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/secret_test.go | internal/dao/secret_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestEncodedSecretDescribe(t *testing.T) {
var s dao.Secret
s.Init(makeFactory(), client.SecGVR)
encodedString := `
Name: bootstrap-token-abcdef
Namespace: kube-system
Labels: <none>
Annotations: <none>
Type: generic
Data
====
token-secret: 24 bytes`
expected := "\nName: bootstrap-token-abcdef\n" +
"Namespace: kube-system\n" +
"Labels: <none>\n" +
"Annotations: <none>\n" +
"\n" +
"Type: generic\n" +
"\n" +
"Data\n" +
"====\n" +
"token-secret: 0123456789abcdef"
decodedDescription, err := s.Decode(encodedString, "kube-system/bootstrap-token-abcdef")
require.NoError(t, err)
assert.Equal(t, expected, decodedDescription)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_item.go | internal/dao/log_item.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"bytes"
)
// LogChan represents a channel for logs.
type LogChan chan *LogItem
var ItemEOF = new(LogItem)
// LogItem represents a container log line.
type LogItem struct {
Pod, Container string
SingleContainer bool
Bytes []byte
IsError bool
}
// NewLogItem returns a new item.
func NewLogItem(bb []byte) *LogItem {
return &LogItem{
Bytes: bb,
}
}
// NewLogItemFromString returns a new item.
func NewLogItemFromString(s string) *LogItem {
return &LogItem{
Bytes: []byte(s),
}
}
// ID returns pod and or container based id.
func (l *LogItem) ID() string {
if l.Pod != "" {
return l.Pod
}
return l.Container
}
// GetTimestamp fetch log lime timestamp
func (l *LogItem) GetTimestamp() string {
index := bytes.Index(l.Bytes, []byte{' '})
if index < 0 {
return ""
}
return string(l.Bytes[:index])
}
// Info returns pod and container information.
func (l *LogItem) Info() string {
return l.Pod + "::" + l.Container
}
// IsEmpty checks if the entry is empty.
func (l *LogItem) IsEmpty() bool {
return len(l.Bytes) == 0
}
// Size returns the size of the item.
func (l *LogItem) Size() int {
return 100 + len(l.Bytes) + len(l.Pod) + len(l.Container)
}
// Render returns a log line as string.
func (l *LogItem) Render(paint string, showTime bool, bb *bytes.Buffer) {
index := bytes.Index(l.Bytes, []byte{' '})
if showTime && index > 0 {
bb.WriteString("[gray::b]")
bb.Write(l.Bytes[:index])
bb.WriteString(" ")
if l := 30 - len(l.Bytes[:index]); l > 0 {
bb.Write(bytes.Repeat([]byte{' '}, l))
}
bb.WriteString("[-::-]")
}
if l.Pod != "" {
bb.WriteString("[" + paint + "::]" + l.Pod)
}
if !l.SingleContainer && l.Container != "" {
if l.Pod != "" {
bb.WriteString(" ")
}
bb.WriteString("[" + paint + "::b]" + l.Container + "[-::-] ")
} else if l.Pod != "" {
bb.WriteString("[-::] ")
}
if index > 0 {
bb.Write(l.Bytes[index+1:])
} else {
bb.Write(l.Bytes)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/pulse.go | internal/dao/pulse.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"fmt"
"k8s.io/apimachinery/pkg/runtime"
)
// Pulse tracks pulses.
type Pulse struct {
NonResource
}
// List lists out pulses.
func (*Pulse) List(context.Context, string) ([]runtime.Object, error) {
return nil, fmt.Errorf("NYI")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rbac_subject.go | internal/dao/rbac_subject.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/render"
"k8s.io/apimachinery/pkg/runtime"
)
var (
_ Accessor = (*Subject)(nil)
_ Nuker = (*Subject)(nil)
)
// Subject represents a subject model.
type Subject struct {
Resource
}
// List returns a collection of subjects.
func (s *Subject) List(ctx context.Context, _ string) ([]runtime.Object, error) {
kind, ok := ctx.Value(internal.KeySubjectKind).(string)
if !ok {
return nil, errors.New("expecting a SubjectKind")
}
crbs, err := s.listClusterRoleBindings(kind)
if err != nil {
return nil, err
}
rbs, err := s.listRoleBindings(kind)
if err != nil {
return nil, err
}
for _, rb := range rbs {
crbs = crbs.Upsert(rb)
}
oo := make([]runtime.Object, len(crbs))
for i, o := range crbs {
oo[i] = o
}
return oo, nil
}
func (s *Subject) listClusterRoleBindings(kind string) (render.Subjects, error) {
crbs, err := fetchClusterRoleBindings(s.Factory)
if err != nil {
return nil, err
}
oo := make(render.Subjects, 0, len(crbs))
for i := range crbs {
for _, su := range crbs[i].Subjects {
if su.Kind != kind {
continue
}
oo = oo.Upsert(render.SubjectRes{
Name: su.Name,
Kind: "ClusterRoleBinding",
FirstLocation: crbs[i].Name,
})
}
}
return oo, nil
}
func (s *Subject) listRoleBindings(kind string) (render.Subjects, error) {
rbs, err := fetchRoleBindings(s.Factory)
if err != nil {
return nil, err
}
oo := make(render.Subjects, 0, len(rbs))
for i := range rbs {
for _, su := range rbs[i].Subjects {
if su.Kind != kind {
continue
}
oo = oo.Upsert(render.SubjectRes{
Name: su.Name,
Kind: "RoleBinding",
FirstLocation: rbs[i].Name,
})
}
}
return oo, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/patch.go | internal/dao/patch.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"encoding/json"
)
// ImageSpec represents a container image.
type ImageSpec struct {
Index int
Name, DockerImage string
Init bool
}
// ImageSpecs represents a collection of container images.
type ImageSpecs []ImageSpec
// JsonPatch track pod spec updates.
type JsonPatch struct {
Spec Spec `json:"spec"`
}
// Spec represents a pod template.
type Spec struct {
Template PodSpec `json:"template"`
}
// PodSpec represents a collection of container images.
type PodSpec struct {
Spec ImagesSpec `json:"spec"`
}
// ImagesSpec tracks container image updates.
type ImagesSpec struct {
SetElementOrderContainers []Element `json:"$setElementOrder/containers,omitempty"`
SetElementOrderInitContainers []Element `json:"$setElementOrder/initContainers,omitempty"`
Containers []Element `json:"containers,omitempty"`
InitContainers []Element `json:"initContainers,omitempty"`
}
// Element tracks a given container image.
type Element struct {
Image string `json:"image,omitempty"`
Name string `json:"name"`
}
// GetTemplateJsonPatch builds a json patch string to update PodSpec images.
func GetTemplateJsonPatch(imageSpecs ImageSpecs) ([]byte, error) {
jsonPatch := JsonPatch{
Spec: Spec{
Template: getPatchPodSpec(imageSpecs),
},
}
return json.Marshal(jsonPatch)
}
// GetJsonPatch returns container image patch.
func GetJsonPatch(imageSpecs ImageSpecs) ([]byte, error) {
podSpec := getPatchPodSpec(imageSpecs)
return json.Marshal(podSpec)
}
func getPatchPodSpec(imageSpecs ImageSpecs) PodSpec {
initElementsOrders, initElements, elementsOrders, elements := extractElements(imageSpecs)
podSpec := PodSpec{
Spec: ImagesSpec{
SetElementOrderInitContainers: initElementsOrders,
InitContainers: initElements,
SetElementOrderContainers: elementsOrders,
Containers: elements,
},
}
return podSpec
}
func extractElements(imageSpecs ImageSpecs) (initElementsOrders, initElements, elementsOrders, elements []Element) {
for _, spec := range imageSpecs {
if spec.Init {
initElementsOrders = append(initElementsOrders, Element{Name: spec.Name})
initElements = append(initElements, Element{Name: spec.Name, Image: spec.DockerImage})
} else {
elementsOrders = append(elementsOrders, Element{Name: spec.Name})
elements = append(elements, Element{Name: spec.Name, Image: spec.DockerImage})
}
}
return initElementsOrders, initElements, elementsOrders, elements
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/sts.go | internal/dao/sts.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
appsv1 "k8s.io/api/apps/v1"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
)
var (
_ Accessor = (*StatefulSet)(nil)
_ Nuker = (*StatefulSet)(nil)
_ Loggable = (*StatefulSet)(nil)
_ Restartable = (*StatefulSet)(nil)
_ Scalable = (*StatefulSet)(nil)
_ Controller = (*StatefulSet)(nil)
_ ContainsPodSpec = (*StatefulSet)(nil)
_ ImageLister = (*StatefulSet)(nil)
)
// StatefulSet represents a K8s sts.
type StatefulSet struct {
Resource
}
// ListImages lists container images.
func (s *StatefulSet) ListImages(_ context.Context, fqn string) ([]string, error) {
sts, err := s.GetInstance(s.Factory, fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&sts.Spec.Template.Spec), nil
}
// Scale a StatefulSet.
func (s *StatefulSet) Scale(ctx context.Context, path string, replicas int32) error {
return scaleRes(ctx, s.getFactory(), client.StsGVR, path, replicas)
}
// Restart a StatefulSet rollout.
func (s *StatefulSet) Restart(ctx context.Context, path string, opts *metav1.PatchOptions) error {
return restartRes[*appsv1.StatefulSet](ctx, s.getFactory(), client.StsGVR, path, opts)
}
// GetInstance returns a statefulset instance.
func (*StatefulSet) GetInstance(f Factory, fqn string) (*appsv1.StatefulSet, error) {
o, err := f.Get(client.StsGVR, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var sts appsv1.StatefulSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &sts)
if err != nil {
return nil, errors.New("expecting Statefulset resource")
}
return &sts, nil
}
// TailLogs tail logs for all pods represented by this StatefulSet.
func (s *StatefulSet) TailLogs(ctx context.Context, opts *LogOptions) ([]LogChan, error) {
sts, err := s.getStatefulSet(opts.Path)
if err != nil {
return nil, errors.New("expecting StatefulSet resource")
}
if sts.Spec.Selector == nil || len(sts.Spec.Selector.MatchLabels) == 0 {
return nil, fmt.Errorf("no valid selector found on statefulset: %s", opts.Path)
}
return podLogs(ctx, sts.Spec.Selector.MatchLabels, opts)
}
// Pod returns a pod victim by name.
func (s *StatefulSet) Pod(fqn string) (string, error) {
sts, err := s.getStatefulSet(fqn)
if err != nil {
return "", err
}
return podFromSelector(s.Factory, sts.Namespace, sts.Spec.Selector.MatchLabels)
}
func (s *StatefulSet) getStatefulSet(fqn string) (*appsv1.StatefulSet, error) {
o, err := s.getFactory().Get(s.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var sts appsv1.StatefulSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &sts)
if err != nil {
return nil, errors.New("expecting Service resource")
}
return &sts, nil
}
// ScanSA scans for serviceaccount refs.
func (s *StatefulSet) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := s.getFactory().List(s.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var sts appsv1.StatefulSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &sts)
if err != nil {
return nil, errors.New("expecting StatefulSet resource")
}
if serviceAccountMatches(sts.Spec.Template.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
}
}
return refs, nil
}
// Scan scans for cluster resource refs.
func (s *StatefulSet) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := s.getFactory().List(s.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var sts appsv1.StatefulSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &sts)
if err != nil {
return nil, errors.New("expecting StatefulSet resource")
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&sts.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
case client.SecGVR:
found, err := hasSecret(s.Factory, &sts.Spec.Template.Spec, sts.Namespace, n, wait)
if err != nil {
slog.Warn("Locate secret failed",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
case client.PvcGVR:
for i := range sts.Spec.VolumeClaimTemplates {
if !strings.HasPrefix(n, sts.Spec.VolumeClaimTemplates[i].Name+"-"+sts.Name) {
continue
}
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
}
if !hasPVC(&sts.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
case client.PcGVR:
if !hasPC(&sts.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: s.GVR(),
FQN: client.FQN(sts.Namespace, sts.Name),
})
}
}
return refs, nil
}
// GetPodSpec returns a pod spec given a resource.
func (s *StatefulSet) GetPodSpec(path string) (*v1.PodSpec, error) {
sts, err := s.getStatefulSet(path)
if err != nil {
return nil, err
}
podSpec := sts.Spec.Template.Spec
return &podSpec, nil
}
// SetImages sets container images.
func (s *StatefulSet) SetImages(ctx context.Context, path string, imageSpecs ImageSpecs) error {
ns, n := client.Namespaced(path)
auth, err := s.Client().CanI(ns, client.StsGVR, n, client.PatchAccess)
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to patch a statefulset")
}
jsonPatch, err := GetTemplateJsonPatch(imageSpecs)
if err != nil {
return err
}
dial, err := s.Client().Dial()
if err != nil {
return err
}
_, err = dial.AppsV1().StatefulSets(ns).Patch(
ctx,
n,
types.StrategicMergePatchType,
jsonPatch,
metav1.PatchOptions{},
)
return err
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/registry_test.go | internal/dao/registry_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestMetaFor(t *testing.T) {
uu := map[string]struct {
gvr *client.GVR
err error
e metav1.APIResource
}{
"xray-gvr": {
gvr: client.XGVR,
e: metav1.APIResource{
Name: "xrays",
Kind: "XRays",
SingularName: "xray",
Categories: []string{k9sCat},
},
},
"xray": {
gvr: client.NewGVR("xrays"),
e: metav1.APIResource{
Name: "xrays",
Kind: "XRays",
SingularName: "xray",
Categories: []string{k9sCat},
},
},
"policy": {
gvr: client.NewGVR("policy"),
e: metav1.APIResource{
Name: "policies",
Kind: "Rules",
Namespaced: true,
Categories: []string{k9sCat},
},
},
"helm": {
gvr: client.NewGVR("helm"),
e: metav1.APIResource{
Name: "helm",
Kind: "Helm",
Namespaced: true,
Verbs: []string{"delete"},
Categories: []string{helmCat},
},
},
"toast": {
gvr: client.NewGVR("blah"),
err: errors.New("no resource meta defined for\n \"blah\""),
},
}
m := NewMeta()
require.NoError(t, m.LoadResources(nil))
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
meta, err := m.MetaFor(u.gvr)
assert.Equal(t, u.err, err)
if err == nil {
assert.Equal(t, &u.e, meta)
}
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rbac_policy_test.go | internal/dao/rbac_policy_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"testing"
"github.com/stretchr/testify/assert"
rbacv1 "k8s.io/api/rbac/v1"
)
func TestIsSameSubject(t *testing.T) {
uu := map[string]struct {
kind string
namespace string
name string
subject rbacv1.Subject
want bool
}{
"kind-name-match": {
kind: rbacv1.UserKind,
name: "foo",
subject: rbacv1.Subject{
Kind: rbacv1.UserKind,
Name: "foo",
},
want: true,
},
"name-does-not-match": {
kind: rbacv1.UserKind,
name: "foo",
subject: rbacv1.Subject{
Kind: rbacv1.UserKind,
Name: "bar",
},
want: false,
},
"kind-does-not-match": {
kind: rbacv1.GroupKind,
name: "foo",
subject: rbacv1.Subject{
Kind: rbacv1.UserKind,
Name: "foo",
},
want: false,
},
"serviceAccount-all-match": {
kind: rbacv1.ServiceAccountKind,
name: "foo",
namespace: "bar",
subject: rbacv1.Subject{
Kind: rbacv1.ServiceAccountKind,
Name: "foo",
Namespace: "bar",
},
want: true,
},
"serviceAccount-namespace-no-match": {
kind: rbacv1.ServiceAccountKind,
name: "foo",
namespace: "bar",
subject: rbacv1.Subject{
Kind: rbacv1.ServiceAccountKind,
Name: "foo",
Namespace: "bazz",
},
want: false,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
same := isSameSubject(u.kind, u.namespace, u.namespace, u.name, &u.subject)
assert.Equal(t, u.want, same)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/cronjob.go | internal/dao/cronjob.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
batchv1 "k8s.io/api/batch/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/rand"
)
const maxJobNameSize = 42
var (
_ Accessor = (*CronJob)(nil)
_ Runnable = (*CronJob)(nil)
_ ImageLister = (*CronJob)(nil)
)
// CronJob represents a cronjob K8s resource.
type CronJob struct {
Generic
}
// ListImages lists container images.
func (c *CronJob) ListImages(_ context.Context, fqn string) ([]string, error) {
cj, err := c.GetInstance(fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&cj.Spec.JobTemplate.Spec.Template.Spec), nil
}
// Run a CronJob.
func (c *CronJob) Run(path string) error {
ns, n := client.Namespaced(path)
auth, err := c.Client().CanI(ns, client.JobGVR, n, []string{client.GetVerb, client.CreateVerb})
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to run jobs")
}
o, err := c.getFactory().Get(c.gvr, path, true, labels.Everything())
if err != nil {
return err
}
var cj batchv1.CronJob
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cj)
if err != nil {
return errors.New("expecting CronJob resource")
}
jobName := cj.Name
if len(cj.Name) >= maxJobNameSize {
jobName = cj.Name[0:maxJobNameSize]
}
trueVal := true
job := &batchv1.Job{
ObjectMeta: metav1.ObjectMeta{
Name: jobName + "-manual-" + rand.String(3),
Namespace: ns,
Labels: cj.Spec.JobTemplate.Labels,
Annotations: cj.Spec.JobTemplate.Annotations,
OwnerReferences: []metav1.OwnerReference{
{
APIVersion: c.gvr.GV().String(),
Kind: "CronJob",
BlockOwnerDeletion: &trueVal,
Controller: &trueVal,
Name: cj.Name,
UID: cj.UID,
},
},
},
Spec: cj.Spec.JobTemplate.Spec,
}
dial, err := c.Client().Dial()
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), c.Client().Config().CallTimeout())
defer cancel()
_, err = dial.BatchV1().Jobs(ns).Create(ctx, job, metav1.CreateOptions{})
return err
}
// ScanSA scans for serviceaccount refs.
func (c *CronJob) ScanSA(_ context.Context, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := c.getFactory().List(c.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var cj batchv1.CronJob
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cj)
if err != nil {
return nil, errors.New("expecting CronJob resource")
}
if serviceAccountMatches(cj.Spec.JobTemplate.Spec.Template.Spec.ServiceAccountName, n) {
refs = append(refs, Ref{
GVR: c.GVR(),
FQN: client.FQN(cj.Namespace, cj.Name),
})
}
}
return refs, nil
}
// GetInstance fetch a matching cronjob.
func (c *CronJob) GetInstance(fqn string) (*batchv1.CronJob, error) {
o, err := c.getFactory().Get(c.gvr, fqn, true, labels.Everything())
if err != nil {
return nil, err
}
var cj batchv1.CronJob
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cj)
if err != nil {
return nil, errors.New("expecting cronjob resource")
}
return &cj, nil
}
// ToggleSuspend toggles suspend/resume on a CronJob.
func (c *CronJob) ToggleSuspend(ctx context.Context, path string) error {
ns, n := client.Namespaced(path)
auth, err := c.Client().CanI(ns, c.gvr, n, []string{client.GetVerb, client.UpdateVerb})
if err != nil {
return err
}
if !auth {
return fmt.Errorf("user is not authorized to (un)suspend cronjobs")
}
dial, err := c.Client().Dial()
if err != nil {
return err
}
cj, err := dial.BatchV1().CronJobs(ns).Get(ctx, n, metav1.GetOptions{})
if err != nil {
return err
}
if cj.Spec.Suspend != nil {
current := !*cj.Spec.Suspend
cj.Spec.Suspend = ¤t
} else {
trueVal := true
cj.Spec.Suspend = &trueVal
}
_, err = dial.BatchV1().CronJobs(ns).Update(ctx, cj, metav1.UpdateOptions{})
return err
}
// Scan scans for cluster resource refs.
func (c *CronJob) Scan(_ context.Context, gvr *client.GVR, fqn string, wait bool) (Refs, error) {
ns, n := client.Namespaced(fqn)
oo, err := c.getFactory().List(c.gvr, ns, wait, labels.Everything())
if err != nil {
return nil, err
}
refs := make(Refs, 0, len(oo))
for _, o := range oo {
var cj batchv1.CronJob
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cj)
if err != nil {
return nil, errors.New("expecting CronJob resource")
}
switch gvr {
case client.CmGVR:
if !hasConfigMap(&cj.Spec.JobTemplate.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: c.GVR(),
FQN: client.FQN(cj.Namespace, cj.Name),
})
case client.SecGVR:
found, err := hasSecret(c.Factory, &cj.Spec.JobTemplate.Spec.Template.Spec, cj.Namespace, n, wait)
if err != nil {
slog.Warn("Failed to locate secret",
slogs.FQN, fqn,
slogs.Error, err,
)
continue
}
if !found {
continue
}
refs = append(refs, Ref{
GVR: c.GVR(),
FQN: client.FQN(cj.Namespace, cj.Name),
})
case client.PcGVR:
if !hasPC(&cj.Spec.JobTemplate.Spec.Template.Spec, n) {
continue
}
refs = append(refs, Ref{
GVR: c.GVR(),
FQN: client.FQN(cj.Namespace, cj.Name),
})
}
}
return refs, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/helpers.go | internal/dao/helpers.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"bytes"
"errors"
"fmt"
"log/slog"
"math"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/cli-runtime/pkg/printers"
)
const (
defaultServiceAccount = "default"
// DefaultContainerAnnotation represents the annotation key for the default container.
DefaultContainerAnnotation = "kubectl.kubernetes.io/default-container"
)
// GetDefaultContainer returns a container name if specified in an annotation.
func GetDefaultContainer(m *metav1.ObjectMeta, spec *v1.PodSpec) (string, bool) {
defaultContainer, ok := m.Annotations[DefaultContainerAnnotation]
if !ok {
return "", false
}
for i := range spec.Containers {
if spec.Containers[i].Name == defaultContainer {
return defaultContainer, true
}
}
slog.Warn("Container not found. Annotation ignored",
slogs.Container, defaultContainer,
slogs.Annotation, DefaultContainerAnnotation,
)
return "", false
}
func extractFQN(o runtime.Object) string {
u, ok := o.(*unstructured.Unstructured)
if !ok {
slog.Error("Expecting unstructured", slogs.ResType, fmt.Sprintf("%T", o))
return client.NA
}
return FQN(u.GetNamespace(), u.GetName())
}
// FQN returns a fully qualified resource name.
func FQN(ns, n string) string {
if ns == "" {
return n
}
return ns + "/" + n
}
func inList(ll []string, s string) bool {
for _, l := range ll {
if l == s {
return true
}
}
return false
}
func toPerc(v, dv float64) float64 {
if dv == 0 {
return 0
}
return math.Round((v / dv) * 100)
}
// ToYAML converts a resource to its YAML representation.
func ToYAML(o runtime.Object, showManaged bool) (string, error) {
if o == nil {
return "", errors.New("no object to yamlize")
}
var p printers.ResourcePrinter = &printers.YAMLPrinter{}
if !showManaged {
o = o.DeepCopyObject()
p = &printers.OmitManagedFieldsPrinter{Delegate: p}
}
var buff bytes.Buffer
if err := p.PrintObj(o, &buff); err != nil {
slog.Error("PrintObj failed", slogs.Error, err)
return "", err
}
return buff.String(), nil
}
// serviceAccountMatches validates that the ServiceAccount referenced in the PodSpec matches the incoming
// ServiceAccount. If the PodSpec ServiceAccount is blank kubernetes will use the "default" ServiceAccount
// when deploying the pod, so if the incoming SA is "default" and podSA is an empty string that is also a match.
func serviceAccountMatches(podSA, saName string) bool {
if podSA == "" {
podSA = defaultServiceAccount
}
return podSA == saName
}
// ContinuousRanges takes a sorted slice of integers and returns a slice of
// sub-slices representing continuous ranges of integers.
func ContinuousRanges(indexes []int) [][]int {
var ranges [][]int
for i, p := 1, 0; i <= len(indexes); i++ {
if i == len(indexes) || indexes[i]-indexes[p] != i-p {
ranges = append(ranges, []int{indexes[p], indexes[i-1] + 1})
p = i
}
}
return ranges
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/rs.go | internal/dao/rs.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
appsv1 "k8s.io/api/apps/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
cmdutil "k8s.io/kubectl/pkg/cmd/util"
"k8s.io/kubectl/pkg/polymorphichelpers"
)
var (
_ ImageLister = (*ReplicaSet)(nil)
)
// ReplicaSet represents a replicaset K8s resource.
type ReplicaSet struct {
Resource
}
// ListImages lists container images.
func (r *ReplicaSet) ListImages(_ context.Context, fqn string) ([]string, error) {
rs, err := r.Load(r.Factory, fqn)
if err != nil {
return nil, err
}
return render.ExtractImages(&rs.Spec.Template.Spec), nil
}
// Load returns a given instance.
func (*ReplicaSet) Load(f Factory, path string) (*appsv1.ReplicaSet, error) {
o, err := f.Get(client.RsGVR, path, true, labels.Everything())
if err != nil {
return nil, err
}
var rs appsv1.ReplicaSet
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &rs)
if err != nil {
return nil, err
}
return &rs, nil
}
func getRSRevision(rs *appsv1.ReplicaSet) (int64, error) {
revision := rs.Annotations["deployment.kubernetes.io/revision"]
if rs.Status.Replicas != 0 {
return 0, errors.New("can not rollback current replica")
}
vers, err := strconv.Atoi(revision)
if err != nil {
return 0, errors.New("revision conversion failed")
}
return int64(vers), nil
}
func controllerInfo(rs *appsv1.ReplicaSet) (name, kind, group string, err error) {
for _, ref := range rs.OwnerReferences {
if ref.Controller == nil {
continue
}
group, tokens := ref.APIVersion, strings.Split(ref.APIVersion, "/")
if len(tokens) == 2 {
group = tokens[0]
}
return ref.Name, ref.Kind, group, nil
}
return "", "", "", fmt.Errorf("unable to find controller for replicaset: %s", rs.Name)
}
// Rollback reverses the last deployment.
func (r *ReplicaSet) Rollback(fqn string) error {
rs, err := r.Load(r.Factory, fqn)
if err != nil {
return err
}
version, err := getRSRevision(rs)
if err != nil {
return err
}
name, kind, apiGroup, err := controllerInfo(rs)
if err != nil {
return err
}
dial, err := r.Client().Dial()
if err != nil {
return err
}
rb, err := polymorphichelpers.RollbackerFor(schema.GroupKind{
Group: apiGroup,
Kind: kind,
},
dial,
)
if err != nil {
return err
}
var ddp Deployment
ddp.Init(r.Factory, client.DpGVR)
dp, err := ddp.GetInstance(client.FQN(rs.Namespace, name))
if err != nil {
return err
}
_, err = rb.Rollback(dp, map[string]string{}, version, cmdutil.DryRunNone)
if err != nil {
return err
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/dir.go | internal/dao/dir.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"os"
"path/filepath"
"regexp"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"k8s.io/apimachinery/pkg/runtime"
)
var _ Accessor = (*Dir)(nil)
// Dir tracks standard and custom command aliases.
type Dir struct {
NonResource
}
// NewDir returns a new set of aliases.
func NewDir(f Factory) *Dir {
var a Dir
a.Init(f, client.DirGVR)
return &a
}
var yamlRX = regexp.MustCompile(`.*\.(yml|yaml|json)`)
// List returns a collection of aliases.
func (*Dir) List(ctx context.Context, _ string) ([]runtime.Object, error) {
dir, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("no dir in context")
}
files, err := os.ReadDir(dir)
if err != nil {
return nil, err
}
oo := make([]runtime.Object, 0, len(files))
for _, f := range files {
if strings.HasPrefix(f.Name(), ".") || !f.IsDir() && !yamlRX.MatchString(f.Name()) {
continue
}
oo = append(oo, render.DirRes{
Path: filepath.Join(dir, f.Name()),
Entry: f,
})
}
return oo, err
}
// Get fetch a resource.
func (*Dir) Get(_ context.Context, _ string) (runtime.Object, error) {
return nil, errors.New("nyi")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/reference.go | internal/dao/reference.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"errors"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"k8s.io/apimachinery/pkg/runtime"
)
var _ Accessor = (*Reference)(nil)
// Reference represents cluster resource references.
type Reference struct {
NonResource
}
// List collects all references.
func (r *Reference) List(ctx context.Context, _ string) ([]runtime.Object, error) {
gvr, ok := ctx.Value(internal.KeyGVR).(*client.GVR)
if !ok {
return nil, errors.New("no context for gvr found")
}
switch gvr {
case client.SaGVR:
return r.ScanSA(ctx)
default:
return r.Scan(ctx)
}
}
// Get fetch a given reference.
func (*Reference) Get(context.Context, string) (runtime.Object, error) {
panic("NYI")
}
// Scan scan cluster resources for references.
func (r *Reference) Scan(ctx context.Context) ([]runtime.Object, error) {
refs, err := ScanForRefs(ctx, r.Factory)
if err != nil {
return nil, err
}
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("expecting context Path")
}
ns, _ := client.Namespaced(fqn)
oo := make([]runtime.Object, 0, len(refs))
for _, ref := range refs {
_, n := client.Namespaced(ref.FQN)
oo = append(oo, render.ReferenceRes{
Namespace: ns,
Name: n,
GVR: ref.GVR,
})
}
return oo, nil
}
// ScanSA scans for serviceaccount refs.
func (r *Reference) ScanSA(ctx context.Context) ([]runtime.Object, error) {
refs, err := ScanForSARefs(ctx, r.Factory)
if err != nil {
return nil, err
}
fqn, ok := ctx.Value(internal.KeyPath).(string)
if !ok {
return nil, errors.New("expecting context Path")
}
ns, _ := client.Namespaced(fqn)
oo := make([]runtime.Object, 0, len(refs))
for _, ref := range refs {
_, n := client.Namespaced(ref.FQN)
oo = append(oo, render.ReferenceRes{
Namespace: ns,
Name: n,
GVR: ref.GVR,
})
}
return oo, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/log_options.go | internal/dao/log_options.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"fmt"
"time"
"github.com/derailed/k9s/internal/client"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// LogOptions represents logger options.
type LogOptions struct {
CreateDuration time.Duration
Path string
Container string
DefaultContainer string
SinceTime string
Lines int64
SinceSeconds int64
Head bool
Previous bool
SingleContainer bool
MultiPods bool
ShowTimestamp bool
AllContainers bool
}
// Info returns the option pod and container info.
func (o *LogOptions) Info() string {
if o.Container != "" {
return fmt.Sprintf("%s (%s)", o.Path, o.Container)
}
return o.Path
}
// Clone clones options.
func (o *LogOptions) Clone() *LogOptions {
return &LogOptions{
Path: o.Path,
Container: o.Container,
DefaultContainer: o.DefaultContainer,
Lines: o.Lines,
Previous: o.Previous,
Head: o.Head,
SingleContainer: o.SingleContainer,
MultiPods: o.MultiPods,
ShowTimestamp: o.ShowTimestamp,
SinceTime: o.SinceTime,
SinceSeconds: o.SinceSeconds,
AllContainers: o.AllContainers,
}
}
// HasContainer checks if a container is present.
func (o *LogOptions) HasContainer() bool {
return o.Container != ""
}
// ToggleAllContainers toggles single or all-containers if possible.
func (o *LogOptions) ToggleAllContainers() {
if o.SingleContainer {
return
}
o.AllContainers = !o.AllContainers
if o.AllContainers {
o.DefaultContainer, o.Container = o.Container, ""
return
}
if o.DefaultContainer != "" {
o.Container = o.DefaultContainer
}
}
// ToPodLogOptions returns pod log options.
func (o *LogOptions) ToPodLogOptions() *v1.PodLogOptions {
opts := v1.PodLogOptions{
Follow: true,
Timestamps: true,
Container: o.Container,
Previous: o.Previous,
TailLines: &o.Lines,
}
if o.Head {
var maxBytes int64 = 5000
opts.Follow = false
opts.TailLines, opts.SinceSeconds, opts.SinceTime = nil, nil, nil
opts.LimitBytes = &maxBytes
return &opts
}
if o.SinceSeconds < 0 {
return &opts
}
if o.SinceSeconds != 0 {
opts.SinceSeconds, opts.SinceTime = &o.SinceSeconds, nil
return &opts
}
if o.SinceTime == "" {
return &opts
}
if t, err := time.Parse(time.RFC3339, o.SinceTime); err == nil {
opts.SinceTime = &metav1.Time{Time: t.Add(time.Second)}
}
return &opts
}
// ToLogItem add a log header to display po/co information along with the log message.
func (o *LogOptions) ToLogItem(bytes []byte) *LogItem {
item := NewLogItem(bytes)
if len(bytes) == 0 {
return item
}
item.SingleContainer = o.SingleContainer
if item.SingleContainer {
item.Container = o.Container
}
if o.MultiPods {
_, pod := client.Namespaced(o.Path)
item.Pod, item.Container = pod, o.Container
} else {
item.Container = o.Container
}
return item
}
func (*LogOptions) ToErrLogItem(err error) *LogItem {
t := time.Now().UTC().Format(time.RFC3339Nano)
item := NewLogItem([]byte(fmt.Sprintf("%s [orange::b]%s[::-]\n", t, err)))
item.IsError = true
return item
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/scalable.go | internal/dao/scalable.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
import (
"context"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/restmapper"
"k8s.io/client-go/scale"
)
var (
_ Scalable = (*Scaler)(nil)
_ ReplicasGetter = (*Scaler)(nil)
)
// Scaler represents a generic resource with scaling.
type Scaler struct {
Generic
}
// Replicas returns the number of replicas for the resource located at the given path.
func (s *Scaler) Replicas(ctx context.Context, path string) (int32, error) {
scaleClient, err := s.scaleClient()
if err != nil {
return 0, err
}
ns, name := client.Namespaced(path)
currScale, err := scaleClient.Scales(ns).Get(ctx, *s.gvr.GR(), name, metav1.GetOptions{})
if err != nil {
return 0, err
}
return currScale.Spec.Replicas, nil
}
// Scale modifies the number of replicas for a given resource specified by the path.
func (s *Scaler) Scale(ctx context.Context, path string, replicas int32) error {
ns, name := client.Namespaced(path)
scaleClient, err := s.scaleClient()
if err != nil {
return err
}
currentScale, err := scaleClient.Scales(ns).Get(ctx, *s.gvr.GR(), name, metav1.GetOptions{})
if err != nil {
return err
}
currentScale.Spec.Replicas = replicas
updatedScale, err := scaleClient.Scales(ns).Update(ctx, *s.gvr.GR(), currentScale, metav1.UpdateOptions{})
if err != nil {
return err
}
slog.Debug("Scaled resource",
slogs.FQN, path,
slogs.Replicas, updatedScale.Spec.Replicas,
)
return nil
}
func (s *Scaler) scaleClient() (scale.ScalesGetter, error) {
cfg, err := s.Client().RestConfig()
if err != nil {
return nil, err
}
discoveryClient, err := s.Client().CachedDiscovery()
if err != nil {
return nil, err
}
mapper := restmapper.NewDeferredDiscoveryRESTMapper(discoveryClient)
scaleKindResolver := scale.NewDiscoveryScaleKindResolver(discoveryClient)
return scale.NewForConfig(cfg, mapper, dynamic.LegacyAPIPathResolverFunc, scaleKindResolver)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/dao/cm.go | internal/dao/cm.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package dao
var _ Accessor = (*ConfigMap)(nil)
// ConfigMap represents a configmap resource.
type ConfigMap struct {
Resource
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/scorer_test.go | internal/vul/scorer_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_scorerAdd(t *testing.T) {
uu := map[string]struct {
b, b1, e scorer
}{
"zero": {},
"same": {
b: scorer(0x80),
b1: scorer(0x80),
e: scorer(0x80),
},
"c+h": {
b: scorer(0x80),
b1: scorer(0x40),
e: scorer(0xC0),
},
"ch+hm": {
b: scorer(0xc0),
b1: scorer(0xa0),
e: scorer(0xe0),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.b.Add(u.b1))
})
}
}
func Test_scorerFromTally(t *testing.T) {
uu := map[string]struct {
tt tally
b scorer
}{
"zero": {},
"critical": {
tt: tally{29, 0, 0, 0, 0, 0, 0},
b: scorer(0x80),
},
"high": {
tt: tally{0, 17, 0, 0, 0, 0, 0},
b: scorer(0x40),
},
"medium": {
tt: tally{0, 0, 5, 0, 0, 0, 0},
b: scorer(0x20),
},
"low": {
tt: tally{0, 0, 0, 10, 0, 0, 0},
b: scorer(0x10),
},
"negligible": {
tt: tally{0, 0, 0, 0, 10, 0, 0},
b: scorer(0x08),
},
"unknown": {
tt: tally{0, 0, 0, 0, 0, 10, 0},
b: scorer(0x04),
},
"c/h": {
tt: tally{10, 20, 0, 0, 0, 0, 0},
b: scorer(0xC0),
},
"c/m": {
tt: tally{10, 0, 20, 0, 0, 0, 0},
b: scorer(0xA0),
},
"c/h/l": {
tt: tally{10, 1, 20, 0, 0, 0, 0},
b: scorer(0xE0),
},
"n/u": {
tt: tally{0, 0, 0, 0, 10, 20, 0},
b: scorer(0x0C),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.b, newScorer(u.tt))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/table_test.go | internal/vul/table_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"bufio"
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func Test_sort(t *testing.T) {
uu := map[string]struct {
t1, t2 *table
}{
"simple": {
t1: makeTable(t, "testdata/sort/no_dups/sc1.text"),
t2: makeTable(t, "testdata/sort/no_dups/sc2.text"),
},
"dups": {
t1: makeTable(t, "testdata/sort/dups/sc1.text"),
t2: makeTable(t, "testdata/sort/dups/sc2.text"),
},
"full": {
t1: makeTable(t, "testdata/sort/full/sc1.text"),
t2: makeTable(t, "testdata/sort/full/sc2.text"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
u.t1.sort()
assert.Equal(t, u.t2, u.t1)
})
}
}
func Test_sortSev(t *testing.T) {
uu := map[string]struct {
t1, t2 *table
}{
"simple": {
t1: makeTable(t, "testdata/sort_sev/no_dups/sc1.text"),
t2: makeTable(t, "testdata/sort_sev/no_dups/sc2.text"),
},
"dups": {
t1: makeTable(t, "testdata/sort_sev/dups/sc1.text"),
t2: makeTable(t, "testdata/sort_sev/dups/sc2.text"),
},
"full": {
t1: makeTable(t, "testdata/sort_sev/full/sc1.text"),
t2: makeTable(t, "testdata/sort_sev/full/sc2.text"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
u.t1.sortSev()
assert.Equal(t, u.t2, u.t1)
})
}
}
// Helpers...
func makeTable(t *testing.T, path string) *table {
f, err := os.Open(path)
defer func() {
_ = f.Close()
}()
require.NoError(t, err)
sc := bufio.NewScanner(f)
var tt table
for sc.Scan() {
ff := strings.Fields(sc.Text())
tt.addRow(newRow(ff...))
}
require.NoError(t, sc.Err())
return &tt
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/table.go | internal/vul/table.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"fmt"
"io"
"sort"
"strings"
"github.com/olekukonko/tablewriter"
"github.com/olekukonko/tablewriter/renderer"
"github.com/olekukonko/tablewriter/tw"
)
const (
nameIdx = iota
verIdx
fixIdx
typeIdx
vulIdx
sevIdx
)
type Row []string
func newRow(ss ...string) Row {
r := make(Row, 0, len(ss))
for i, s := range ss {
if i == sevIdx {
s = toSev(s)
}
r = append(r, s)
}
return r
}
func toSev(s string) string {
switch s {
case "Critical":
return Sev1
case "High":
return Sev2
case "Medium":
return Sev3
case "Low":
return Sev4
case "Negligible":
return Sev5
default:
return SevU
}
}
func (r Row) Name() string { return r[nameIdx] }
func (r Row) Version() string { return r[verIdx] }
func (r Row) Fix() string { return r[fixIdx] }
func (r Row) Type() string { return r[typeIdx] }
func (r Row) Vulnerability() string { return r[vulIdx] }
func (r Row) Severity() string { return r[sevIdx] }
func sevColor(s string) string {
switch strings.ToLower(s) {
case "critical":
return fmt.Sprintf("[red::b]%s[-::-]", s)
case "high":
return fmt.Sprintf("[orange::b]%s[-::-]", s)
case "medium":
return fmt.Sprintf("[yellow::b]%s[-::-]", s)
case "low":
return fmt.Sprintf("[blue::b]%s[-::-]", s)
default:
return fmt.Sprintf("[gray::b]%s[-::-]", s)
}
}
type table struct {
Rows []Row
}
func newTable() *table {
return &table{}
}
func (t *table) dedup() {
var (
seen = make(map[string]struct{}, len(t.Rows))
rr = make([]Row, 0, len(t.Rows))
)
for _, v := range t.Rows {
key := strings.Join(v, "|")
if _, ok := seen[key]; ok {
continue
}
rr, seen[key] = append(rr, v), struct{}{}
}
t.Rows = rr
}
func (t *table) addRow(r Row) {
t.Rows = append(t.Rows, r)
}
func (t *table) dump(w io.Writer) error {
columns := []string{"Name", "Installed", "Fixed-In", "Type", "Vulnerability", "Severity"}
ascii := tw.NewSymbols(tw.StyleASCII)
cfg := tablewriter.Config{
Behavior: tw.Behavior{TrimSpace: tw.On},
Row: tw.CellConfig{
Padding: tw.CellPadding{
Global: tw.Padding{Left: " ", Right: " "}, // 2‑space pad
},
Alignment: tw.CellAlignment{Global: tw.AlignLeft},
},
}
table := tablewriter.NewTable(
w,
tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
Borders: tw.BorderNone,
Settings: tw.Settings{
Separators: tw.SeparatorsNone,
Lines: tw.LinesNone,
},
Symbols: ascii,
})),
tablewriter.WithConfig(cfg),
)
table.Header(columns)
for _, row := range t.Rows {
err := table.Append(colorize(row))
if err != nil {
return err
}
}
return table.Render()
}
func (t *table) sort() {
t.dedup()
sort.SliceStable(t.Rows, func(i, j int) bool {
if t.Rows[i][nameIdx] != t.Rows[j][nameIdx] {
return t.Rows[i][nameIdx] < t.Rows[j][nameIdx]
}
if t.Rows[i][verIdx] != t.Rows[j][verIdx] {
return t.Rows[i][verIdx] < t.Rows[j][verIdx]
}
if t.Rows[i][typeIdx] != t.Rows[j][typeIdx] {
return t.Rows[i][typeIdx] < t.Rows[j][typeIdx]
}
if t.Rows[i][sevIdx] == t.Rows[j][sevIdx] {
return t.Rows[i][vulIdx] < t.Rows[j][vulIdx]
}
return sevToScore(t.Rows[i][sevIdx]) < sevToScore(t.Rows[j][sevIdx])
})
}
func (t *table) sortSev() {
t.dedup()
sort.SliceStable(t.Rows, func(i, j int) bool {
if s1, s2 := sevToScore(t.Rows[i][sevIdx]), sevToScore(t.Rows[j][sevIdx]); s1 != s2 {
return s1 < s2
}
if t.Rows[i][nameIdx] != t.Rows[j][nameIdx] {
return t.Rows[i][nameIdx] < t.Rows[j][nameIdx]
}
if t.Rows[i][verIdx] != t.Rows[j][verIdx] {
return t.Rows[i][verIdx] < t.Rows[j][verIdx]
}
if t.Rows[i][typeIdx] != t.Rows[j][typeIdx] {
return t.Rows[i][typeIdx] < t.Rows[j][typeIdx]
}
return t.Rows[i][vulIdx] < t.Rows[j][vulIdx]
})
}
func sevToScore(s string) int {
switch s {
case Sev1:
return 1
case Sev2:
return 2
case Sev3:
return 3
case Sev4:
return 4
case Sev5:
return 5
default:
return 6
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/types.go | internal/vul/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
const (
// Sev1 tracks Critical sev.
Sev1 = "SEV-1"
// Sev2 tracks High sev.
Sev2 = "SEV-2"
// Sev3 tracks Medium sev.
Sev3 = "SEV-3"
// Sev4 tracks Low sev.
Sev4 = "SEV-4"
// Sev5 tracks Negligible sev.
Sev5 = "SEV-5"
// SevU tracks Unknown sev.
SevU = "SEV-U"
)
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/scan.go | internal/vul/scan.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"fmt"
"io"
"strings"
"github.com/anchore/grype/grype/match"
"github.com/anchore/grype/grype/vulnerability"
)
const (
wontFix = "(won't fix)"
naValue = ""
)
// Scans tracks scans per image.
type Scans map[string]*Scan
// Dump dumps reports to writer.
func (s Scans) Dump(w io.Writer) error {
for k, v := range s {
_, _ = fmt.Fprintf(w, "Image: %s -- ", k)
v.Tally.Dump(w)
_, _ = fmt.Fprintln(w)
if err := v.Dump(w); err != nil {
return err
}
}
return nil
}
// Scan tracks image vulnerability scan.
type Scan struct {
ID string
Table *table
Tally tally
}
func newScan(img string) *Scan {
return &Scan{ID: img, Table: newTable()}
}
// Dump dump report to stdout.
func (s *Scan) Dump(w io.Writer) error {
return s.Table.dump(w)
}
func (s *Scan) run(mm *match.Matches, store vulnerability.MetadataProvider) error {
for m := range mm.Enumerate() {
meta, err := store.VulnerabilityMetadata(vulnerability.Reference{
ID: m.Vulnerability.ID,
Namespace: m.Vulnerability.Namespace,
})
if err != nil {
return err
}
var severity string
if meta != nil {
severity = meta.Severity
}
fixVersion := strings.Join(m.Vulnerability.Fix.Versions, ", ")
switch m.Vulnerability.Fix.State {
case vulnerability.FixStateWontFix:
fixVersion = wontFix
case vulnerability.FixStateUnknown:
fixVersion = naValue
}
s.Table.addRow(newRow(m.Package.Name, m.Package.Version, fixVersion, string(m.Package.Type), m.Vulnerability.ID, severity))
}
s.Table.dedup()
s.Tally = newTally(s.Table)
return nil
}
func colorize(rr []string) []string {
crr := make([]string, len(rr))
copy(crr, rr)
crr[len(crr)-1] = sevColor(crr[len(crr)-1])
return crr
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/tally_test.go | internal/vul/tally_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_newTally(t *testing.T) {
uu := map[string]struct {
t *table
tt tally
}{
"full": {
t: makeTable(t, "testdata/sort/full/sc2.text"),
tt: tally{7, 14, 8, 0, 0, 0, 29},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.tt, newTally(u.t))
})
}
}
func Test_score(t *testing.T) {
uu := map[string]struct {
tt tally
sc int
}{
"zero": {},
"critical": {
tt: tally{29, 7, 14, 8, 0, 0, 0},
sc: 292180,
},
"high": {
tt: tally{0, 17, 14, 8, 0, 0, 0},
sc: 3180,
},
"medium": {
tt: tally{0, 0, 14, 0, 0, 0, 0},
sc: 1400,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.sc, u.tt.score())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/scorer.go | internal/vul/scorer.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import "fmt"
type scorer uint8
func (b scorer) String() string {
return fmt.Sprintf("%08b", b)[:6]
}
func newScorer(t tally) scorer {
return fromTally(t)
}
func (b scorer) Add(b1 scorer) scorer {
return b | b1
}
func fromTally(t tally) scorer {
var b scorer
for i, v := range t {
if v == 0 {
continue
}
switch i {
case sevCritical:
b |= 0x80
case sevHigh:
b |= 0x40
case sevMedium:
b |= 0x20
case sevLow:
b |= 0x10
case sevNegligible:
b |= 0x08
case sevUnknown:
b |= 0x04
}
}
return b
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/scanner.go | internal/vul/scanner.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"context"
"errors"
"fmt"
"log/slog"
"sync"
"time"
"github.com/anchore/clio"
"github.com/anchore/grype/cmd/grype/cli/options"
"github.com/anchore/grype/grype"
"github.com/anchore/grype/grype/match"
"github.com/anchore/grype/grype/matcher"
"github.com/anchore/grype/grype/matcher/dotnet"
"github.com/anchore/grype/grype/matcher/golang"
"github.com/anchore/grype/grype/matcher/java"
"github.com/anchore/grype/grype/matcher/javascript"
"github.com/anchore/grype/grype/matcher/python"
"github.com/anchore/grype/grype/matcher/ruby"
"github.com/anchore/grype/grype/matcher/stock"
"github.com/anchore/grype/grype/pkg"
"github.com/anchore/grype/grype/vex"
"github.com/anchore/grype/grype/vulnerability"
"github.com/anchore/syft/syft"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/slogs"
)
var ImgScanner *imageScanner
const (
imgChanSize = 3
imgScanTimeout = 2 * time.Second
scanConcurrency = 2
)
type imageScanner struct {
provider vulnerability.Provider
status *vulnerability.ProviderStatus
opts *options.Grype
scans Scans
mx sync.RWMutex
initialized bool
config config.ImageScans
log *slog.Logger
}
// NewImageScanner returns a new instance.
func NewImageScanner(cfg config.ImageScans, l *slog.Logger) *imageScanner {
return &imageScanner{
scans: make(Scans),
config: cfg,
log: l.With(slogs.Subsys, "vul"),
}
}
func (s *imageScanner) ShouldExcludes(ns string, lbls map[string]string) bool {
return s.config.ShouldExclude(ns, lbls)
}
// GetScan fetch scan for a given image. Returns ok=false when not found.
func (s *imageScanner) GetScan(img string) (*Scan, bool) {
s.mx.RLock()
defer s.mx.RUnlock()
scan, ok := s.scans[img]
return scan, ok
}
func (s *imageScanner) setScan(img string, sc *Scan) {
s.mx.Lock()
defer s.mx.Unlock()
s.scans[img] = sc
}
// Init initializes image vulnerability database.
func (s *imageScanner) Init(name, version string) {
defer func(t time.Time) {
slog.Debug("VulDb initialization complete",
slogs.Elapsed, time.Since(t),
)
}(time.Now())
opts := options.DefaultGrype(clio.Identification{Name: name, Version: version})
opts.GenerateMissingCPEs = true
provider, status, err := grype.LoadVulnerabilityDB(
opts.ToClientConfig(),
opts.ToCuratorConfig(),
opts.DB.AutoUpdate,
)
if err != nil {
s.log.Error("VulDb load failed", slogs.Error, err)
return
}
s.mx.Lock()
s.opts, s.provider, s.status = opts, provider, status
s.mx.Unlock()
if e := validateDBLoad(err, status); e != nil {
s.log.Error("VulDb validate failed", slogs.Error, e)
return
}
s.mx.Lock()
s.initialized = true
s.mx.Unlock()
slog.Debug("VulDB initialized")
}
// Stop closes scan database.
func (s *imageScanner) Stop() {
s.mx.RLock()
defer s.mx.RUnlock()
if s.provider != nil {
_ = s.provider.Close()
s.provider = nil
}
}
func (s *imageScanner) Score(ii ...string) string {
var sc scorer
for _, i := range ii {
if scan, ok := s.GetScan(i); ok {
sc = sc.Add(newScorer(scan.Tally))
}
}
return sc.String()
}
func (s *imageScanner) IsInitialized() bool {
s.mx.RLock()
defer s.mx.RUnlock()
return s.initialized
}
func (s *imageScanner) Enqueue(ctx context.Context, images ...string) {
ctx, cancel := context.WithTimeout(ctx, imgScanTimeout)
defer cancel()
for _, img := range images {
if _, ok := s.GetScan(img); ok {
continue
}
go s.scanWorker(ctx, img)
}
}
func (s *imageScanner) scanWorker(ctx context.Context, img string) {
defer s.log.Debug("ScanWorker bailing out!")
s.log.Debug("ScanWorker processing image", slogs.Image, img)
sc := newScan(img)
s.setScan(img, sc)
if err := s.scan(ctx, img, sc); err != nil {
s.log.Warn("Scan failed for image",
slogs.Image, img,
slogs.Error, err,
)
}
}
func (s *imageScanner) scan(_ context.Context, img string, sc *Scan) error {
defer func(t time.Time) {
s.log.Debug("[Vulscan] perf",
slogs.Image, img,
slogs.Elapsed, time.Since(t),
)
}(time.Now())
packages, pkgContext, _, err := pkg.Provide(img, getProviderConfig(s.opts))
if err != nil {
return fmt.Errorf("failed to analyze image packages: %w", err)
}
processor, err := vex.NewProcessor(vex.ProcessorOptions{
Documents: s.opts.VexDocuments,
IgnoreRules: s.opts.Ignore,
})
if err != nil {
return fmt.Errorf("failed to create VEX processor: %w", err)
}
v := grype.VulnerabilityMatcher{
VulnerabilityProvider: s.provider,
IgnoreRules: s.opts.Ignore,
NormalizeByCVE: s.opts.ByCVE,
FailSeverity: s.opts.FailOnSeverity(),
Matchers: getMatchers(s.opts),
VexProcessor: processor,
}
var errs error
mm, _, err := v.FindMatches(packages, pkgContext)
if err != nil {
errs = errors.Join(errs, err)
}
if err := sc.run(mm, s.provider); err != nil {
errs = errors.Join(errs, err)
}
return errs
}
func getProviderConfig(opts *options.Grype) pkg.ProviderConfig {
return pkg.ProviderConfig{
SyftProviderConfig: pkg.SyftProviderConfig{
SBOMOptions: syft.DefaultCreateSBOMConfig(),
RegistryOptions: opts.Registry.ToOptions(),
Exclusions: opts.Exclusions,
Platform: opts.Platform,
Name: opts.Name,
DefaultImagePullSource: opts.DefaultImagePullSource,
},
SynthesisConfig: pkg.SynthesisConfig{
GenerateMissingCPEs: opts.GenerateMissingCPEs,
},
}
}
func getMatchers(opts *options.Grype) []match.Matcher {
return matcher.NewDefaultMatchers(
matcher.Config{
Java: java.MatcherConfig{
ExternalSearchConfig: opts.ExternalSources.ToJavaMatcherConfig(),
UseCPEs: opts.Match.Java.UseCPEs,
},
Ruby: ruby.MatcherConfig(opts.Match.Ruby),
Python: python.MatcherConfig(opts.Match.Python),
Dotnet: dotnet.MatcherConfig(opts.Match.Dotnet),
Javascript: javascript.MatcherConfig(opts.Match.Javascript),
Golang: golang.MatcherConfig{
UseCPEs: opts.Match.Golang.UseCPEs,
AlwaysUseCPEForStdlib: opts.Match.Golang.AlwaysUseCPEForStdlib,
AllowMainModulePseudoVersionComparison: opts.Match.Golang.AllowMainModulePseudoVersionComparison,
},
Stock: stock.MatcherConfig(opts.Match.Stock),
},
)
}
func validateDBLoad(loadErr error, status *vulnerability.ProviderStatus) error {
if loadErr != nil {
return fmt.Errorf("failed to load vulnerability db: %w", loadErr)
}
if status == nil {
return fmt.Errorf("unable to determine the status of the vulnerability db")
}
if status.Error != nil {
return fmt.Errorf("db could not be loaded: %w", status.Error)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/vul/tally.go | internal/vul/tally.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package vul
import (
"fmt"
"io"
)
const (
sevCritical = iota
sevHigh
sevMedium
sevLow
sevNegligible
sevUnknown
sevFixed
)
var vulWeights = []int{10_000, 100, 100, 10, 0, 0, 0, 0}
type tally [7]int
func newTally(t *table) tally {
var tt tally
for _, r := range t.Rows {
if r.Fix() != "" {
tt[sevFixed]++
}
switch r.Severity() {
case Sev1:
tt[sevCritical]++
case Sev2:
tt[sevHigh]++
case Sev3:
tt[sevMedium]++
case Sev4:
tt[sevLow]++
case Sev5:
tt[sevNegligible]++
case SevU:
tt[sevUnknown]++
}
}
return tt
}
// Dump dumps tally as text.
func (t tally) Dump(w io.Writer) {
_, _ = fmt.Fprintf(w, "%d critical, %d high, %d medium, %d low, %d negligible",
t[sevCritical],
t[sevHigh],
t[sevMedium],
t[sevLow],
t[sevNegligible],
)
if t[sevUnknown] > 0 {
_, _ = fmt.Fprintf(w, " (%d unknown)", t[sevUnknown])
}
if t[sevFixed] > 0 {
_, _ = fmt.Fprintf(w, " -- [Fixed: %d]", t[sevFixed])
}
}
func (t *tally) score() int {
var s int
for i, v := range t[:5] {
s += v * vulWeights[i]
}
return s
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/health/types.go | internal/health/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package health
// Level tracks health count categories.
type Level int
const (
// Unknown represents no health level.
Unknown Level = 1 << iota
// Corpus tracks total health.
Corpus
// S1 tracks series 1.
S1
// S2 tracks series 2.
S2
// S3 tracks series 3.
S3
)
// Message represents a health message.
type Message struct {
Level Level
Message string
GVR string
FQN string
}
// Messages tracks a collection of messages.
type Messages []Message
// Counts tracks health counts by category.
type Counts map[Level]int64
// Vital tracks a resource vitals.
type Vital struct {
Resource string
Total, OK, Toast int
}
// Vitals tracks a collection of resource health.
type Vitals []Vital
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/health/check.go | internal/health/check.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package health
import (
"github.com/derailed/k9s/internal/client"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
// Check tracks resource health.
type Check struct {
Counts
GVR *client.GVR
}
// Checks represents a collection of health checks.
type Checks []*Check
// NewCheck returns a new health check.
func NewCheck(gvr *client.GVR) *Check {
return &Check{
GVR: gvr,
Counts: make(Counts),
}
}
// Set sets a health metric.
func (c *Check) Set(l Level, v int64) {
c.Counts[l] = v
}
// Inc increments a health metric.
func (c *Check) Inc(l Level) {
c.Counts[l]++
}
// Total stores a metric total.
func (c *Check) Total(n int64) {
c.Counts[Corpus] = n
}
// Tally retrieves a given health metric.
func (c *Check) Tally(l Level) int64 {
return c.Counts[l]
}
// GetObjectKind returns a schema object.
func (Check) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (c Check) DeepCopyObject() runtime.Object {
return c
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/health/check_test.go | internal/health/check_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package health_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/health"
"github.com/stretchr/testify/assert"
)
func TestCheck(t *testing.T) {
var cc health.Checks
c := health.NewCheck(client.NewGVR("test"))
n := 0
for range 10 {
c.Inc(health.S1)
cc = append(cc, c)
n++
}
c.Total(int64(n))
assert.Len(t, cc, 10)
assert.Equal(t, int64(10), c.Tally(health.Corpus))
assert.Equal(t, int64(10), c.Tally(health.S1))
assert.Equal(t, int64(0), c.Tally(health.S2))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/co_portspec.go | internal/port/co_portspec.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port
import (
"strconv"
"strings"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/intstr"
)
// ContainerPortSpecs represents a container exposed ports.
type ContainerPortSpecs []ContainerPortSpec
func (c ContainerPortSpecs) Dump() string {
ss := make([]string, 0, len(c))
for _, spec := range c {
ss = append(ss, spec.String())
}
return strings.Join(ss, "\n")
}
// MatchSpec checks if given port matches a spec.
func (c ContainerPortSpecs) MatchSpec(s string) bool {
// Skip validation if No port are exposed or no container port spec.
if len(c) == 0 || !strings.Contains(s, "::") {
return true
}
for _, spec := range c {
if spec.MatchSpec(s) {
return true
}
}
return false
}
// ToTunnels convert port specs to tunnels.
func (c ContainerPortSpecs) ToTunnels(address string) PortTunnels {
tt := make(PortTunnels, 0, len(c))
for _, spec := range c {
tt = append(tt, spec.ToTunnel(address))
}
return tt
}
// Find finds a matching container port.
func (c ContainerPortSpecs) Find(pf *PFAnn) (ContainerPortSpec, bool) {
for _, spec := range c {
if spec.Match(pf) {
return spec, true
}
}
return ContainerPortSpec{}, false
}
// Match checks if container ports match a pf annotation.
func (c ContainerPortSpecs) Match(pf *PFAnn) bool {
for _, spec := range c {
if spec.Match(pf) {
return true
}
}
return false
}
func (c ContainerPortSpecs) MatchAnnotations(s string) PFAnns {
pfs, err := ParsePFs(s)
if err != nil {
return nil
}
mm := make(PFAnns, 0, len(c))
for _, pf := range pfs {
if pf.Match(c) {
mm = append(mm, pf)
}
}
return mm
}
// FromContainerPorts hydrates from a pod container specification.
func FromContainerPorts(co string, pp []v1.ContainerPort) ContainerPortSpecs {
specs := make(ContainerPortSpecs, 0, len(pp))
for _, p := range pp {
if p.Protocol != v1.ProtocolTCP {
continue
}
specs = append(specs, NewPortSpec(co, p.Name, p.ContainerPort))
}
return specs
}
// ContainerPortSpec represents a container port specification.
type ContainerPortSpec struct {
Container string
PortName string
PortNum string
}
// NewPortSpec returns a new instance.
func NewPortSpec(co, portName string, port int32) ContainerPortSpec {
return ContainerPortSpec{
Container: co,
PortName: portName,
PortNum: strconv.Itoa(int(port)),
}
}
func (c ContainerPortSpec) MatchSpec(s string) bool {
tokens := strings.Split(s, "::")
if len(tokens) < 2 {
return false
}
return tokens[0] == c.Container && tokens[1] == c.PortNum
}
func (c ContainerPortSpec) ToTunnel(address string) PortTunnel {
return PortTunnel{
Address: address,
LocalPort: c.PortNum,
ContainerPort: c.PortNum,
}
}
func (c ContainerPortSpec) Port() intstr.IntOrString {
if c.PortName != "" {
return intstr.Parse(c.PortName)
}
return intstr.Parse(c.PortNum)
}
func (c ContainerPortSpec) ToPFAnn() *PFAnn {
return &PFAnn{
Container: c.Container,
ContainerPort: c.Port(),
LocalPort: c.PortNum,
}
}
// Match checks if the container spec matches an annotation.
func (c ContainerPortSpec) Match(ann *PFAnn) bool {
if c.Container != ann.Container {
return false
}
switch ann.ContainerPort.Type {
case intstr.String:
return c.PortName == ann.ContainerPort.String()
case intstr.Int:
return c.PortNum == ann.ContainerPort.String()
default:
return false
}
}
// String dumps spec to string.
func (c ContainerPortSpec) String() string {
s := c.Container + "::" + c.PortNum
if c.PortName != "" {
s += "(" + c.PortName + ")"
}
return s
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/pfs_test.go | internal/port/pfs_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port_test
import (
"context"
"errors"
"testing"
"github.com/derailed/k9s/internal/port"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/util/intstr"
)
func TestParsePFs(t *testing.T) {
uu := map[string]struct {
spec string
pfs port.PFAnns
e error
}{
"single": {
spec: "c2::4321:1234",
pfs: port.PFAnns{
{Container: "c2", ContainerPort: intstr.Parse("1234"), LocalPort: "4321"},
},
},
"multi": {
spec: "c1::4321:1234,c2::6666:6543",
pfs: port.PFAnns{
{Container: "c1", ContainerPort: intstr.Parse("1234"), LocalPort: "4321"},
{Container: "c2", ContainerPort: intstr.Parse("6543"), LocalPort: "6666"},
},
},
"spaces": {
spec: " c1::4321:1234 , c2::6666:6543 ",
pfs: port.PFAnns{
{Container: "c1", ContainerPort: intstr.Parse("1234"), LocalPort: "4321"},
{Container: "c2", ContainerPort: intstr.Parse("6543"), LocalPort: "6666"},
},
},
"plain-multi": {
spec: "4321:1234, 6666:6543",
pfs: port.PFAnns{
{ContainerPort: intstr.Parse("1234"), LocalPort: "4321"},
{ContainerPort: intstr.Parse("6543"), LocalPort: "6666"},
},
},
"toast": {
spec: "c1::p1:1234,c2::4321",
e: errors.New("invalid port-forward specification c1::p1:1234"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pfs, err := port.ParsePFs(u.spec)
assert.Equal(t, u.e, err)
if err != nil {
return
}
assert.Equal(t, u.pfs, pfs)
})
}
}
func TestPFsToTunnel(t *testing.T) {
uu := map[string]struct {
exp string
specs port.ContainerPortSpecs
pts port.PortTunnels
e error
}{
"single": {
exp: "c2::4321:1234",
specs: port.ContainerPortSpecs{
{Container: "c2", PortName: "p1", PortNum: "1234"},
},
pts: port.PortTunnels{
{Address: "fred", Container: "c2", ContainerPort: "1234", LocalPort: "4321"},
},
},
"hosed": {
exp: "c2::p2",
specs: port.ContainerPortSpecs{
{Container: "c2", PortName: "p1", PortNum: "1234"},
},
pts: port.PortTunnels{
{Address: "fred", Container: "c2", ContainerPort: "1234", LocalPort: "4321"},
},
e: errors.New("no port number assigned"),
},
}
f := func(context.Context, port.PortTunnel) bool {
return true
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pfs, err := port.ParsePFs(u.exp)
require.NoError(t, err)
pts, err := pfs.ToTunnels("fred", u.specs, f)
assert.Equal(t, u.e, err)
if err != nil {
return
}
assert.Equal(t, u.pts, pts)
})
}
}
func TestPFsToPortSpec(t *testing.T) {
uu := map[string]struct {
exp string
spec, port string
specs port.ContainerPortSpecs
e error
}{
"single": {
exp: "c2::4321:p2/1234",
spec: "c2::1234",
port: "4321",
specs: port.ContainerPortSpecs{
{Container: "c2", PortNum: "1234"},
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pfs, err := port.ParsePFs(u.exp)
assert.Equal(t, u.e, err)
if err != nil {
return
}
spec, prt := pfs.ToPortSpec(u.specs)
assert.Equal(t, u.spec, spec)
assert.Equal(t, u.port, prt)
})
}
}
func TestToTunnels(t *testing.T) {
uu := map[string]struct {
specs, ports string
tunnels port.PortTunnels
err error
}{
"single": {
specs: "c2::4321:p2/1234",
ports: "4321",
tunnels: port.PortTunnels{
{
Address: "blee",
LocalPort: "4321",
Container: "c2",
ContainerPort: "1234",
},
},
},
"multi": {
specs: "c1::5432:2345/2345,c2::4321:p2/1234",
ports: "5432,4321",
tunnels: port.PortTunnels{
{
Address: "blee",
LocalPort: "5432",
Container: "c1",
ContainerPort: "2345",
},
{
Address: "blee",
LocalPort: "4321",
Container: "c2",
ContainerPort: "1234",
},
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
tt, err := port.ToTunnels("blee", u.specs, u.ports)
assert.Equal(t, u.err, err)
if err != nil {
return
}
assert.Equal(t, u.tunnels, tt)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/pf_test.go | internal/port/pf_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port_test
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/port"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/util/intstr"
)
func TestParsePF(t *testing.T) {
uu := map[string]struct {
exp string
container string
containerPort intstr.IntOrString
localPort string
e error
}{
"full-numbs": {
exp: "c1::4321:1234",
container: "c1",
containerPort: intstr.Parse("1234"),
localPort: "4321",
},
"full-named": {
exp: "c1::4321:p1/1234",
container: "c1",
containerPort: intstr.Parse("p1"),
localPort: "4321",
},
"just-named": {
exp: "c1::p1/1234",
container: "c1",
containerPort: intstr.Parse("p1"),
localPort: "1234",
},
"just-num": {
exp: "c1::1234",
container: "c1",
containerPort: intstr.Parse("1234"),
localPort: "1234",
},
"plain-single": {
exp: "1234",
container: "",
containerPort: intstr.Parse("1234"),
localPort: "1234",
},
"plain-full": {
exp: "4321:1234",
container: "",
containerPort: intstr.Parse("1234"),
localPort: "4321",
},
"toast": {
exp: "c1:4321:1234",
e: errors.New("invalid port-forward specification c1:4321:1234"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.exp)
assert.Equal(t, u.e, err)
if err != nil {
return
}
assert.Equal(t, u.container, pf.Container)
assert.Equal(t, u.containerPort, pf.ContainerPort)
assert.Equal(t, u.localPort, pf.LocalPort)
})
}
}
func TestPFMatch(t *testing.T) {
uu := map[string]struct {
exp string
specs port.ContainerPortSpecs
err error
e bool
}{
"match": {
exp: "c1::1234",
specs: port.ContainerPortSpecs{
{Container: "c1", PortNum: "1234"},
},
e: true,
},
"match-portnum": {
exp: "c1::4321:1234",
specs: port.ContainerPortSpecs{
{Container: "c1", PortNum: "1234"},
},
e: true,
},
"no-match": {
exp: "c1::1235",
specs: port.ContainerPortSpecs{
{Container: "c1", PortNum: "1234"},
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.exp)
assert.Equal(t, u.err, err)
if err != nil {
return
}
assert.Equal(t, u.e, pf.Match(u.specs))
})
}
}
func TestPFPortNum(t *testing.T) {
uu := map[string]struct {
exp string
err error
e string
}{
"port-name": {
exp: "c1::4321:1234",
e: "1234",
},
"port-number": {
exp: "c1::4321:1234",
e: "1234",
},
"missing-port-number": {
exp: "c1::p1",
err: errors.New("no port number assigned"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.exp)
require.NoError(t, err)
n, err := pf.PortNum()
assert.Equal(t, u.err, err)
if err != nil {
return
}
assert.Equal(t, u.e, n)
})
}
}
func TestPFToTunnel(t *testing.T) {
uu := map[string]struct {
exp string
err error
e port.PortTunnel
}{
"port-name": {
exp: "c1::p1/1234",
e: port.PortTunnel{
Address: "blee",
Container: "c1",
LocalPort: "1234",
ContainerPort: "1234",
},
},
"port-numb": {
exp: "c1::4321:1234",
e: port.PortTunnel{
Address: "blee",
Container: "c1",
LocalPort: "4321",
ContainerPort: "1234",
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.exp)
require.NoError(t, err)
pt, err := pf.ToTunnel("blee")
assert.Equal(t, u.err, err)
if err != nil {
return
}
assert.Equal(t, u.e, pt)
})
}
}
func TestPFString(t *testing.T) {
uu := map[string]struct {
exp string
err error
e string
}{
"port-name": {
exp: "c1::p1/1234",
e: "c1::1234:1234",
},
"port-numb": {
exp: "c1::4321:1234/1234",
e: "c1::4321:1234",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.exp)
require.NoError(t, err)
assert.Equal(t, u.e, pf.String())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/ann.go | internal/port/ann.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port
import (
"errors"
)
type Annotations map[string]string
func (a Annotations) PreferredPorts(specs ContainerPortSpecs) (PFAnns, error) {
if len(specs) == 0 {
return nil, errors.New("no exposed ports")
}
value, ok := a[K9sPortForwardsKey]
if !ok {
return PFAnns{specs[0].ToPFAnn()}, nil
}
return specs.MatchAnnotations(value), nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/pfs.go | internal/port/pfs.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port
import (
"context"
"fmt"
"strings"
)
// PortCheck checks if port is free on host.
type PortChecker func(context.Context, PortTunnel) bool
// PFAnns represents a collection of port forward annotations.
type PFAnns []*PFAnn
// ToPortSpec returns a container port and local port definitions.
func (aa PFAnns) ToPortSpec(pp ContainerPortSpecs) (ports, localPorts string) {
specs, lps := make([]string, 0, len(aa)), make([]string, 0, len(aa))
for _, a := range aa {
specs = append(specs, a.AsSpec())
if a.LocalPort == "" {
if spec, ok := pp.Find(a); ok {
a.LocalPort = spec.PortNum
}
}
if a.LocalPort != "" {
lps = append(lps, a.LocalPort)
}
}
return strings.Join(specs, ","), strings.Join(lps, ",")
}
func (aa PFAnns) ToTunnels(address string, _ ContainerPortSpecs, available PortChecker) (PortTunnels, error) {
pts := make(PortTunnels, 0, len(aa))
for _, a := range aa {
pt, err := a.ToTunnel(address)
if err != nil {
return pts, err
}
if !available(context.Background(), pt) {
return pts, fmt.Errorf("port %s is not available on host", pt.LocalPort)
}
pts = append(pts, pt)
}
return pts, nil
}
// ParsePFs hydrates a collection of portforward annotations.
func ParsePFs(ann string) (PFAnns, error) {
ss := strings.Split(ann, ",")
pp := make(PFAnns, 0, len(ss))
for _, s := range ss {
f, err := ParsePF(s)
if err != nil {
return nil, err
}
pp = append(pp, f)
}
return pp, nil
}
func ToTunnels(address, specs, localPorts string) (PortTunnels, error) {
pp, lps := strings.Split(specs, ","), strings.Split(localPorts, ",")
if len(pp) != len(lps) {
return nil, fmt.Errorf("spec to local port count mismatch. Expected %d but got %d", len(pp), len(lps))
}
pts := make(PortTunnels, 0, len(pp))
for i, p := range pp {
a, err := ParsePF(p)
if err != nil {
return nil, err
}
n, err := a.PortNum()
if err != nil {
return nil, err
}
pts = append(pts, PortTunnel{
Address: address,
Container: a.Container,
ContainerPort: n,
LocalPort: lps[i],
})
}
return pts, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/pf.go | internal/port/pf.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port
import (
"errors"
"fmt"
"regexp"
"strings"
"k8s.io/apimachinery/pkg/util/intstr"
)
const (
// K9sAutoPortForwardsKey represents an auto portforwards annotation.
K9sAutoPortForwardsKey = "k9scli.io/auto-port-forwards"
// K9sPortForwardsKey represents a portforwards annotation.
K9sPortForwardsKey = "k9scli.io/port-forwards"
)
var (
pfRX = regexp.MustCompile(`\A([\w-]+)::(\d*):?(\d*|[\w-]*)/?(\d+)?\z`)
pfPlainRX = regexp.MustCompile(`\A(\d*):?(\d*|[\w-]*)\z`)
)
// PFAnn represents a portforward annotation value.
// Shape: container/portname|portNum:localPort
type PFAnn struct {
Container string
ContainerPort intstr.IntOrString
LocalPort string
containerPortNum string
}
func ParsePlainPF(ann string) (*PFAnn, error) {
if ann == "" {
return nil, fmt.Errorf("invalid annotation %q", ann)
}
var pf PFAnn
mm := pfPlainRX.FindStringSubmatch(strings.TrimSpace(ann))
if len(mm) < 3 {
return nil, fmt.Errorf("invalid plain port-forward %s", ann)
}
if mm[2] == "" {
pf.ContainerPort = intstr.Parse(mm[1])
pf.LocalPort = mm[1]
return &pf, nil
}
pf.LocalPort, pf.ContainerPort = mm[1], intstr.Parse(mm[2])
return &pf, nil
}
// ParsePF hydrate a portforward annotation from string.
func ParsePF(ann string) (*PFAnn, error) {
if pf, err := ParsePlainPF(ann); err == nil {
return pf, nil
}
var pf PFAnn
if mm := pfPlainRX.FindStringSubmatch(strings.TrimSpace(ann)); len(mm) == 3 {
pf.containerPortNum = mm[0]
}
r := pfRX.FindStringSubmatch(strings.TrimSpace(ann))
if len(r) < 4 {
return &pf, fmt.Errorf("invalid port-forward specification %s", ann)
}
pf.Container = r[1]
pf.LocalPort, pf.ContainerPort = r[2], intstr.Parse(r[3])
if r[3] == "" {
pf.ContainerPort = intstr.Parse(pf.LocalPort)
}
// Testing only!
if len(r) == 5 && r[4] != "" {
pf.containerPortNum = r[4]
}
if pf.LocalPort == "" {
pf.LocalPort = pf.containerPortNum
}
return &pf, nil
}
// Match checks if annotation matches any of the container ports.
func (p *PFAnn) Match(ss ContainerPortSpecs) bool {
for _, s := range ss {
if s.Match(p) {
p.containerPortNum = s.PortNum
return true
}
}
return false
}
func (p *PFAnn) AsSpec() string {
s := p.Container + "::"
if p.containerPortNum != "" {
return s + p.containerPortNum
}
return s + p.LocalPort
}
// String dumps the annotation.
func (p *PFAnn) String() string {
return p.Container + "::" + p.LocalPort + ":" + p.containerPortNum
}
func (p *PFAnn) PortNum() (string, error) {
if p.ContainerPort.Type == intstr.Int {
return p.ContainerPort.String(), nil
}
if p.containerPortNum != "" {
return p.containerPortNum, nil
}
return "", errors.New("no port number assigned")
}
func (p *PFAnn) ToTunnel(address string) (PortTunnel, error) {
var pt PortTunnel
port, err := p.PortNum()
if err != nil {
return pt, err
}
pt.Address, pt.Container = address, p.Container
pt.ContainerPort, pt.LocalPort = port, p.LocalPort
return pt, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/tunnel.go | internal/port/tunnel.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port
import (
"context"
"fmt"
"log/slog"
"net"
"github.com/derailed/k9s/internal/slogs"
)
// PortTunnels represents a collection of tunnels.
type PortTunnels []PortTunnel
// CheckAvailable checks if all port tunnels are available.
func (t PortTunnels) CheckAvailable(ctx context.Context) error {
for _, pt := range t {
if !IsPortFree(ctx, pt) {
return fmt.Errorf("port %s is not available on host", pt.LocalPort)
}
}
return nil
}
// PortTunnel represents a host tunnel port mapper.
type PortTunnel struct {
Address, Container, LocalPort, ContainerPort string
}
// NewPortTunnel returns a new instance.
func NewPortTunnel(a, co, lp, cp string) PortTunnel {
return PortTunnel{
Address: a,
Container: co,
LocalPort: lp,
ContainerPort: cp,
}
}
// String dumps as string.
func (t PortTunnel) String() string {
return fmt.Sprintf("%s|%s|%s:%s", t.Address, t.Container, t.LocalPort, t.ContainerPort)
}
// PortMap returns a port mapping.
func (t PortTunnel) PortMap() string {
if t.LocalPort == "" {
t.LocalPort = t.ContainerPort
}
return t.LocalPort + ":" + t.ContainerPort
}
// IsPortFree checks if a address/port pair is available on host.
func IsPortFree(ctx context.Context, t PortTunnel) bool {
var ncfg net.ListenConfig
s, err := ncfg.Listen(ctx, "tcp", fmt.Sprintf("%s:%s", t.Address, t.LocalPort))
if err != nil {
slog.Warn("Port is not available", slogs.Port, t.LocalPort, slogs.Address, t.Address)
return false
}
return s.Close() == nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/tunnel_test.go | internal/port/tunnel_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port_test
import (
"testing"
"github.com/derailed/k9s/internal/port"
"github.com/stretchr/testify/assert"
)
func TestPortTunnelMap(t *testing.T) {
uu := map[string]struct {
pt port.PortTunnel
coPort, locPort string
e string
}{
"plain": {
pt: port.PortTunnel{
Address: "localhost",
LocalPort: "1234",
ContainerPort: "4321",
},
e: "1234:4321",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.pt.PortMap())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/co_portspec_test.go | internal/port/co_portspec_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port_test
import (
"testing"
"github.com/derailed/k9s/internal/port"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestContainerPortSpecMatch(t *testing.T) {
uu := map[string]struct {
ann string
spec port.ContainerPortSpec
e bool
}{
"full": {
ann: "c1::4321:1234",
spec: port.ContainerPortSpec{
Container: "c1",
PortNum: "1234",
},
e: true,
},
"no-port-name": {
ann: "c1::4321:p1/1234",
spec: port.ContainerPortSpec{
Container: "c1",
PortName: "p1",
PortNum: "1234",
},
e: true,
},
"port-name-hosed": {
ann: "c1::4321:blee/1234",
spec: port.ContainerPortSpec{
Container: "c1",
PortName: "fred",
PortNum: "1234",
},
},
"container-name-hosed": {
ann: "c2::4321:fred/1234",
spec: port.ContainerPortSpec{
Container: "c1",
PortName: "blee",
PortNum: "1234",
},
},
"port-num-hosed": {
ann: "c2::4321:1235",
spec: port.ContainerPortSpec{
Container: "c1",
PortNum: "1234",
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.ann)
require.NoError(t, err)
assert.Equal(t, u.e, u.spec.Match(pf))
})
}
}
func TestContainerPortSpecString(t *testing.T) {
uu := map[string]struct {
spec port.ContainerPortSpec
e string
}{
"full": {
spec: port.NewPortSpec("c1", "p1", 1234),
e: "c1::1234(p1)",
},
"no-name": {
spec: port.NewPortSpec("c1", "", 1234),
e: "c1::1234",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.spec.String())
})
}
}
func TestContainerPortSpecsMatch(t *testing.T) {
uu := map[string]struct {
ann string
specs port.ContainerPortSpecs
e bool
}{
"full": {
ann: "c1::4321:p1",
specs: port.ContainerPortSpecs{
port.NewPortSpec("c1", "p1", 1234),
port.NewPortSpec("c2", "p2", 1235),
},
e: true,
},
"no-name": {
ann: "c1::4321",
specs: port.ContainerPortSpecs{
port.NewPortSpec("c1", "", 4321),
port.NewPortSpec("c2", "p2", 1235),
},
e: true,
},
"name-hosed": {
ann: "c1::4321:p4",
specs: port.ContainerPortSpecs{
port.NewPortSpec("c1", "p1", 1234),
port.NewPortSpec("c2", "p2", 1235),
},
},
"numb-hosed": {
ann: "c1::4321:1235",
specs: port.ContainerPortSpecs{
port.NewPortSpec("c1", "p1", 1234),
port.NewPortSpec("c2", "p2", 1236),
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
pf, err := port.ParsePF(u.ann)
require.NoError(t, err)
assert.Equal(t, u.e, u.specs.Match(pf))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/port/ann_test.go | internal/port/ann_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package port_test
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/port"
"github.com/stretchr/testify/assert"
)
func TestPreferredPorts(t *testing.T) {
uu := map[string]struct {
anns port.Annotations
specs port.ContainerPortSpecs
err error
e string
}{
"no-ports": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c1::4321:p1",
},
err: errors.New("no exposed ports"),
},
"no-annotations": {
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
},
e: "c1::1234:p1",
},
"single-numb": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c1::4321:1234",
},
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
},
e: "c1::4321:1234/1234",
},
"single-same": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c1::1234",
},
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
},
e: "c1::1234:1234/1234",
},
"single-mismatch": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c2::4321:p1",
},
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
},
},
"multi": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c1::4321:1234,c1::5432:2345",
},
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
{Container: "c1", PortName: "p2", PortNum: "2345"},
},
e: "c1::4321:1234/1234,c1::5432:2345/2345",
},
"multi-mismatch": {
anns: port.Annotations{
port.K9sPortForwardsKey: "c1::4321:1234,c1::5432:2345",
},
specs: port.ContainerPortSpecs{
{Container: "c1", PortName: "p1", PortNum: "1234"},
{Container: "c2", PortName: "p3", PortNum: "2345"},
},
e: "c1::4321:1234/1234",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
anns, err := u.anns.PreferredPorts(u.specs)
assert.Equal(t, u.err, err)
if err != nil {
return
}
pfs, err := port.ParsePFs(u.e)
if err != nil {
pfs = port.PFAnns{}
}
assert.Equal(t, pfs, anns)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/text.go | internal/model/text.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"strings"
"github.com/derailed/k9s/internal"
"github.com/sahilm/fuzzy"
)
// Filterable represents an entity that can be filtered.
type Filterable interface {
Filter(string)
ClearFilter()
}
// Textable represents a text resource.
type Textable interface {
Peek() []string
SetText(string)
AddListener(TextListener)
RemoveListener(TextListener)
}
// TextListener represents a text model listener.
type TextListener interface {
// TextChanged notifies the model changed.
TextChanged([]string)
// TextFiltered notifies when the filter changed.
TextFiltered([]string, fuzzy.Matches)
}
// Text represents a text model.
type Text struct {
lines []string
listeners []TextListener
query string
}
// NewText returns a new model.
func NewText() *Text {
return &Text{}
}
// Peek returns the current model state.
func (t *Text) Peek() []string {
return t.lines
}
// ClearFilter clear out filter.
func (t *Text) ClearFilter() {
t.query = ""
t.filterChanged(t.lines)
}
// Filter filters out the text.
func (t *Text) Filter(q string) {
t.query = q
t.filterChanged(t.lines)
}
// SetText sets the current model content.
func (t *Text) SetText(buff string) {
t.lines = strings.Split(buff, "\n")
t.fireTextChanged(t.lines)
}
// AddListener adds a new model listener.
func (t *Text) AddListener(listener TextListener) {
t.listeners = append(t.listeners, listener)
}
// RemoveListener delete a listener from the list.
func (t *Text) RemoveListener(listener TextListener) {
victim := -1
for i, lis := range t.listeners {
if lis == listener {
victim = i
break
}
}
if victim >= 0 {
t.listeners = append(t.listeners[:victim], t.listeners[victim+1:]...)
}
}
func (t *Text) filterChanged(lines []string) {
t.fireTextFiltered(lines, t.filter(t.query, lines))
}
func (t *Text) fireTextChanged(lines []string) {
for _, lis := range t.listeners {
lis.TextChanged(lines)
}
}
func (t *Text) fireTextFiltered(lines []string, matches fuzzy.Matches) {
for _, lis := range t.listeners {
lis.TextFiltered(lines, matches)
}
}
// ----------------------------------------------------------------------------
// Helpers...
func (t *Text) filter(q string, lines []string) fuzzy.Matches {
if q == "" {
return nil
}
if f, ok := internal.IsFuzzySelector(q); ok {
return t.fuzzyFilter(strings.TrimSpace(f), lines)
}
return rxFilter(q, lines)
}
func (*Text) fuzzyFilter(q string, lines []string) fuzzy.Matches {
return fuzzy.Find(q, lines)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/history_test.go | internal/model/history_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"fmt"
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestHistoryClear(t *testing.T) {
h := model.NewHistory(3)
for i := 1; i < 5; i++ {
h.Push(fmt.Sprintf("cmd%d", i))
}
assert.Equal(t, []string{"cmd1", "cmd2", "cmd3"}, h.List())
h.Clear()
assert.True(t, h.Empty())
}
func TestHistoryPush(t *testing.T) {
h := model.NewHistory(3)
for i := 1; i < 4; i++ {
h.Push(fmt.Sprintf("cmd%d", i))
}
h.Push("cmd1")
h.Push("")
assert.Equal(t, []string{"cmd1", "cmd2", "cmd3"}, h.List())
}
func TestHistoryTop(t *testing.T) {
uu := map[string]struct {
push []string
pop int
cmd string
ok bool
}{
"empty": {},
"no-one-left": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 3,
},
"last": {
push: []string{"cmd1", "cmd2", "cmd3"},
cmd: "cmd3",
ok: true,
},
"middle": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 1,
cmd: "cmd2",
ok: true,
},
"first": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 2,
cmd: "cmd1",
ok: true,
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
h := model.NewHistory(3)
for _, cmd := range u.push {
h.Push(cmd)
}
for range u.pop {
_ = h.Pop()
}
cmd, ok := h.Top()
assert.Equal(t, u.ok, ok)
assert.Equal(t, u.cmd, cmd)
})
}
}
func TestHistoryBack(t *testing.T) {
uu := map[string]struct {
push []string
pop int
cmd string
ok bool
}{
"empty": {},
"pop-all": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 3,
},
"pop-none": {
push: []string{"cmd1", "cmd2", "cmd3"},
cmd: "cmd2",
ok: true,
},
"pop-one": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 1,
cmd: "cmd1",
ok: true,
},
"pop-to-first": {
push: []string{"cmd1", "cmd2", "cmd3"},
pop: 2,
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
h := model.NewHistory(3)
for _, cmd := range u.push {
h.Push(cmd)
}
for range u.pop {
_ = h.Pop()
}
cmd, ok := h.Back()
assert.Equal(t, u.ok, ok)
assert.Equal(t, u.cmd, cmd)
})
}
}
func TestHistoryForward(t *testing.T) {
uu := map[string]struct {
push []string
back int
cmd string
ok bool
}{
"empty": {},
"back-2": {
push: []string{"cmd1", "cmd2", "cmd3"},
back: 2,
cmd: "cmd2",
ok: true,
},
"back-1": {
push: []string{"cmd1", "cmd2", "cmd3"},
back: 1,
cmd: "cmd3",
ok: true,
},
"back-all": {
push: []string{"cmd1", "cmd2", "cmd3"},
back: 3,
cmd: "cmd2",
ok: true,
},
"back-none": {
push: []string{"cmd1", "cmd2", "cmd3"},
back: 0,
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
h := model.NewHistory(3)
for _, cmd := range u.push {
h.Push(cmd)
}
for range u.back {
_, _ = h.Back()
}
cmd, ok := h.Forward()
assert.Equal(t, u.ok, ok)
assert.Equal(t, u.cmd, cmd)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/rev_values.go | internal/model/rev_values.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"errors"
"log/slog"
"strings"
"sync/atomic"
"time"
backoff "github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/sahilm/fuzzy"
)
// RevValues tracks Helm values representations.
type RevValues struct {
gvr *client.GVR
inUpdate int32
path string
rev string
query string
lines []string
allValues bool
listeners []ResourceViewerListener
options ViewerToggleOpts
}
// NewRevValues return a new Helm values resource model.
func NewRevValues(gvr *client.GVR, path, rev string) *RevValues {
return &RevValues{
gvr: gvr,
path: path,
rev: rev,
allValues: false,
lines: getRevValues(path, rev),
}
}
func getHelmHistDao() *dao.HelmHistory {
return Registry[client.HmhGVR].DAO.(*dao.HelmHistory)
}
func getRevValues(path, _ string) []string {
vals, err := getHelmHistDao().GetValues(path, true)
if err != nil {
slog.Error("Failed to get Helm values", slogs.Error, err)
}
return strings.Split(string(vals), "\n")
}
// GVR returns the resource gvr.
func (v *RevValues) GVR() *client.GVR {
return v.gvr
}
// GetPath returns the active resource path.
func (v *RevValues) GetPath() string {
return v.path
}
// SetOptions toggle model options.
func (v *RevValues) SetOptions(ctx context.Context, opts ViewerToggleOpts) {
v.options = opts
if err := v.refresh(ctx); err != nil {
v.fireResourceFailed(err)
}
}
// Filter filters the model.
func (v *RevValues) Filter(q string) {
v.query = q
v.filterChanged(v.lines)
}
func (v *RevValues) filterChanged(lines []string) {
v.fireResourceChanged(lines, v.filter(v.query, lines))
}
func (v *RevValues) filter(q string, lines []string) fuzzy.Matches {
if q == "" {
return nil
}
if f, ok := internal.IsFuzzySelector(q); ok {
return v.fuzzyFilter(strings.TrimSpace(f), lines)
}
return rxFilter(q, lines)
}
func (*RevValues) fuzzyFilter(q string, lines []string) fuzzy.Matches {
return fuzzy.Find(q, lines)
}
func (v *RevValues) fireResourceChanged(lines []string, matches fuzzy.Matches) {
for _, l := range v.listeners {
l.ResourceChanged(lines, matches)
}
}
func (v *RevValues) fireResourceFailed(err error) {
for _, l := range v.listeners {
l.ResourceFailed(err)
}
}
// ClearFilter clear out the filter.
func (v *RevValues) ClearFilter() {
v.query = ""
}
// Peek returns the current model data.
func (v *RevValues) Peek() []string {
return v.lines
}
// Refresh updates model data.
func (v *RevValues) Refresh(ctx context.Context) error {
return v.refresh(ctx)
}
// Watch watches for Values changes.
func (v *RevValues) Watch(ctx context.Context) error {
if err := v.refresh(ctx); err != nil {
return err
}
go v.updater(ctx)
return nil
}
func (v *RevValues) updater(ctx context.Context) {
defer slog.Debug("YAML canceled", slogs.GVR, v.gvr)
backOff := NewExpBackOff(ctx, defaultReaderRefreshRate, maxReaderRetryInterval)
delay := defaultReaderRefreshRate
for {
select {
case <-ctx.Done():
return
case <-time.After(delay):
if err := v.refresh(ctx); err != nil {
v.fireResourceFailed(err)
if delay = backOff.NextBackOff(); delay == backoff.Stop {
slog.Error("Giving up retrieving chart values", slogs.Error, err)
return
}
} else {
backOff.Reset()
delay = defaultReaderRefreshRate
}
}
}
}
func (v *RevValues) refresh(context.Context) error {
if !atomic.CompareAndSwapInt32(&v.inUpdate, 0, 1) {
slog.Debug("Dropping update...")
return errors.New("refresh in progress, dropping")
}
defer atomic.StoreInt32(&v.inUpdate, 0)
v.reconcile()
return nil
}
func (v *RevValues) reconcile() {
v.fireResourceChanged(v.lines, v.filter(v.query, v.lines))
}
// AddListener adds a new model listener.
func (v *RevValues) AddListener(l ResourceViewerListener) {
v.listeners = append(v.listeners, l)
}
// RemoveListener delete a listener from the list.
func (v *RevValues) RemoveListener(l ResourceViewerListener) {
victim := -1
for i, lis := range v.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
v.listeners = append(v.listeners[:victim], v.listeners[victim+1:]...)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/tree.go | internal/model/tree.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"regexp"
"strings"
"sync/atomic"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/xray"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
const initTreeRefreshRate = 500 * time.Millisecond
// TreeListener represents a tree model listener.
type TreeListener interface {
// TreeChanged notifies the model data changed.
TreeChanged(*xray.TreeNode)
// TreeLoadFailed notifies the load failed.
TreeLoadFailed(error)
}
// Tree represents a tree model.
type Tree struct {
gvr *client.GVR
namespace string
root *xray.TreeNode
listeners []TreeListener
inUpdate int32
refreshRate time.Duration
query string
}
// NewTree returns a new model.
func NewTree(gvr *client.GVR) *Tree {
return &Tree{
gvr: gvr,
refreshRate: 2 * time.Second,
}
}
// ClearFilter clears out active filter.
func (t *Tree) ClearFilter() {
t.query = ""
}
// SetFilter sets the current filter.
func (t *Tree) SetFilter(q string) {
t.query = q
}
// AddListener adds a listener.
func (t *Tree) AddListener(l TreeListener) {
t.listeners = append(t.listeners, l)
}
// RemoveListener delete a listener.
func (t *Tree) RemoveListener(l TreeListener) {
victim := -1
for i, lis := range t.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
t.listeners = append(t.listeners[:victim], t.listeners[victim+1:]...)
}
}
// Watch initiates model updates.
func (t *Tree) Watch(ctx context.Context) {
t.Refresh(ctx)
go t.updater(ctx)
}
// Refresh update the model now.
func (t *Tree) Refresh(ctx context.Context) {
t.refresh(ctx)
}
// GetNamespace returns the model namespace.
func (t *Tree) GetNamespace() string {
return t.namespace
}
// SetNamespace sets up model namespace.
func (t *Tree) SetNamespace(ns string) {
t.namespace = ns
if t.root == nil {
return
}
t.root.Clear()
}
// SetRefreshRate sets model refresh duration.
func (t *Tree) SetRefreshRate(d time.Duration) {
t.refreshRate = d
}
// ClusterWide checks if resource is scope for all namespaces.
func (t *Tree) ClusterWide() bool {
return client.IsClusterWide(t.namespace)
}
// InNamespace checks if current namespace matches desired namespace.
func (t *Tree) InNamespace(ns string) bool {
return t.namespace == ns
}
// Empty return true if no model data.
func (t *Tree) Empty() bool {
return t.root.IsLeaf()
}
// Peek returns model data.
func (t *Tree) Peek() *xray.TreeNode {
return t.root
}
// Describe describes a given resource.
func (t *Tree) Describe(ctx context.Context, gvr *client.GVR, path string) (string, error) {
meta, err := t.getMeta(ctx, gvr)
if err != nil {
return "", err
}
desc, ok := meta.DAO.(dao.Describer)
if !ok {
return "", fmt.Errorf("no describer for %q", meta.DAO.GVR())
}
return desc.Describe(path)
}
// ToYAML returns a resource yaml.
func (t *Tree) ToYAML(ctx context.Context, gvr *client.GVR, path string) (string, error) {
meta, err := t.getMeta(ctx, gvr)
if err != nil {
return "", err
}
desc, ok := meta.DAO.(dao.Describer)
if !ok {
return "", fmt.Errorf("no describer for %q", meta.DAO.GVR())
}
return desc.ToYAML(path, false)
}
func (t *Tree) updater(ctx context.Context) {
defer slog.Debug("Tree-model canceled", slogs.GVR, t.gvr)
rate := initTreeRefreshRate
for {
select {
case <-ctx.Done():
t.root = nil
return
case <-time.After(rate):
rate = t.refreshRate
t.refresh(ctx)
}
}
}
func (t *Tree) refresh(ctx context.Context) {
if !atomic.CompareAndSwapInt32(&t.inUpdate, 0, 1) {
slog.Debug("Dropping update...")
return
}
defer atomic.StoreInt32(&t.inUpdate, 0)
if err := t.reconcile(ctx); err != nil {
slog.Error("Reconcile failed", slogs.Error, err)
t.fireTreeLoadFailed(err)
return
}
}
func (t *Tree) list(ctx context.Context, a dao.Accessor) ([]runtime.Object, error) {
factory, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return nil, fmt.Errorf("expected Factory in context but got %T", ctx.Value(internal.KeyFactory))
}
a.Init(factory, t.gvr)
return a.List(ctx, client.CleanseNamespace(t.namespace))
}
func (t *Tree) reconcile(ctx context.Context) error {
meta := t.resourceMeta()
oo, err := t.list(ctx, meta.DAO)
if err != nil {
return err
}
ns := client.CleanseNamespace(t.namespace)
root := xray.NewTreeNode(t.gvr, t.gvr.R())
ctx = context.WithValue(ctx, xray.KeyParent, root)
if _, ok := meta.TreeRenderer.(*xray.Generic); ok {
table, ok := oo[0].(*metav1.Table)
if !ok {
return fmt.Errorf("expecting a Table but got %T", oo[0])
}
if err := genericTreeHydrate(ctx, ns, table, meta.TreeRenderer); err != nil {
return err
}
} else if err := treeHydrate(ctx, ns, oo, meta.TreeRenderer); err != nil {
return err
}
root.Sort()
if t.query != "" {
t.root = root.Filter(t.query, rxMatch)
}
if t.root == nil || t.root.Diff(root) {
t.root = root
t.fireTreeChanged(t.root)
}
return nil
}
func (t *Tree) resourceMeta() ResourceMeta {
meta, ok := Registry[t.gvr]
if !ok {
meta = ResourceMeta{
DAO: &dao.Table{},
Renderer: &render.Table{},
}
}
if meta.DAO == nil {
meta.DAO = &dao.Resource{}
}
return meta
}
func (t *Tree) fireTreeChanged(root *xray.TreeNode) {
for _, l := range t.listeners {
l.TreeChanged(root)
}
}
func (t *Tree) fireTreeLoadFailed(err error) {
for _, l := range t.listeners {
l.TreeLoadFailed(err)
}
}
func (t *Tree) getMeta(ctx context.Context, gvr *client.GVR) (ResourceMeta, error) {
meta := t.resourceMeta()
factory, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return ResourceMeta{}, fmt.Errorf("expected Factory in context but got %T", ctx.Value(internal.KeyFactory))
}
meta.DAO.Init(factory, gvr)
return meta, nil
}
// ----------------------------------------------------------------------------
// Helpers...
func rxMatch(q, path string) bool {
rx := regexp.MustCompile(`(?i)` + q)
tokens := strings.Split(path, "::")
for _, t := range tokens {
if rx.MatchString(t) {
return true
}
}
return false
}
func treeHydrate(ctx context.Context, ns string, oo []runtime.Object, re TreeRenderer) error {
if re == nil {
return fmt.Errorf("no tree renderer defined for this resource")
}
pool := internal.NewWorkerPool(ctx, internal.DefaultPoolSize)
for _, o := range oo {
pool.Add(func(_ context.Context) error {
return re.Render(ctx, ns, o)
})
}
errs := pool.Drain()
if len(errs) > 0 {
return errs[0]
}
return nil
}
func genericTreeHydrate(ctx context.Context, ns string, table *metav1.Table, re TreeRenderer) error {
tre, ok := re.(*xray.Generic)
if !ok {
return fmt.Errorf("expecting xray.Generic renderer but got %T", re)
}
tre.SetTable(ns, table)
// BOZO!! Need table row sorter!!
for _, row := range table.Rows {
if err := tre.Render(ctx, ns, row); err != nil {
return err
}
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/describe.go | internal/model/describe.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"reflect"
"strings"
"sync/atomic"
"time"
backoff "github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/sahilm/fuzzy"
)
// Describe tracks describable resources.
type Describe struct {
gvr *client.GVR
inUpdate int32
path string
query string
lines []string
refreshRate time.Duration
listeners []ResourceViewerListener
decode bool
}
// NewDescribe returns a new describe resource model.
func NewDescribe(gvr *client.GVR, path string) *Describe {
return &Describe{
gvr: gvr,
path: path,
refreshRate: defaultReaderRefreshRate,
}
}
// GVR returns the resource gvr.
func (d *Describe) GVR() *client.GVR {
return d.gvr
}
// GetPath returns the active resource path.
func (d *Describe) GetPath() string {
return d.path
}
// SetOptions toggle model options.
func (*Describe) SetOptions(context.Context, ViewerToggleOpts) {}
// Filter filters the model.
func (d *Describe) Filter(q string) {
d.query = q
d.filterChanged(d.lines)
}
func (d *Describe) filterChanged(lines []string) {
d.fireResourceChanged(lines, d.filter(d.query, lines))
}
func (d *Describe) filter(q string, lines []string) fuzzy.Matches {
if q == "" {
return nil
}
if f, ok := internal.IsFuzzySelector(q); ok {
return d.fuzzyFilter(strings.TrimSpace(f), lines)
}
return rxFilter(q, lines)
}
func (*Describe) fuzzyFilter(q string, lines []string) fuzzy.Matches {
return fuzzy.Find(q, lines)
}
func (d *Describe) fireResourceChanged(lines []string, matches fuzzy.Matches) {
for _, l := range d.listeners {
l.ResourceChanged(lines, matches)
}
}
func (d *Describe) fireResourceFailed(err error) {
for _, l := range d.listeners {
l.ResourceFailed(err)
}
}
// ClearFilter clear out the filter.
func (*Describe) ClearFilter() {
}
// Peek returns current model state.
func (d *Describe) Peek() []string {
return d.lines
}
// Refresh updates model data.
func (d *Describe) Refresh(ctx context.Context) error {
return d.refresh(ctx)
}
// Watch watches for describe data changes.
func (d *Describe) Watch(ctx context.Context) error {
if err := d.refresh(ctx); err != nil {
return err
}
go d.updater(ctx)
return nil
}
func (d *Describe) updater(ctx context.Context) {
defer slog.Debug("Describe canceled", slogs.GVR, d.gvr)
backOff := NewExpBackOff(ctx, defaultReaderRefreshRate, maxReaderRetryInterval)
delay := defaultReaderRefreshRate
for {
select {
case <-ctx.Done():
return
case <-time.After(delay):
if err := d.refresh(ctx); err != nil {
d.fireResourceFailed(err)
if delay = backOff.NextBackOff(); delay == backoff.Stop {
slog.Error("Describe gave up!", slogs.Error, err)
return
}
} else {
backOff.Reset()
delay = defaultReaderRefreshRate
}
}
}
}
func (d *Describe) refresh(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&d.inUpdate, 0, 1) {
slog.Debug("Dropping update...")
return nil
}
defer atomic.StoreInt32(&d.inUpdate, 0)
if err := d.reconcile(ctx); err != nil {
slog.Error("reconcile failed",
slogs.GVR, d.gvr,
slogs.Error, err,
)
d.fireResourceFailed(err)
return err
}
return nil
}
func (d *Describe) reconcile(ctx context.Context) error {
s, err := d.describe(ctx, d.gvr, d.path)
if err != nil {
return err
}
lines := strings.Split(s, "\n")
if reflect.DeepEqual(lines, d.lines) {
return nil
}
d.lines = lines
d.fireResourceChanged(d.lines, d.filter(d.query, d.lines))
return nil
}
// Describe describes a given resource.
func (d *Describe) describe(ctx context.Context, gvr *client.GVR, path string) (string, error) {
meta, err := getMeta(ctx, gvr)
if err != nil {
return "", err
}
desc, ok := meta.DAO.(dao.Describer)
if !ok {
return "", fmt.Errorf("no describer for %q", meta.DAO.GVR())
}
if desc, ok := meta.DAO.(*dao.Secret); ok {
desc.SetDecodeData(d.decode)
}
return desc.Describe(path)
}
// AddListener adds a new model listener.
func (d *Describe) AddListener(l ResourceViewerListener) {
d.listeners = append(d.listeners, l)
}
// RemoveListener delete a listener from the list.
func (d *Describe) RemoveListener(l ResourceViewerListener) {
victim := -1
for i, lis := range d.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
d.listeners = append(d.listeners[:victim], d.listeners[victim+1:]...)
}
}
// Toggle toggles the decode flag.
func (d *Describe) Toggle() {
d.decode = !d.decode
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/flash_test.go | internal/model/flash_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"errors"
"fmt"
"testing"
"time"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestFlash(t *testing.T) {
const delay = 1 * time.Millisecond
uu := map[string]struct {
level model.FlashLevel
e string
}{
"info": {level: model.FlashInfo, e: "blee"},
"warn": {level: model.FlashWarn, e: "blee"},
"err": {level: model.FlashErr, e: "blee"},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
f := model.NewFlash(delay)
v := newFlash()
go v.listen(f.Channel())
switch u.level {
case model.FlashInfo:
f.Info(u.e)
case model.FlashWarn:
f.Warn(u.e)
case model.FlashErr:
f.Err(errors.New(u.e))
}
time.Sleep(5 * delay)
s, l, m := v.getMetrics()
assert.Equal(t, 1, s)
assert.Equal(t, u.level, l)
assert.Equal(t, u.e, m)
})
}
}
func TestFlashBurst(t *testing.T) {
const delay = 1 * time.Millisecond
f := model.NewFlash(delay)
v := newFlash()
go v.listen(f.Channel())
count := 5
for i := 1; i <= count; i++ {
f.Info(fmt.Sprintf("test-%d", i))
}
time.Sleep(5 * delay)
s, l, m := v.getMetrics()
assert.Equal(t, count, s)
assert.Equal(t, model.FlashInfo, l)
assert.Equal(t, fmt.Sprintf("test-%d", count), m)
}
type flash struct {
set, clear int
level model.FlashLevel
msg string
}
func newFlash() *flash {
return &flash{}
}
func (f *flash) getMetrics() (val int, lvl model.FlashLevel, msg string) {
return f.set, f.level, f.msg
}
func (f *flash) listen(c model.FlashChan) {
for m := range c {
if m.IsClear() {
f.clear++
} else {
f.set++
f.level, f.msg = m.Level, m.Text
}
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/menu_hint_test.go | internal/model/menu_hint_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"sort"
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestMenuHintsSort(t *testing.T) {
uu := map[string]struct {
hh model.MenuHints
e []int
}{
"mixed": {
hh: model.MenuHints{
model.MenuHint{Mnemonic: "2", Description: "Bubba"},
model.MenuHint{Mnemonic: "b", Description: "Duh"},
model.MenuHint{Mnemonic: "a", Description: "Blee"},
model.MenuHint{Mnemonic: "1", Description: "Zorg"},
},
e: []int{3, 0, 2, 1},
},
"all_strs": {
hh: model.MenuHints{
model.MenuHint{Mnemonic: "b", Description: "Bob"},
model.MenuHint{Mnemonic: "a", Description: "Abby"},
model.MenuHint{Mnemonic: "c", Description: "Chris"},
},
e: []int{1, 0, 2},
},
"all_ints": {
hh: model.MenuHints{
model.MenuHint{Mnemonic: "3", Description: "Bob"},
model.MenuHint{Mnemonic: "2", Description: "Abby"},
model.MenuHint{Mnemonic: "1", Description: "Chris"},
},
e: []int{2, 1, 0},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
o := make(model.MenuHints, len(u.hh))
copy(o, u.hh)
sort.Sort(u.hh)
for i, idx := range u.e {
assert.Equal(t, o[idx], u.hh[i])
}
})
}
}
func TestMenuHintBlank(t *testing.T) {
uu := map[string]struct {
hint model.MenuHint
e bool
}{
"yes": {hint: model.MenuHint{}, e: true},
"no": {hint: model.MenuHint{Mnemonic: "a", Description: "blee"}},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.hint.IsBlank())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/cmd_buff_test.go | internal/model/cmd_buff_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
type testListener struct {
text, suggestion string
act int
inact int
}
func (l *testListener) BufferChanged(t, s string) {
l.text, l.suggestion = t, s
}
func (l *testListener) BufferCompleted(t, s string) {
l.text, l.suggestion = t, s
}
func (l *testListener) BufferActive(s bool, _ model.BufferKind) {
if s {
l.act++
return
}
l.inact++
}
func TestCmdBuffActivate(t *testing.T) {
b, l := model.NewCmdBuff('>', model.CommandBuffer), testListener{}
b.AddListener(&l)
b.SetActive(true)
assert.Equal(t, 1, l.act)
assert.Equal(t, 0, l.inact)
assert.True(t, b.IsActive())
}
func TestCmdBuffDeactivate(t *testing.T) {
b, l := model.NewCmdBuff('>', model.CommandBuffer), testListener{}
b.AddListener(&l)
b.SetActive(false)
assert.Equal(t, 0, l.act)
assert.Equal(t, 1, l.inact)
assert.False(t, b.IsActive())
}
func TestCmdBuffChanged(t *testing.T) {
b, l := model.NewCmdBuff('>', model.CommandBuffer), testListener{}
b.AddListener(&l)
b.Add('b')
assert.Equal(t, 0, l.act)
assert.Equal(t, 0, l.inact)
assert.Equal(t, "b", l.text)
assert.Equal(t, "b", b.GetText())
b.Delete()
assert.Equal(t, 0, l.act)
assert.Equal(t, 0, l.inact)
assert.Empty(t, l.text)
assert.Empty(t, b.GetText())
b.Add('c')
b.ClearText(true)
assert.Equal(t, 0, l.act)
assert.Equal(t, 0, l.inact)
assert.Empty(t, l.text)
assert.Empty(t, b.GetText())
b.Add('c')
b.Reset()
assert.Equal(t, 0, l.act)
assert.Equal(t, 1, l.inact)
assert.Empty(t, l.text)
assert.Empty(t, b.GetText())
assert.True(t, b.Empty())
}
func TestCmdBuffAdd(t *testing.T) {
b := model.NewCmdBuff('>', model.CommandBuffer)
uu := []struct {
runes []rune
cmd string
}{
{[]rune{}, ""},
{[]rune{'a'}, "a"},
{[]rune{'a', 'b', 'c'}, "abc"},
}
for _, u := range uu {
for _, r := range u.runes {
b.Add(r)
}
assert.Equal(t, u.cmd, b.GetText())
b.Reset()
}
}
func TestCmdBuffDel(t *testing.T) {
b := model.NewCmdBuff('>', model.CommandBuffer)
uu := []struct {
runes []rune
cmd string
}{
{[]rune{}, ""},
{[]rune{'a'}, ""},
{[]rune{'a', 'b', 'c'}, "ab"},
}
for _, u := range uu {
for _, r := range u.runes {
b.Add(r)
}
b.Delete()
assert.Equal(t, u.cmd, b.GetText())
b.Reset()
}
}
func TestCmdBuffEmpty(t *testing.T) {
b := model.NewCmdBuff('>', model.CommandBuffer)
uu := []struct {
runes []rune
empty bool
}{
{[]rune{}, true},
{[]rune{'a'}, false},
{[]rune{'a', 'b', 'c'}, false},
}
for _, u := range uu {
for _, r := range u.runes {
b.Add(r)
}
assert.Equal(t, u.empty, b.Empty())
b.Reset()
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/cluster_info_test.go | internal/model/cluster_info_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"log/slog"
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestClusterMetaDelta(t *testing.T) {
uu := map[string]struct {
o, n *model.ClusterMeta
e bool
}{
"empty": {
o: model.NewClusterMeta(),
n: model.NewClusterMeta(),
},
"same": {
o: makeClusterMeta("fred"),
n: makeClusterMeta("fred"),
},
"diff": {
o: makeClusterMeta("fred"),
n: makeClusterMeta("freddie"),
e: true,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.o.Deltas(u.n))
})
}
}
// Helpers...
func makeClusterMeta(cluster string) *model.ClusterMeta {
m := model.NewClusterMeta()
m.Cluster = cluster
m.Cpu, m.Mem = 10, 20
return m
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/registry.go | internal/model/registry.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/render/helm"
"github.com/derailed/k9s/internal/xray"
)
// Registry tracks resources metadata.
// BOZO!! Break up deps and merge into single registrar.
var Registry = map[*client.GVR]ResourceMeta{
// Custom...
client.WkGVR: {
DAO: new(dao.Workload),
Renderer: new(render.Workload),
},
client.RefGVR: {
DAO: new(dao.Reference),
Renderer: new(render.Reference),
},
client.DirGVR: {
DAO: new(dao.Dir),
Renderer: new(render.Dir),
},
client.PuGVR: {
DAO: new(dao.Pulse),
},
client.HmGVR: {
DAO: new(dao.HelmChart),
Renderer: new(helm.Chart),
},
client.HmhGVR: {
DAO: new(dao.HelmHistory),
Renderer: new(helm.History),
},
client.CoGVR: {
DAO: new(dao.Container),
Renderer: new(render.Container),
TreeRenderer: new(xray.Container),
},
client.ScnGVR: {
DAO: new(dao.ImageScan),
Renderer: new(render.ImageScan),
},
client.CtGVR: {
DAO: new(dao.Context),
Renderer: new(render.Context),
},
client.SdGVR: {
DAO: new(dao.ScreenDump),
Renderer: new(render.ScreenDump),
},
client.RbacGVR: {
DAO: new(dao.Rbac),
Renderer: new(render.Rbac),
},
client.PolGVR: {
DAO: new(dao.Policy),
Renderer: new(render.Policy),
},
client.UsrGVR: {
DAO: new(dao.Subject),
Renderer: new(render.Subject),
},
client.GrpGVR: {
DAO: new(dao.Subject),
Renderer: new(render.Subject),
},
client.PfGVR: {
DAO: new(dao.PortForward),
Renderer: new(render.PortForward),
},
client.BeGVR: {
DAO: new(dao.Benchmark),
Renderer: new(render.Benchmark),
},
client.AliGVR: {
DAO: new(dao.Alias),
Renderer: new(render.Alias),
},
// Discovery...
client.EpsGVR: {
Renderer: new(render.EndpointSlice),
},
// Core...
client.EpGVR: {
Renderer: new(render.Endpoints),
},
client.PodGVR: {
DAO: new(dao.Pod),
Renderer: render.NewPod(),
TreeRenderer: new(xray.Pod),
},
client.NsGVR: {
DAO: new(dao.Namespace),
Renderer: new(render.Namespace),
},
client.SecGVR: {
DAO: new(dao.Secret),
Renderer: new(render.Secret),
},
client.CmGVR: {
DAO: new(dao.ConfigMap),
Renderer: new(render.ConfigMap),
},
client.NodeGVR: {
DAO: new(dao.Node),
Renderer: new(render.Node),
},
client.SvcGVR: {
DAO: new(dao.Service),
Renderer: new(render.Service),
TreeRenderer: new(xray.Service),
},
client.SaGVR: {
Renderer: new(render.ServiceAccount),
},
client.PvGVR: {
Renderer: new(render.PersistentVolume),
},
client.PvcGVR: {
Renderer: new(render.PersistentVolumeClaim),
},
client.EvGVR: {
DAO: new(dao.Table),
Renderer: new(render.Event),
},
// Apps...
client.DpGVR: {
DAO: new(dao.Deployment),
Renderer: new(render.Deployment),
TreeRenderer: new(xray.Deployment),
},
client.RsGVR: {
Renderer: new(render.ReplicaSet),
TreeRenderer: new(xray.ReplicaSet),
},
client.StsGVR: {
DAO: new(dao.StatefulSet),
Renderer: new(render.StatefulSet),
TreeRenderer: new(xray.StatefulSet),
},
client.DsGVR: {
DAO: new(dao.DaemonSet),
Renderer: new(render.DaemonSet),
TreeRenderer: new(xray.DaemonSet),
},
// Extensions...
client.NpGVR: {
Renderer: &render.NetworkPolicy{},
},
// Batch...
client.CjGVR: {
DAO: new(dao.CronJob),
Renderer: new(render.CronJob),
},
client.JobGVR: {
DAO: new(dao.Job),
Renderer: new(render.Job),
},
// CRDs...
client.CrdGVR: {
DAO: new(dao.CustomResourceDefinition),
Renderer: new(render.CustomResourceDefinition),
},
// Storage...
client.ScGVR: {
Renderer: &render.StorageClass{},
},
// Policy...
client.PdbGVR: {
Renderer: &render.PodDisruptionBudget{},
},
// RBAC...
client.CrGVR: {
DAO: new(dao.Rbac),
Renderer: new(render.ClusterRole),
},
client.CrbGVR: {
Renderer: new(render.ClusterRoleBinding),
},
client.RoGVR: {
Renderer: new(render.Role),
},
client.RobGVR: {
Renderer: new(render.RoleBinding),
},
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.