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/view/ds.go | internal/view/ds.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
appsv1 "k8s.io/api/apps/v1"
)
// DaemonSet represents a daemon set custom viewer.
type DaemonSet struct {
ResourceViewer
}
// NewDaemonSet returns a new viewer.
func NewDaemonSet(gvr *client.GVR) ResourceViewer {
var d DaemonSet
d.ResourceViewer = NewPortForwardExtender(
NewVulnerabilityExtender(
NewRestartExtender(
NewImageExtender(
NewOwnerExtender(
NewLogsExtender(NewBrowser(gvr), d.logOptions),
),
),
),
),
)
d.AddBindKeysFn(d.bindKeys)
d.GetTable().SetEnterFn(d.showPods)
return &d
}
func (d *DaemonSet) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyShiftD: ui.NewKeyAction("Sort Desired", d.GetTable().SortColCmd("DESIRED", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort Current", d.GetTable().SortColCmd("CURRENT", true), false),
ui.KeyShiftR: ui.NewKeyAction("Sort Ready", d.GetTable().SortColCmd(readyCol, true), false),
ui.KeyShiftU: ui.NewKeyAction("Sort UpToDate", d.GetTable().SortColCmd(uptodateCol, true), false),
ui.KeyShiftL: ui.NewKeyAction("Sort Available", d.GetTable().SortColCmd(availCol, true), false),
})
}
func (d *DaemonSet) showPods(app *App, _ ui.Tabular, _ *client.GVR, path string) {
var res dao.DaemonSet
res.Init(app.factory, d.GVR())
ds, err := res.GetInstance(path)
if err != nil {
d.App().Flash().Err(err)
return
}
showPodsFromSelector(app, path, ds.Spec.Selector)
}
func (d *DaemonSet) logOptions(prev bool) (*dao.LogOptions, error) {
path := d.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("you must provide a selection")
}
ds, err := d.getInstance(path)
if err != nil {
return nil, err
}
return podLogOptions(d.App(), path, prev, &ds.ObjectMeta, &ds.Spec.Template.Spec), nil
}
func (d *DaemonSet) getInstance(fqn string) (*appsv1.DaemonSet, error) {
var ds dao.DaemonSet
ds.Init(d.App().factory, client.DsGVR)
return ds.GetInstance(fqn)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/helpers_test.go | internal/view/helpers_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"log/slog"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/mock"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/tcell/v2"
"github.com/sahilm/fuzzy"
"github.com/stretchr/testify/assert"
"k8s.io/cli-runtime/pkg/genericclioptions"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestParsePFAnn(t *testing.T) {
uu := map[string]struct {
ann, co, port string
ok bool
}{
"named-port": {
ann: "c1:blee",
co: "c1",
port: "blee",
ok: true,
},
"port-num": {
ann: "c1:1234",
co: "c1",
port: "1234",
ok: true,
},
"toast": {
ann: "zorg",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
co, port, ok := parsePFAnn(u.ann)
if u.ok {
assert.Equal(t, u.co, co)
assert.Equal(t, u.port, port)
assert.Equal(t, u.ok, ok)
}
})
}
}
func TestExtractApp(t *testing.T) {
app := NewApp(mock.NewMockConfig(t))
uu := map[string]struct {
app *App
err error
}{
"cool": {app: app},
"not-cool": {err: errors.New("no application found in context")},
}
for k := range uu {
u := uu[k]
ctx := context.Background()
if u.app != nil {
ctx = context.WithValue(ctx, internal.KeyApp, u.app)
}
t.Run(k, func(t *testing.T) {
app, err := extractApp(ctx)
assert.Equal(t, u.err, err)
if err == nil {
assert.Equal(t, u.app, app)
}
})
}
}
func TestFwFQN(t *testing.T) {
uu := map[string]struct {
po, co, e string
}{
"cool": {po: "p1", co: "c1", e: "p1|c1"},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, fwFQN(u.po, u.co))
})
}
}
func TestAsKey(t *testing.T) {
uu := map[string]struct {
k string
err error
e tcell.Key
}{
"cool": {k: "Ctrl-A", e: tcell.KeyCtrlA},
"miss": {k: "fred", e: 0, err: errors.New(`invalid key specified: "fred"`)},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
key, err := asKey(u.k)
assert.Equal(t, u.err, err)
assert.Equal(t, u.e, key)
})
}
}
func TestK8sEnv(t *testing.T) {
cl, ctx, cfg, u := "cluster1", "context1", "cfg1", "user1"
flags := genericclioptions.ConfigFlags{
ClusterName: &cl,
Context: &ctx,
AuthInfoName: &u,
KubeConfig: &cfg,
}
c := client.NewConfig(&flags)
env := k8sEnv(c)
assert.Len(t, env, 5)
assert.Equal(t, cl, env["CLUSTER"])
assert.Equal(t, ctx, env["CONTEXT"])
assert.Equal(t, u, env["USER"])
assert.Equal(t, render.NAValue, env["GROUPS"])
assert.Equal(t, cfg, env["KUBECONFIG"])
}
func TestK9sEnv(t *testing.T) {
cl, ctx, cfg, u := "cluster1", "context1", "cfg1", "user1"
flags := genericclioptions.ConfigFlags{
ClusterName: &cl,
Context: &ctx,
AuthInfoName: &u,
KubeConfig: &cfg,
}
c := client.NewConfig(&flags)
h := model1.Header{
{Name: "A"},
{Name: "B"},
{Name: "C"},
}
r := model1.Row{
Fields: []string{"a1", "b1", "c1"},
}
env := defaultEnv(c, "fred/blee", h, &r)
assert.Len(t, env, 10)
assert.Equal(t, cl, env["CLUSTER"])
assert.Equal(t, ctx, env["CONTEXT"])
assert.Equal(t, u, env["USER"])
assert.Equal(t, render.NAValue, env["GROUPS"])
assert.Equal(t, cfg, env["KUBECONFIG"])
assert.Equal(t, "fred", env["NAMESPACE"])
assert.Equal(t, "blee", env["NAME"])
assert.Equal(t, "a1", env["COL-A"])
assert.Equal(t, "b1", env["COL-B"])
assert.Equal(t, "c1", env["COL-C"])
}
func TestIsTCPPort(t *testing.T) {
uu := map[string]struct {
p string
e bool
}{
"tcp": {"80╱TCP", true},
"udp": {"80╱UDP", false},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, isTCPPort(u.p))
})
}
}
func TestFQN(t *testing.T) {
uu := map[string]struct {
ns, n, e string
}{
"fullFQN": {"blee", "fred", "blee/fred"},
"allNS": {"", "fred", "fred"},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, fqn(u.ns, u.n))
})
}
}
func TestUrlFor(t *testing.T) {
uu := map[string]struct {
cfg config.BenchConfig
co, port string
e string
}{
"empty": {
config.BenchConfig{}, "c1", "9000", "http://localhost:9000/",
},
"path": {
config.BenchConfig{
HTTP: config.HTTP{
Path: "/fred/blee",
},
},
"c1",
"9000",
"http://localhost:9000/fred/blee",
},
"host/path": {
config.BenchConfig{
HTTP: config.HTTP{
Host: "zorg",
Path: "/fred/blee",
},
},
"c1",
"9000",
"http://zorg:9000/fred/blee",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, urlFor(&u.cfg, u.port))
})
}
}
func TestContainerID(t *testing.T) {
uu := map[string]struct {
path, co string
e string
}{
"plain": {
"fred/blee", "c1", "fred/blee:c1",
},
"podID": {
"fred/blee-78f8b5d78c-f8588", "c1", "fred/blee:c1",
},
"stsID": {
"fred/blee-1", "c1", "fred/blee:c1",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, containerID(u.path, u.co))
})
}
}
func Test_linesWithRegions(t *testing.T) {
uu := map[string]struct {
lines []string
matches fuzzy.Matches
e []string
}{
"empty-lines": {
e: []string{},
},
"no-match": {
lines: []string{"bar"},
e: []string{"bar"},
},
"single-match": {
lines: []string{"foo", "bar", "baz"},
matches: fuzzy.Matches{
{Index: 1, MatchedIndexes: []int{0, 1, 2}},
},
e: []string{"foo", matchTag(0, "bar"), "baz"},
},
"single-character": {
lines: []string{"foo", "bar", "baz"},
matches: fuzzy.Matches{
{Index: 1, MatchedIndexes: []int{1}},
},
e: []string{"foo", "b" + matchTag(0, "a") + "r", "baz"},
},
"multiple-matches": {
lines: []string{"foo", "bar", "baz"},
matches: fuzzy.Matches{
{Index: 1, MatchedIndexes: []int{0, 1, 2}},
{Index: 2, MatchedIndexes: []int{0, 1, 2}},
},
e: []string{"foo", matchTag(0, "bar"), matchTag(1, "baz")},
},
"multiple-matches-same-line": {
lines: []string{"foosfoo baz", "dfbarfoos bar"},
matches: fuzzy.Matches{
{Index: 0, MatchedIndexes: []int{0, 1, 2}},
{Index: 0, MatchedIndexes: []int{4, 5, 6}},
{Index: 1, MatchedIndexes: []int{5, 6, 7}},
},
e: []string{
matchTag(0, "foo") + "s" + matchTag(1, "foo") + " baz",
"dfbar" + matchTag(2, "foo") + "s bar",
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
t.Parallel()
assert.Equal(t, u.e, linesWithRegions(u.lines, u.matches))
})
}
}
func Test_sanitizeEsc(t *testing.T) {
uu := map[string]struct {
s string
e string
}{
"empty": {},
"empty-brackets": {
s: "[]",
e: "[]",
},
"tag": {
s: "[fred[]",
e: "[fred]",
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, sanitizeEsc(u.s))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/ns.go | internal/view/ns.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"k8s.io/apimachinery/pkg/util/sets"
)
const (
favNSIndicator = "+"
defaultNSIndicator = "(*)"
)
// Namespace represents a namespace viewer.
type Namespace struct {
ResourceViewer
}
// NewNamespace returns a new viewer.
func NewNamespace(gvr *client.GVR) ResourceViewer {
n := Namespace{
ResourceViewer: NewBrowser(gvr),
}
n.GetTable().SetDecorateFn(n.decorate)
n.GetTable().SetEnterFn(n.switchNs)
n.AddBindKeysFn(n.bindKeys)
return &n
}
func (n *Namespace) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyU: ui.NewKeyAction("Use", n.useNsCmd, true),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", n.GetTable().SortColCmd(statusCol, true), false),
})
}
func (n *Namespace) switchNs(app *App, _ ui.Tabular, _ *client.GVR, path string) {
n.useNamespace(path)
_, ns := client.Namespaced(path)
app.gotoResource(client.PodGVR.String()+" "+ns, "", false, true)
}
func (n *Namespace) useNsCmd(*tcell.EventKey) *tcell.EventKey {
path := n.GetTable().GetSelectedItem()
if path == "" {
return nil
}
n.useNamespace(path)
return nil
}
func (n *Namespace) useNamespace(fqn string) {
_, ns := client.Namespaced(fqn)
if client.CleanseNamespace(n.App().Config.ActiveNamespace()) == ns {
return
}
if err := n.App().switchNS(ns); err != nil {
n.App().Flash().Err(err)
return
}
if err := n.App().Config.SetActiveNamespace(ns); err != nil {
n.App().Flash().Err(err)
return
}
}
func (n *Namespace) decorate(td *model1.TableData) {
if n.App().Conn() == nil || td.RowCount() == 0 {
return
}
// checks if all ns is in the list if not add it.
if _, ok := td.FindRow(client.NamespaceAll); !ok {
td.AddRow(model1.RowEvent{
Kind: model1.EventUnchanged,
Row: model1.Row{
ID: client.NamespaceAll,
Fields: model1.Fields{client.NamespaceAll, "Active", "", "", ""},
},
},
)
}
var (
favs = sets.New(n.App().Config.FavNamespaces()...)
activeNS = n.App().Config.ActiveNamespace()
)
td.RowsRange(func(i int, re model1.RowEvent) bool {
_, n := client.Namespaced(re.Row.ID)
if favs.Has(n) {
re.Row.Fields[0] += favNSIndicator
}
if n == activeNS {
re.Row.Fields[0] += defaultNSIndicator
}
re.Kind = model1.EventUnchanged
td.SetRow(i, re)
return true
})
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pf.go | internal/view/pf.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"regexp"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/perf"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
)
// PortForward presents active portforward viewer.
type PortForward struct {
ResourceViewer
bench *perf.Benchmark
}
// NewPortForward returns a new viewer.
func NewPortForward(gvr *client.GVR) ResourceViewer {
p := PortForward{
ResourceViewer: NewBrowser(gvr),
}
p.GetTable().SetBorderFocusColor(tcell.ColorDodgerBlue)
p.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorDodgerBlue).Attributes(tcell.AttrNone))
p.GetTable().SetSortCol(ageCol, true)
p.SetContextFn(p.portForwardContext)
p.AddBindKeysFn(p.bindKeys)
return &p
}
func (p *PortForward) portForwardContext(ctx context.Context) context.Context {
if bc := p.App().BenchFile; bc != "" {
return context.WithValue(ctx, internal.KeyBenchCfg, p.App().BenchFile)
}
return ctx
}
func (p *PortForward) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("View Benchmarks", p.showBenchCmd, true),
ui.KeyB: ui.NewKeyAction("Benchmark Run/Stop", p.toggleBenchCmd, true),
tcell.KeyCtrlD: ui.NewKeyAction("Delete", p.deleteCmd, true),
ui.KeyShiftP: ui.NewKeyAction("Sort Ports", p.GetTable().SortColCmd("PORTS", true), false),
ui.KeyShiftU: ui.NewKeyAction("Sort URL", p.GetTable().SortColCmd("URL", true), false),
})
}
func (p *PortForward) showBenchCmd(*tcell.EventKey) *tcell.EventKey {
b := NewBenchmark(client.BeGVR)
b.SetContextFn(p.getContext)
if err := p.App().inject(b, false); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *PortForward) getContext(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyDir, benchDir(p.App().Config))
path := p.GetTable().GetSelectedItem()
if path == "" {
return ctx
}
return context.WithValue(ctx, internal.KeyPath, path)
}
func (p *PortForward) toggleBenchCmd(*tcell.EventKey) *tcell.EventKey {
if p.bench != nil {
p.App().Status(model.FlashErr, "Benchmark Canceled!")
p.bench.Cancel()
p.App().ClearStatus(true)
return nil
}
path := p.GetTable().GetSelectedItem()
if path == "" {
return nil
}
cfg := dao.BenchConfigFor(p.App().BenchFile, path)
cfg.Name = path
r, _ := p.GetTable().GetSelection()
slog.Debug("Port forward namespace", slogs.Namespace, p.GetTable().GetModel().GetNamespace())
col := 3
if client.IsAllNamespaces(p.GetTable().GetModel().GetNamespace()) {
col = 4
}
base := ui.TrimCell(p.GetTable().SelectTable, r, col)
var err error
p.bench, err = perf.NewBenchmark(base, p.App().version, &cfg)
if err != nil {
p.App().Flash().Errf("Bench failed %v", err)
p.App().ClearStatus(false)
return nil
}
p.App().Status(model.FlashWarn, "Benchmark in progress...")
go func() {
if err := p.runBenchmark(); err != nil {
slog.Error("Benchmark run failed", slogs.Error, err)
}
}()
return nil
}
func (p *PortForward) runBenchmark() error {
slog.Debug("Bench starting...")
ct, err := p.App().Config.K9s.ActiveContext()
if err != nil {
return err
}
name := p.App().Config.K9s.ActiveContextName()
p.bench.Run(ct.ClusterName, name, func() {
slog.Debug("Benchmark Completed!", slogs.Name, name)
p.App().QueueUpdate(func() {
if p.bench.Canceled() {
p.App().Status(model.FlashInfo, "Benchmark canceled")
} else {
p.App().Status(model.FlashInfo, "Benchmark Completed!")
p.bench.Cancel()
}
p.bench = nil
go func() {
<-time.After(2 * time.Second)
p.App().QueueUpdate(func() { p.App().ClearStatus(true) })
}()
})
})
return nil
}
func (p *PortForward) deleteCmd(evt *tcell.EventKey) *tcell.EventKey {
if !p.GetTable().CmdBuff().Empty() {
p.GetTable().CmdBuff().Reset()
return nil
}
selections := p.GetTable().GetSelectedItems()
if len(selections) == 0 {
return evt
}
p.Stop()
defer p.Start()
var msg string
if len(selections) > 1 {
msg = fmt.Sprintf("Delete %d marked %s?", len(selections), p.GVR())
} else if h, err := pfToHuman(selections[0]); err == nil {
msg = fmt.Sprintf("Delete %s %s?", p.GVR().R(), h)
} else {
p.App().Flash().Err(err)
return nil
}
d := p.App().Styles.Dialog()
dialog.ShowConfirm(&d, p.App().Content.Pages, "Delete", msg, func() {
for _, s := range selections {
var pf dao.PortForward
pf.Init(p.App().factory, client.PfGVR)
if err := pf.Delete(context.Background(), s, nil, dao.DefaultGrace); err != nil {
p.App().Flash().Err(err)
return
}
}
p.App().Flash().Infof("Successfully deleted %d PortForward!", len(selections))
p.GetTable().Refresh()
}, func() {})
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
var selRx = regexp.MustCompile(`\A([\w-]+)/([\w-]+)\|([\w-]+)?\|(\d+):(\d+)`)
func pfToHuman(s string) (string, error) {
mm := selRx.FindStringSubmatch(s)
if len(mm) < 6 {
return "", fmt.Errorf("unable to parse selection %s", s)
}
return fmt.Sprintf("%s::%s %s->%s", mm[2], mm[3], mm[4], mm[5]), nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/log.go | internal/view/log.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"io"
"log/slog"
"os"
"path/filepath"
"strings"
"sync"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/color"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"k8s.io/apimachinery/pkg/labels"
)
const (
logTitle = "logs"
logMessage = "Waiting for logs...\n"
logFmt = "([hilite:bg:]%s[-:bg:-])[[green:bg:b]%s[-:bg:-]] "
logCoFmt = "([hilite:bg:]%s:[hilite:bg:b]%s[-:bg:-])[[green:bg:b]%s[-:bg:-]] "
defaultFlushTimeout = 50 * time.Millisecond
)
// Log represents a generic log viewer.
type Log struct {
*tview.Flex
app *App
logs *Logger
indicator *LogIndicator
ansiWriter io.Writer
model *model.Log
cancelFn context.CancelFunc
cancelUpdates bool
mx sync.Mutex
follow bool
columnLock bool
requestOneRefresh bool
}
var _ model.Component = (*Log)(nil)
// NewLog returns a new viewer.
func NewLog(gvr *client.GVR, opts *dao.LogOptions) *Log {
return &Log{
Flex: tview.NewFlex(),
model: model.NewLog(gvr, opts, defaultFlushTimeout),
}
}
func (*Log) SetCommand(*cmd.Interpreter) {}
func (*Log) SetFilter(string, bool) {}
func (*Log) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the viewer.
func (l *Log) Init(ctx context.Context) (err error) {
if l.app, err = extractApp(ctx); err != nil {
return err
}
l.model.Configure(l.app.Config.K9s.Logger)
l.SetBorder(true)
l.SetDirection(tview.FlexRow)
l.indicator = NewLogIndicator(l.app.Config, l.app.Styles, l.isContainerLogView())
l.AddItem(l.indicator, 1, 1, false)
if !l.model.HasDefaultContainer() {
l.indicator.ToggleAllContainers()
}
l.indicator.Refresh()
l.logs = NewLogger(l.app)
if e := l.logs.Init(ctx); e != nil {
return e
}
l.logs.SetBorderPadding(0, 0, 1, 1)
l.logs.SetText("[orange::d]" + logMessage)
l.logs.SetWrap(l.app.Config.K9s.Logger.TextWrap)
l.logs.SetMaxLines(l.app.Config.K9s.Logger.BufferSize)
l.ansiWriter = tview.ANSIWriter(l.logs, l.app.Styles.Views().Log.FgColor.String(), l.app.Styles.Views().Log.BgColor.String())
l.AddItem(l.logs, 0, 1, true)
l.bindKeys()
l.StylesChanged(l.app.Styles)
l.toggleFullScreen()
l.model.Init(l.app.factory)
l.updateTitle()
l.follow = !l.app.Config.K9s.Logger.DisableAutoscroll
l.columnLock = l.app.Config.K9s.Logger.ColumnLock
l.model.ToggleShowTimestamp(l.app.Config.K9s.Logger.ShowTime)
return nil
}
// InCmdMode checks if prompt is active.
func (l *Log) InCmdMode() bool {
return l.logs.cmdBuff.InCmdMode()
}
// LogCanceled indicates no more logs are coming.
func (l *Log) LogCanceled() {
slog.Debug("Logs watcher canceled!")
l.Flush([][]byte{[]byte("\n🏁 [red::b]Stream exited! No more logs...")})
}
// LogStop disables log flushes.
func (l *Log) LogStop() {
slog.Debug("Logs watcher stopped!")
l.mx.Lock()
defer l.mx.Unlock()
l.cancelUpdates = true
}
// LogResume resume log flushes.
func (l *Log) LogResume() {
l.mx.Lock()
defer l.mx.Unlock()
l.cancelUpdates = false
}
// LogCleared clears the logs.
func (l *Log) LogCleared() {
l.app.QueueUpdateDraw(func() {
l.logs.Clear()
})
}
// LogFailed notifies an error occurred.
func (l *Log) LogFailed(err error) {
l.app.QueueUpdateDraw(func() {
l.app.Flash().Err(err)
if l.logs.GetText(true) == logMessage {
l.logs.Clear()
}
if _, err = l.ansiWriter.Write([]byte(tview.Escape(color.Colorize(err.Error(), color.Red)))); err != nil {
slog.Error("Log line write failed", slogs.Error, err)
}
})
}
// LogChanged updates the logs.
func (l *Log) LogChanged(lines [][]byte) {
l.app.QueueUpdateDraw(func() {
if l.logs.GetText(true) == logMessage {
l.logs.Clear()
}
l.Flush(lines)
})
}
// BufferCompleted indicates input was accepted.
func (l *Log) BufferCompleted(text, _ string) {
l.model.Filter(text)
l.updateTitle()
}
// BufferChanged indicates the buffer was changed.
func (*Log) BufferChanged(_, _ string) {}
// BufferActive indicates the buff activity changed.
func (l *Log) BufferActive(state bool, k model.BufferKind) {
l.app.BufferActive(state, k)
}
// StylesChanged reports skin changes.
func (l *Log) StylesChanged(s *config.Styles) {
l.SetBackgroundColor(s.Views().Log.BgColor.Color())
l.logs.SetTextColor(s.Views().Log.FgColor.Color())
l.logs.SetBackgroundColor(s.Views().Log.BgColor.Color())
}
// GetModel returns the log model.
func (l *Log) GetModel() *model.Log {
return l.model
}
// Hints returns a collection of menu hints.
func (l *Log) Hints() model.MenuHints {
return l.logs.Actions().Hints()
}
// ExtraHints returns additional hints.
func (*Log) ExtraHints() map[string]string {
return nil
}
func (l *Log) cancel() {
l.mx.Lock()
defer l.mx.Unlock()
if l.cancelFn != nil {
l.cancelFn()
l.cancelFn = nil
}
}
func (l *Log) getContext() context.Context {
l.cancel()
ctx := context.Background()
ctx, l.cancelFn = context.WithCancel(ctx)
return ctx
}
// Start runs the component.
func (l *Log) Start() {
l.model.Start(l.getContext())
l.model.AddListener(l)
l.app.Styles.AddListener(l)
l.logs.cmdBuff.AddListener(l)
l.logs.cmdBuff.AddListener(l.app.Prompt())
l.updateTitle()
}
// Stop terminates the component.
func (l *Log) Stop() {
l.model.RemoveListener(l)
l.model.Stop()
l.cancel()
l.app.Styles.RemoveListener(l)
l.logs.cmdBuff.RemoveListener(l)
l.logs.cmdBuff.RemoveListener(l.app.Prompt())
}
// Name returns the component name.
func (*Log) Name() string { return logTitle }
func (l *Log) bindKeys() {
l.logs.Actions().Bulk(ui.KeyMap{
ui.Key0: ui.NewKeyAction("tail", l.sinceCmd(-1), true),
ui.Key1: ui.NewKeyAction("head", l.sinceCmd(0), true),
ui.Key2: ui.NewKeyAction("1m", l.sinceCmd(60), true),
ui.Key3: ui.NewKeyAction("5m", l.sinceCmd(5*60), true),
ui.Key4: ui.NewKeyAction("15m", l.sinceCmd(15*60), true),
ui.Key5: ui.NewKeyAction("30m", l.sinceCmd(30*60), true),
ui.Key6: ui.NewKeyAction("1h", l.sinceCmd(60*60), true),
tcell.KeyEnter: ui.NewSharedKeyAction("Filter", l.filterCmd, false),
tcell.KeyEscape: ui.NewKeyAction("Back", l.resetCmd, false),
ui.KeyQ: ui.NewKeyAction("Back", l.resetCmd, false),
ui.KeyShiftC: ui.NewKeyAction("Clear", l.clearCmd, true),
ui.KeyM: ui.NewKeyAction("Mark", l.markCmd, true),
ui.KeyS: ui.NewKeyAction("Toggle AutoScroll", l.toggleAutoScrollCmd, true),
ui.KeyShiftL: ui.NewKeyAction("Toggle ColumnLock", l.toggleColumnLockCmd, true),
ui.KeyF: ui.NewKeyAction("Toggle FullScreen", l.toggleFullScreenCmd, true),
ui.KeyT: ui.NewKeyAction("Toggle Timestamp", l.toggleTimestampCmd, true),
ui.KeyW: ui.NewKeyAction("Toggle Wrap", l.toggleTextWrapCmd, true),
tcell.KeyCtrlS: ui.NewKeyAction("Save", l.SaveCmd, true),
ui.KeyC: ui.NewKeyAction("Copy", cpCmd(l.app.Flash(), l.logs.TextView), true),
})
if l.model.HasDefaultContainer() {
l.logs.Actions().Add(ui.KeyA, ui.NewKeyAction("Toggle AllContainers", l.toggleAllContainers, true))
}
}
func (l *Log) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !l.logs.cmdBuff.IsActive() {
if l.logs.cmdBuff.GetText() == "" {
return l.app.PrevCmd(evt)
}
}
l.logs.cmdBuff.Reset()
l.logs.cmdBuff.SetActive(false)
l.model.Filter(l.logs.cmdBuff.GetText())
l.updateTitle()
return nil
}
// SendStrokes (testing only!)
func (l *Log) SendStrokes(s string) {
l.app.Prompt().SendStrokes(s)
}
// SendKeys (testing only!)
func (l *Log) SendKeys(kk ...tcell.Key) {
for _, k := range kk {
l.logs.keyboard(tcell.NewEventKey(k, ' ', tcell.ModNone))
}
}
// Indicator returns the scroll mode viewer.
func (l *Log) Indicator() *LogIndicator {
return l.indicator
}
func (l *Log) updateTitle() {
sinceSeconds, since := l.model.SinceSeconds(), "tail"
if sinceSeconds > 0 && sinceSeconds < 60*60 {
since = fmt.Sprintf("%dm", sinceSeconds/60)
}
if sinceSeconds >= 60*60 {
since = fmt.Sprintf("%dh", sinceSeconds/(60*60))
}
if l.model.IsHead() {
since = "head"
}
title := " Logs"
if l.model.LogOptions().Previous {
title = " Previous Logs"
}
var (
path, co = l.model.GetPath(), l.model.GetContainer()
styles = l.app.Styles.Frame()
)
if co == "" {
title += ui.SkinTitle(fmt.Sprintf(logFmt, path, since), &styles)
} else {
title += ui.SkinTitle(fmt.Sprintf(logCoFmt, path, co, since), &styles)
}
buff := l.logs.cmdBuff.GetText()
if buff != "" {
title += ui.SkinTitle(fmt.Sprintf(ui.SearchFmt, buff), &styles)
}
l.SetTitle(title)
}
// Logs returns the log viewer.
func (l *Log) Logs() *Logger {
return l.logs
}
// EOL tracks end of lines.
var EOL = []byte{'\n'}
// Flush write logs to viewer.
func (l *Log) Flush(lines [][]byte) {
defer func() {
if l.cancelUpdates {
l.cancelUpdates = false
}
}()
if len(lines) == 0 || (!l.requestOneRefresh && !l.indicator.AutoScroll()) || l.cancelUpdates {
return
}
if l.requestOneRefresh {
l.requestOneRefresh = false
}
for i := range lines {
if l.cancelUpdates {
break
}
_, _ = l.ansiWriter.Write(lines[i])
}
if l.follow {
if l.columnLock {
// Enables end tracking without resetting column
l.logs.SetScrollable(false).SetScrollable(true)
} else {
l.logs.ScrollToEnd()
}
}
}
// ----------------------------------------------------------------------------
// Actions...
func (l *Log) sinceCmd(n int) func(evt *tcell.EventKey) *tcell.EventKey {
return func(*tcell.EventKey) *tcell.EventKey {
l.logs.Clear()
ctx := l.getContext()
if n == 0 {
l.model.Head(ctx)
} else {
l.model.SetSinceSeconds(ctx, int64(n))
}
l.requestOneRefresh = true
l.updateTitle()
return nil
}
}
func (l *Log) toggleAllContainers(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleAllContainers()
l.model.ToggleAllContainers(l.getContext())
l.updateTitle()
return nil
}
func (l *Log) filterCmd(evt *tcell.EventKey) *tcell.EventKey {
if !l.logs.cmdBuff.IsActive() {
_, _ = fmt.Fprintln(l.ansiWriter)
return evt
}
l.logs.cmdBuff.SetActive(false)
l.model.Filter(l.logs.cmdBuff.GetText())
l.updateTitle()
return nil
}
// SaveCmd dumps the logs to file.
func (l *Log) SaveCmd(*tcell.EventKey) *tcell.EventKey {
path, err := saveData(l.app.Config.K9s.ContextScreenDumpDir(), l.model.GetPath(), l.logs.GetText(true))
if err != nil {
l.app.Flash().Err(err)
return nil
}
l.app.Flash().Infof("Log %s saved successfully!", path)
return nil
}
func ensureDir(dir string) error {
return os.MkdirAll(dir, 0744)
}
func saveData(dir, fqn, logs string) (string, error) {
if err := ensureDir(dir); err != nil {
return "", err
}
f := fmt.Sprintf("%s-%d.log", fqn, time.Now().UnixNano())
path := filepath.Join(dir, data.SanitizeFileName(f))
mod := os.O_CREATE | os.O_WRONLY
file, err := os.OpenFile(path, mod, 0600)
if err != nil {
slog.Error("Unable to save log file",
slogs.Path, path,
slogs.Error, err,
)
return "", nil
}
defer func() {
if err := file.Close(); err != nil {
slog.Error("Closing Log file failed",
slogs.Path, path,
slogs.Error, err,
)
}
}()
if _, err := file.WriteString(logs); err != nil {
return "", err
}
return path, nil
}
func (l *Log) clearCmd(*tcell.EventKey) *tcell.EventKey {
l.model.Clear()
return nil
}
func (l *Log) markCmd(*tcell.EventKey) *tcell.EventKey {
_, _, w, _ := l.GetRect()
_, _ = fmt.Fprintf(l.ansiWriter, "[%s:-:b]%s[-:-:-]\n", l.app.Styles.Views().Log.FgColor.String(), strings.Repeat("-", w-4))
l.follow = true
return nil
}
func (l *Log) toggleTimestampCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleTimestamp()
l.model.ToggleShowTimestamp(l.indicator.showTime)
l.indicator.Refresh()
return nil
}
func (l *Log) toggleTextWrapCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleTextWrap()
l.logs.SetWrap(l.indicator.textWrap)
l.indicator.Refresh()
return nil
}
// ToggleAutoScrollCmd toggles autoscroll status.
func (l *Log) toggleAutoScrollCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleAutoScroll()
l.follow = l.indicator.AutoScroll()
l.indicator.Refresh()
return nil
}
func (l *Log) toggleColumnLockCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleColumnLock()
l.columnLock = l.indicator.ColumnLock()
l.indicator.Refresh()
return nil
}
func (l *Log) toggleFullScreenCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.indicator.ToggleFullScreen()
l.toggleFullScreen()
l.indicator.Refresh()
return nil
}
func (l *Log) toggleFullScreen() {
l.SetFullScreen(l.indicator.FullScreen())
l.SetBorder(!l.indicator.FullScreen())
if l.indicator.FullScreen() {
l.logs.SetBorderPadding(0, 0, 0, 0)
} else {
l.logs.SetBorderPadding(0, 0, 1, 1)
}
}
func (l *Log) isContainerLogView() bool {
return l.model.HasDefaultContainer()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/value_extender.go | internal/view/value_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"log/slog"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// ValueExtender adds values actions to a given viewer.
type ValueExtender struct {
ResourceViewer
}
// NewValueExtender returns a new extender.
func NewValueExtender(r ResourceViewer) ResourceViewer {
p := ValueExtender{ResourceViewer: r}
p.AddBindKeysFn(p.bindKeys)
p.GetTable().SetEnterFn(func(*App, ui.Tabular, *client.GVR, string) {
p.valuesCmd(nil)
})
return &p
}
func (v *ValueExtender) bindKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyV, ui.NewKeyAction("Values", v.valuesCmd, true))
}
func (v *ValueExtender) valuesCmd(evt *tcell.EventKey) *tcell.EventKey {
path := v.GetTable().GetSelectedItem()
if path == "" {
return evt
}
showValues(v.defaultCtx(), v.App(), path, v.GVR())
return nil
}
func (v *ValueExtender) defaultCtx() context.Context {
return context.WithValue(context.Background(), internal.KeyFactory, v.App().factory)
}
func showValues(ctx context.Context, app *App, path string, gvr *client.GVR) {
vm := model.NewValues(gvr, path)
if err := vm.Init(app.factory); err != nil {
app.Flash().Errf("Initializing the values model failed: %s", err)
}
toggleValuesCmd := func(*tcell.EventKey) *tcell.EventKey {
if err := vm.ToggleValues(); err != nil {
app.Flash().Errf("Values toggle failed: %s", err)
return nil
}
if err := vm.Refresh(ctx); err != nil {
slog.Error("Values viewer refresh failed", slogs.Error, err)
return nil
}
app.Flash().Infof("Values toggled")
return nil
}
v := NewLiveView(app, "Values", vm)
v.actions.Add(ui.KeyV, ui.NewKeyAction("Toggle All Values", toggleValuesCmd, true))
if err := v.app.inject(v, false); err != nil {
v.app.Flash().Err(err)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/help_test.go | internal/view/help_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"strings"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestHelp(t *testing.T) {
ctx := makeCtx(t)
app := ctx.Value(internal.KeyApp).(*view.App)
po := view.NewPod(client.PodGVR)
require.NoError(t, po.Init(ctx))
app.Content.Push(po)
v := view.NewHelp(app)
require.NoError(t, v.Init(ctx))
assert.Equal(t, 29, v.GetRowCount())
assert.Equal(t, 8, v.GetColumnCount())
assert.Equal(t, "<a>", strings.TrimSpace(v.GetCell(1, 0).Text))
assert.Equal(t, "Attach", strings.TrimSpace(v.GetCell(1, 1).Text))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/restart_extender.go | internal/view/restart_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"fmt"
"strings"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// RestartExtender represents a restartable resource.
type RestartExtender struct {
ResourceViewer
}
// NewRestartExtender returns a new extender.
func NewRestartExtender(v ResourceViewer) ResourceViewer {
r := RestartExtender{ResourceViewer: v}
v.AddBindKeysFn(r.bindKeys)
return &r
}
// BindKeys creates additional menu actions.
func (r *RestartExtender) bindKeys(aa *ui.KeyActions) {
if r.App().Config.IsReadOnly() {
return
}
aa.Add(ui.KeyR, ui.NewKeyActionWithOpts("Restart", r.restartCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
))
}
func (r *RestartExtender) restartCmd(*tcell.EventKey) *tcell.EventKey {
paths := r.GetTable().GetSelectedItems()
if len(paths) == 0 || paths[0] == "" {
return nil
}
r.Stop()
defer r.Start()
msg := fmt.Sprintf("Restart %s %s?", singularize(r.GVR().R()), paths[0])
if len(paths) > 1 {
msg = fmt.Sprintf("Restart %d %s?", len(paths), r.GVR().R())
}
d := r.App().Styles.Dialog()
opts := dialog.RestartDialogOpts{
Title: "Confirm Restart",
Message: msg,
FieldManager: "kubectl-rollout",
Ack: func(opts *metav1.PatchOptions) bool {
ctx, cancel := context.WithTimeout(context.Background(), r.App().Conn().Config().CallTimeout())
defer cancel()
for _, path := range paths {
if err := r.restartRollout(ctx, path, opts); err != nil {
r.App().Flash().Err(err)
} else {
r.App().Flash().Infof("Restart in progress for `%s...", path)
}
}
return true
},
Cancel: func() {},
}
dialog.ShowRestart(&d, r.App().Content.Pages, &opts)
return nil
}
func (r *RestartExtender) restartRollout(ctx context.Context, path string, opts *metav1.PatchOptions) error {
res, err := dao.AccessorFor(r.App().factory, r.GVR())
if err != nil {
return err
}
s, ok := res.(dao.Restartable)
if !ok {
return errors.New("resource is not restartable")
}
return s.Restart(ctx, path, opts)
}
// Helpers...
func singularize(s string) string {
if strings.LastIndex(s, "s") == len(s)-1 {
return s[:len(s)-1]
}
return s
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/alias_test.go | internal/view/alias_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"context"
"testing"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/mock"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view"
"github.com/derailed/tcell/v2"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
func TestAliasNew(t *testing.T) {
v := view.NewAlias(client.AliGVR)
require.NoError(t, v.Init(makeContext(t)))
assert.Equal(t, "Aliases", v.Name())
assert.Len(t, v.Hints(), 7)
}
func TestAliasSearch(t *testing.T) {
v := view.NewAlias(client.AliGVR)
require.NoError(t, v.Init(makeContext(t)))
v.GetTable().SetModel(new(mockModel))
v.GetTable().Refresh()
v.App().Prompt().SetModel(v.GetTable().CmdBuff())
v.App().Prompt().SendStrokes("blee")
assert.Equal(t, 3, v.GetTable().GetColumnCount())
assert.Equal(t, 3, v.GetTable().GetRowCount())
}
func TestAliasGoto(t *testing.T) {
v := view.NewAlias(client.AliGVR)
require.NoError(t, v.Init(makeContext(t)))
v.GetTable().Select(0, 0)
b := buffL{}
v.GetTable().CmdBuff().SetActive(true)
v.GetTable().CmdBuff().AddListener(&b)
v.GetTable().SendKey(tcell.NewEventKey(tcell.KeyEnter, 256, tcell.ModNone))
assert.True(t, v.GetTable().CmdBuff().IsActive())
}
// ----------------------------------------------------------------------------
// Helpers...
type buffL struct {
active int
changed int
}
func (b *buffL) BufferChanged(string, string) {
b.changed++
}
func (*buffL) BufferCompleted(string, string) {}
func (b *buffL) BufferActive(bool, model.BufferKind) {
b.active++
}
func makeContext(t testing.TB) context.Context {
a := view.NewApp(mock.NewMockConfig(t))
ctx := context.WithValue(context.Background(), internal.KeyApp, a)
return context.WithValue(ctx, internal.KeyStyles, a.Styles)
}
type mockModel struct{}
var (
_ ui.Tabular = (*mockModel)(nil)
_ ui.Suggester = (*mockModel)(nil)
)
func (*mockModel) SetViewSetting(context.Context, *config.ViewSetting) {}
func (*mockModel) CurrentSuggestion() (string, bool) { return "", false }
func (*mockModel) NextSuggestion() (string, bool) { return "", false }
func (*mockModel) PrevSuggestion() (string, bool) { return "", false }
func (*mockModel) ClearSuggestions() {}
func (*mockModel) SetInstance(string) {}
func (*mockModel) SetLabelSelector(labels.Selector) {}
func (*mockModel) GetLabelSelector() labels.Selector { return nil }
func (*mockModel) Empty() bool { return false }
func (*mockModel) RowCount() int { return 1 }
func (*mockModel) HasMetrics() bool { return true }
func (*mockModel) Peek() *model1.TableData { return makeTableData() }
func (*mockModel) ClusterWide() bool { return false }
func (*mockModel) GetNamespace() string { return "blee" }
func (*mockModel) SetNamespace(string) {}
func (*mockModel) ToggleToast() {}
func (*mockModel) AddListener(model.TableListener) {}
func (*mockModel) RemoveListener(model.TableListener) {}
func (*mockModel) Watch(context.Context) error { return nil }
func (*mockModel) Refresh(context.Context) error { return nil }
func (*mockModel) Get(context.Context, string) (runtime.Object, error) {
return nil, nil
}
func (*mockModel) Delete(context.Context, string, *metav1.DeletionPropagation, dao.Grace) error {
return nil
}
func (*mockModel) Describe(context.Context, string) (string, error) {
return "", nil
}
func (*mockModel) ToYAML(context.Context, string) (string, error) {
return "", nil
}
func (*mockModel) InNamespace(string) bool { return true }
func (*mockModel) SetRefreshRate(time.Duration) {}
func makeTableData() *model1.TableData {
return model1.NewTableDataWithRows(
client.NewGVR("test"),
model1.Header{
model1.HeaderColumn{Name: "RESOURCE"},
model1.HeaderColumn{Name: "COMMAND"},
model1.HeaderColumn{Name: "APIGROUP"},
},
model1.NewRowEventsWithEvts(
model1.RowEvent{
Row: model1.Row{
ID: "r1",
Fields: model1.Fields{"blee", "duh", "fred"},
},
},
model1.RowEvent{
Row: model1.Row{
ID: "r2",
Fields: model1.Fields{"fred", "duh", "zorg"},
},
},
),
)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pod_int_test.go | internal/view/pod_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/cli-runtime/pkg/genericclioptions"
)
func newStr(s string) *string {
return &s
}
func TestComputeShellArgs(t *testing.T) {
uu := map[string]struct {
fqn, co, os string
cfg *genericclioptions.ConfigFlags
e string
}{
"config": {
fqn: "fred/blee",
co: "c1",
os: "darwin",
cfg: &genericclioptions.ConfigFlags{
KubeConfig: newStr("coolConfig"),
},
e: "exec -it -n fred blee --kubeconfig coolConfig -c c1 -- sh -c " + shellCheck,
},
"no-config": {
fqn: "fred/blee",
co: "c1",
os: "linux",
e: "exec -it -n fred blee -c c1 -- sh -c " + shellCheck,
},
"empty-config": {
fqn: "fred/blee",
cfg: new(genericclioptions.ConfigFlags),
e: "exec -it -n fred blee -- sh -c " + shellCheck,
},
"single-container": {
fqn: "fred/blee",
os: "linux",
cfg: new(genericclioptions.ConfigFlags),
e: "exec -it -n fred blee -- sh -c " + shellCheck,
},
"windows": {
fqn: "fred/blee",
co: "c1",
os: windowsOS,
cfg: new(genericclioptions.ConfigFlags),
e: "exec -it -n fred blee -c c1 -- powershell",
},
"full": {
fqn: "fred/blee",
co: "c1",
os: windowsOS,
cfg: &genericclioptions.ConfigFlags{
KubeConfig: newStr("coolConfig"),
Context: newStr("coolContext"),
BearerToken: newStr("coolToken"),
},
e: "exec -it -n fred blee --kubeconfig coolConfig --context coolContext --token coolToken -c c1 -- powershell",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
args := computeShellArgs(u.fqn, u.co, u.cfg, u.os)
assert.Equal(t, u.e, strings.Join(args, " "))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/svc.go | internal/view/svc.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"fmt"
"log/slog"
"strings"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/perf"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
// Service represents a service viewer.
type Service struct {
ResourceViewer
bench *perf.Benchmark
}
// NewService returns a new viewer.
func NewService(gvr *client.GVR) ResourceViewer {
s := Service{
ResourceViewer: NewPortForwardExtender(
NewOwnerExtender(
NewLogsExtender(NewBrowser(gvr), nil),
),
),
}
s.AddBindKeysFn(s.bindKeys)
s.GetTable().SetEnterFn(s.showPods)
return &s
}
// Protocol...
func (s *Service) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyB: ui.NewKeyAction("Bench Run/Stop", s.toggleBenchCmd, true),
ui.KeyShiftT: ui.NewKeyAction("Sort Type", s.GetTable().SortColCmd("TYPE", true), false),
})
}
func (s *Service) showPods(a *App, _ ui.Tabular, _ *client.GVR, path string) {
var res dao.Service
res.Init(a.factory, s.GVR())
svc, err := res.GetInstance(path)
if err != nil {
a.Flash().Err(err)
return
}
if svc.Spec.Type == v1.ServiceTypeExternalName {
a.Flash().Warnf("No matching pods. Service %s is an external service.", path)
return
}
if svc.Spec.Selector == nil {
a.Flash().Warnf("No matching pods. Service %s does not provide any selectors", path)
return
}
showPods(a, path, labels.SelectorFromSet(svc.Spec.Selector), "")
}
func (*Service) checkSvc(svc *v1.Service) error {
if svc.Spec.Type != "NodePort" && svc.Spec.Type != "LoadBalancer" {
return errors.New("you must select a reachable service")
}
return nil
}
func (*Service) getExternalPort(svc *v1.Service) (string, error) {
if svc.Spec.Type == "LoadBalancer" {
return "", nil
}
ports := render.ToPorts(svc.Spec.Ports)
pp := strings.Split(ports, " ")
// Grab the first port pair for now...
tokens := strings.Split(pp[0], "►")
if len(tokens) < 2 {
return "", errors.New("no ports pair found")
}
return tokens[1], nil
}
func (s *Service) toggleBenchCmd(evt *tcell.EventKey) *tcell.EventKey {
if s.bench != nil {
slog.Debug(">>> Benchmark canceled!!")
s.App().Status(model.FlashErr, "Benchmark Canceled!")
s.bench.Cancel()
s.App().ClearStatus(true)
return nil
}
path := s.GetTable().GetSelectedItem()
if path == "" || s.bench != nil {
return evt
}
cust, err := config.NewBench(s.App().BenchFile)
if err != nil {
slog.Debug("No bench config file found", slogs.FileName, s.App().BenchFile)
}
cfg, ok := cust.Benchmarks.Services[path]
if !ok {
s.App().Flash().Errf("No bench config found for service %s in %s", path, s.App().BenchFile)
return nil
}
cfg.Name = path
slog.Debug("Benchmark config", slogs.Config, cfg)
svc, err := fetchService(s.App().factory, path)
if err != nil {
s.App().Flash().Err(err)
return nil
}
if e := s.checkSvc(svc); e != nil {
s.App().Flash().Err(e)
return nil
}
port, err := s.getExternalPort(svc)
if err != nil {
s.App().Flash().Err(err)
return nil
}
if err := s.runBenchmark(port, &cfg); err != nil {
s.App().Flash().Errf("Benchmark failed %v", err)
s.App().ClearStatus(false)
s.bench = nil
}
return nil
}
// BOZO!! Refactor used by forwards.
func (s *Service) runBenchmark(port string, cfg *config.BenchConfig) error {
if cfg.HTTP.Host == "" {
return fmt.Errorf("invalid benchmark host %q", cfg.HTTP.Host)
}
var err error
base := cfg.HTTP.Host
if !strings.Contains(base, ":") {
base += ":" + port + cfg.HTTP.Path
} else {
base += cfg.HTTP.Path
}
if strings.Index(base, "http") != 0 {
base = "http://" + base
}
if s.bench, err = perf.NewBenchmark(base, s.App().version, cfg); err != nil {
return err
}
s.App().Status(model.FlashWarn, "Benchmark in progress...")
slog.Debug("Benchmark starting...")
ct, err := s.App().Config.K9s.ActiveContext()
if err != nil {
return err
}
name := s.App().Config.K9s.ActiveContextName()
go s.bench.Run(ct.ClusterName, name, s.benchDone)
return nil
}
func (s *Service) benchDone() {
slog.Debug("Bench Completed!")
s.App().QueueUpdate(func() {
if s.bench.Canceled() {
s.App().Status(model.FlashInfo, "Benchmark canceled")
} else {
s.App().Status(model.FlashInfo, "Benchmark Completed!")
s.bench.Cancel()
}
s.bench = nil
go clearStatus(s.App())
})
}
// ----------------------------------------------------------------------------
// Helpers...
func clearStatus(app *App) {
<-time.After(2 * time.Second)
app.QueueUpdate(func() {
app.ClearStatus(true)
})
}
func fetchService(f dao.Factory, path string) (*v1.Service, error) {
o, err := f.Get(client.SvcGVR, path, 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, err
}
return &svc, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/live_view.go | internal/view/live_view.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"strconv"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"github.com/sahilm/fuzzy"
"k8s.io/apimachinery/pkg/labels"
)
const (
liveViewTitleFmt = "[fg:bg:b] %s([hilite:bg:b]%s[fg:bg:-])[fg:bg:-] "
yamlAction = "YAML"
)
// LiveView represents a live text viewer.
type LiveView struct {
*tview.Flex
title string
model model.ResourceViewer
text *tview.TextView
actions *ui.KeyActions
app *App
cmdBuff *model.FishBuff
currentRegion, maxRegions int
cancel context.CancelFunc
fullScreen bool
managedField bool
autoRefresh bool
}
// NewLiveView returns a live viewer.
func NewLiveView(app *App, title string, m model.ResourceViewer) *LiveView {
v := LiveView{
Flex: tview.NewFlex(),
text: tview.NewTextView(),
app: app,
title: title,
actions: ui.NewKeyActions(),
currentRegion: 0,
maxRegions: 0,
cmdBuff: model.NewFishBuff('/', model.FilterBuffer),
model: m,
autoRefresh: app.Config.K9s.LiveViewAutoRefresh,
}
v.AddItem(v.text, 0, 1, true)
return &v
}
func (*LiveView) SetCommand(*cmd.Interpreter) {}
func (*LiveView) SetFilter(string, bool) {}
func (*LiveView) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the viewer.
func (v *LiveView) Init(_ context.Context) error {
if v.title != "" {
v.SetBorder(true)
}
v.text.SetScrollable(true).SetWrap(true).SetRegions(true)
v.text.SetDynamicColors(true)
v.text.SetHighlightColor(tcell.ColorOrange)
v.SetTitleColor(tcell.ColorAqua)
v.SetInputCapture(v.keyboard)
v.SetBorderPadding(0, 0, 1, 1)
v.updateTitle()
v.app.Styles.AddListener(v)
v.StylesChanged(v.app.Styles)
v.setFullScreen(v.app.Config.K9s.UI.DefaultsToFullScreen)
v.app.Prompt().SetModel(v.cmdBuff)
v.cmdBuff.AddListener(v)
v.bindKeys()
v.SetInputCapture(v.keyboard)
if v.model != nil {
v.model.AddListener(v)
}
return nil
}
// InCmdMode checks if prompt is active.
func (v *LiveView) InCmdMode() bool {
return v.cmdBuff.InCmdMode()
}
// ResourceFailed notifies when there is an issue.
func (v *LiveView) ResourceFailed(err error) {
v.text.SetTextAlign(tview.AlignCenter)
x, _, w, _ := v.GetRect()
v.text.SetText(cowTalk(err.Error(), x+w))
}
// ResourceChanged notifies when the filter changes.
func (v *LiveView) ResourceChanged(lines []string, matches fuzzy.Matches) {
v.app.QueueUpdateDraw(func() {
v.text.SetTextAlign(tview.AlignLeft)
v.currentRegion, v.maxRegions = 0, len(matches)
if v.text.GetText(true) == "" {
v.text.ScrollToBeginning()
}
lines = linesWithRegions(lines, matches)
v.text.SetText(colorizeYAML(v.app.Styles.Views().Yaml, strings.Join(lines, "\n")))
v.text.Highlight()
if v.currentRegion < v.maxRegions {
v.text.Highlight("search_" + strconv.Itoa(v.currentRegion))
v.text.ScrollToHighlight()
}
v.updateTitle()
})
}
// BufferChanged indicates the buffer was changed.
func (*LiveView) BufferChanged(_, _ string) {}
// BufferCompleted indicates input was accepted.
func (v *LiveView) BufferCompleted(text, _ string) {
v.model.Filter(text)
}
// BufferActive indicates the buff activity changed.
func (v *LiveView) BufferActive(state bool, k model.BufferKind) {
v.app.BufferActive(state, k)
}
func (v *LiveView) bindKeys() {
v.actions.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewSharedKeyAction("Filter", v.filterCmd, false),
tcell.KeyEscape: ui.NewKeyAction("Back", v.resetCmd, false),
ui.KeyQ: ui.NewKeyAction("Back", v.resetCmd, false),
tcell.KeyCtrlS: ui.NewKeyAction("Save", v.saveCmd, false),
ui.KeyC: ui.NewKeyAction("Copy", cpCmd(v.app.Flash(), v.text), true),
ui.KeyF: ui.NewKeyAction("Toggle FullScreen", v.toggleFullScreenCmd, true),
ui.KeyR: ui.NewKeyAction("Toggle Auto-Refresh", v.toggleRefreshCmd, true),
ui.KeyN: ui.NewKeyAction("Next Match", v.nextCmd, true),
ui.KeyShiftN: ui.NewKeyAction("Prev Match", v.prevCmd, true),
ui.KeySlash: ui.NewSharedKeyAction("Filter Mode", v.activateCmd, false),
tcell.KeyDelete: ui.NewSharedKeyAction("Erase", v.eraseCmd, false),
})
if !v.app.Config.IsReadOnly() {
v.actions.Add(ui.KeyE, ui.NewKeyAction("Edit", v.editCmd, true))
}
if v.title == yamlAction {
v.actions.Add(ui.KeyM, ui.NewKeyAction("Toggle ManagedFields", v.toggleManagedCmd, true))
}
if _, ok := v.model.(model.EncDecResourceViewer); ok {
v.actions.Add(ui.KeyX, ui.NewKeyAction("Toggle Decode", v.toggleEncodedDecodedCmd, true))
}
}
func (v *LiveView) toggleEncodedDecodedCmd(evt *tcell.EventKey) *tcell.EventKey {
m, ok := v.model.(model.EncDecResourceViewer)
if !ok {
return evt
}
m.Toggle()
v.Start()
return nil
}
func (v *LiveView) editCmd(evt *tcell.EventKey) *tcell.EventKey {
path := v.model.GetPath()
if path == "" {
return evt
}
v.Stop()
defer v.Start()
if err := editRes(v.app, v.model.GVR(), path); err != nil {
v.app.Flash().Err(err)
}
return nil
}
// ToggleRefreshCmd is used for pausing the refreshing of data on config map and secrets.
func (v *LiveView) toggleRefreshCmd(*tcell.EventKey) *tcell.EventKey {
v.autoRefresh = !v.autoRefresh
if v.autoRefresh {
v.Start()
v.app.Flash().Info("Auto-refresh is enabled")
return nil
}
v.Stop()
v.app.Flash().Info("Auto-refresh is disabled")
return nil
}
func (v *LiveView) keyboard(evt *tcell.EventKey) *tcell.EventKey {
if a, ok := v.actions.Get(ui.AsKey(evt)); ok {
return a.Action(evt)
}
return evt
}
// StylesChanged notifies the skin changed.
func (v *LiveView) StylesChanged(s *config.Styles) {
v.SetBackgroundColor(s.BgColor())
v.text.SetTextColor(s.FgColor())
v.SetBorderFocusColor(s.Frame().Border.FocusColor.Color())
}
// Actions returns menu actions.
func (v *LiveView) Actions() *ui.KeyActions {
return v.actions
}
// Name returns the component name.
func (v *LiveView) Name() string { return v.title }
// Start starts the view updater.
func (v *LiveView) Start() {
if v.autoRefresh {
var ctx context.Context
ctx, v.cancel = context.WithCancel(v.defaultCtx())
if err := v.model.Watch(ctx); err != nil {
slog.Error("LiveView watcher failed", slogs.Error, err)
}
return
}
if err := v.model.Refresh(v.defaultCtx()); err != nil {
slog.Error("LiveView refresh failed", slogs.Error, err)
}
}
func (v *LiveView) defaultCtx() context.Context {
return context.WithValue(context.Background(), internal.KeyFactory, v.app.factory)
}
// Stop terminates the updater.
func (v *LiveView) Stop() {
if v.cancel != nil {
v.cancel()
v.cancel = nil
}
v.app.Styles.RemoveListener(v)
}
// Hints returns menu hints.
func (v *LiveView) Hints() model.MenuHints {
return v.actions.Hints()
}
// ExtraHints returns additional hints.
func (*LiveView) ExtraHints() map[string]string {
return nil
}
func (v *LiveView) toggleManagedCmd(evt *tcell.EventKey) *tcell.EventKey {
if v.app.InCmdMode() {
return evt
}
v.managedField = !v.managedField
v.model.SetOptions(v.defaultCtx(), map[string]bool{model.ManagedFieldsOpts: v.managedField})
v.app.Flash().Info("toggled managed fields")
return nil
}
func (v *LiveView) toggleFullScreenCmd(evt *tcell.EventKey) *tcell.EventKey {
if v.app.InCmdMode() {
return evt
}
v.setFullScreen(!v.fullScreen)
return nil
}
func (v *LiveView) setFullScreen(isFullScreen bool) {
v.fullScreen = isFullScreen
v.SetFullScreen(isFullScreen)
v.SetBorder(!isFullScreen)
if isFullScreen {
v.SetBorderPadding(0, 0, 0, 0)
} else {
v.SetBorderPadding(0, 0, 1, 1)
}
}
func (v *LiveView) nextCmd(evt *tcell.EventKey) *tcell.EventKey {
if v.cmdBuff.Empty() {
return evt
}
v.currentRegion++
if v.currentRegion >= v.maxRegions {
v.currentRegion = 0
}
v.text.Highlight("search_" + strconv.Itoa(v.currentRegion))
v.text.ScrollToHighlight()
v.updateTitle()
return nil
}
func (v *LiveView) prevCmd(evt *tcell.EventKey) *tcell.EventKey {
if v.cmdBuff.Empty() {
return evt
}
v.currentRegion--
if v.currentRegion < 0 {
v.currentRegion = v.maxRegions - 1
}
v.text.Highlight("search_" + strconv.Itoa(v.currentRegion))
v.text.ScrollToHighlight()
v.updateTitle()
return nil
}
func (v *LiveView) filterCmd(*tcell.EventKey) *tcell.EventKey {
v.model.Filter(v.cmdBuff.GetText())
v.cmdBuff.SetActive(false)
v.updateTitle()
return nil
}
func (v *LiveView) activateCmd(evt *tcell.EventKey) *tcell.EventKey {
if v.app.InCmdMode() {
return evt
}
v.app.ResetPrompt(v.cmdBuff)
return nil
}
func (v *LiveView) eraseCmd(*tcell.EventKey) *tcell.EventKey {
if !v.cmdBuff.IsActive() {
return nil
}
v.cmdBuff.Delete()
return nil
}
func (v *LiveView) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !v.cmdBuff.InCmdMode() {
v.cmdBuff.Reset()
return v.app.PrevCmd(evt)
}
if v.cmdBuff.GetText() != "" {
v.model.ClearFilter()
}
v.cmdBuff.SetActive(false)
v.cmdBuff.Reset()
v.updateTitle()
return nil
}
func (v *LiveView) saveCmd(*tcell.EventKey) *tcell.EventKey {
name := fmt.Sprintf("%s--%s", strings.Replace(v.model.GetPath(), "/", "-", 1), strings.ToLower(v.title))
if _, err := saveYAML(v.app.Config.K9s.ContextScreenDumpDir(), name, sanitizeEsc(v.text.GetText(true))); err != nil {
v.app.Flash().Err(err)
} else {
v.app.Flash().Infof("File %q saved successfully!", name)
}
return nil
}
func (v *LiveView) updateTitle() {
if v.title == "" {
return
}
var fmat string
if v.model != nil {
fmat = fmt.Sprintf(liveViewTitleFmt, v.title, v.model.GetPath())
}
var (
buff = v.cmdBuff.GetText()
styles = v.app.Styles.Frame()
)
if buff == "" {
v.SetTitle(ui.SkinTitle(fmat, &styles))
return
}
if v.maxRegions > 0 {
buff += fmt.Sprintf("[%d:%d]", v.currentRegion+1, v.maxRegions)
}
fmat += fmt.Sprintf(ui.SearchFmt, buff)
v.SetTitle(ui.SkinTitle(fmat, &styles))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/sa.go | internal/view/sa.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// ServiceAccount represents a serviceaccount viewer.
type ServiceAccount struct {
ResourceViewer
}
// NewServiceAccount returns a new viewer.
func NewServiceAccount(gvr *client.GVR) ResourceViewer {
s := ServiceAccount{
ResourceViewer: NewOwnerExtender(NewBrowser(gvr)),
}
s.AddBindKeysFn(s.bindKeys)
s.SetContextFn(s.subjectCtx)
return &s
}
func (s *ServiceAccount) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyU: ui.NewKeyAction("UsedBy", s.refCmd, true),
tcell.KeyEnter: ui.NewKeyAction("Rules", s.policyCmd, true),
})
}
func (*ServiceAccount) subjectCtx(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeySubjectKind, sa)
}
func (s *ServiceAccount) refCmd(evt *tcell.EventKey) *tcell.EventKey {
return scanSARefs(evt, s.App(), s.GetTable(), client.SaGVR)
}
func (s *ServiceAccount) policyCmd(evt *tcell.EventKey) *tcell.EventKey {
path := s.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if err := s.App().inject(NewPolicy(s.App(), sa, path), false); err != nil {
s.App().Flash().Err(err)
}
return nil
}
func scanSARefs(evt *tcell.EventKey, a *App, t *Table, gvr *client.GVR) *tcell.EventKey {
path := t.GetSelectedItem()
if path == "" {
return evt
}
ctx := context.Background()
refs, err := dao.ScanForSARefs(refContext(gvr, path, true)(ctx), a.factory)
if err != nil {
a.Flash().Err(err)
return nil
}
if len(refs) == 0 {
a.Flash().Warnf("No references found at this time for %s::%s. Check again later!", gvr, path)
return nil
}
a.Flash().Infof("Viewing references for %s::%s", gvr, path)
view := NewReference(client.RefGVR)
view.SetContextFn(refContext(gvr, path, false))
if err := a.inject(view, false); err != nil {
a.Flash().Err(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/view/cluster_info.go | internal/view/cluster_info.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
var _ model.ClusterInfoListener = (*ClusterInfo)(nil)
// ClusterInfo represents a cluster info view.
type ClusterInfo struct {
*tview.Table
app *App
styles *config.Styles
}
// NewClusterInfo returns a new cluster info view.
func NewClusterInfo(app *App) *ClusterInfo {
return &ClusterInfo{
Table: tview.NewTable(),
app: app,
styles: app.Styles,
}
}
// Init initializes the view.
func (c *ClusterInfo) Init() {
c.SetBorderPadding(0, 0, 1, 0)
c.app.Styles.AddListener(c)
c.layout()
c.StylesChanged(c.app.Styles)
}
// StylesChanged notifies skin changed.
func (c *ClusterInfo) StylesChanged(s *config.Styles) {
c.styles = s
c.SetBackgroundColor(s.BgColor())
c.updateStyle()
}
func (c *ClusterInfo) hasMetrics() bool {
mx := c.app.Conn().HasMetrics()
if mx {
auth, err := c.app.Conn().CanI("", client.NmxGVR, "", client.ListAccess)
if err != nil {
slog.Warn("No nodes metrics access", slogs.Error, err)
}
mx = auth
}
return mx
}
func (c *ClusterInfo) layout() {
for row, section := range []string{"Context", "Cluster", "User", "K9s Rev", "K8s Rev", "CPU", "MEM"} {
c.SetCell(row, 0, c.sectionCell(section))
c.SetCell(row, 1, c.infoCell(render.NAValue))
}
}
func (c *ClusterInfo) sectionCell(t string) *tview.TableCell {
cell := tview.NewTableCell(t + ":")
cell.SetAlign(tview.AlignLeft)
cell.SetBackgroundColor(c.app.Styles.BgColor())
return cell
}
func (c *ClusterInfo) infoCell(t string) *tview.TableCell {
cell := tview.NewTableCell(t)
cell.SetExpansion(2)
cell.SetTextColor(c.styles.K9s.Info.FgColor.Color())
cell.SetBackgroundColor(c.app.Styles.BgColor())
return cell
}
func (c *ClusterInfo) setCell(row int, s string) int {
if s == "" {
s = render.NAValue
}
c.GetCell(row, 1).SetText(s)
return row + 1
}
// ClusterInfoUpdated notifies the cluster meta was updated.
func (c *ClusterInfo) ClusterInfoUpdated(data *model.ClusterMeta) {
c.ClusterInfoChanged(data, data)
}
func (*ClusterInfo) warnCell(s string, w bool) string {
if w {
return fmt.Sprintf("[orangered::b]%s", s)
}
return s
}
// ClusterInfoChanged notifies the cluster meta was changed.
func (c *ClusterInfo) ClusterInfoChanged(prev, curr *model.ClusterMeta) {
c.app.QueueUpdateDraw(func() {
c.Clear()
c.layout()
context := curr.Context
if ic := ui.ROIndicator(c.app.Config.IsReadOnly(), c.app.Config.K9s.UI.NoIcons); ic != "" {
context += " " + ic
}
row := c.setCell(0, context)
row = c.setCell(row, curr.Cluster)
row = c.setCell(row, curr.User)
if curr.K9sLatest != "" {
row = c.setCell(row, fmt.Sprintf("%s ⚡️[cadetblue::b]%s", curr.K9sVer, curr.K9sLatest))
} else {
row = c.setCell(row, curr.K9sVer)
}
row = c.setCell(row, curr.K8sVer)
if c.hasMetrics() {
row = c.setCell(row, ui.AsPercDelta(prev.Cpu, curr.Cpu))
_ = c.setCell(row, ui.AsPercDelta(prev.Mem, curr.Mem))
c.setDefCon(curr.Cpu, curr.Mem)
} else {
row = c.setCell(row, c.warnCell(render.NAValue, true))
_ = c.setCell(row, c.warnCell(render.NAValue, true))
}
c.updateStyle()
})
}
const defconFmt = "%s %s level!"
func (c *ClusterInfo) setDefCon(cpu, mem int) {
var set bool
l := c.app.Config.K9s.Thresholds.LevelFor(config.CPU, cpu)
if l > config.SeverityLow {
c.app.Status(flashLevel(l), fmt.Sprintf(defconFmt, flashMessage(l), "CPU"))
set = true
}
l = c.app.Config.K9s.Thresholds.LevelFor(config.MEM, mem)
if l > config.SeverityLow {
c.app.Status(flashLevel(l), fmt.Sprintf(defconFmt, flashMessage(l), "Memory"))
set = true
}
if !set && !c.app.IsBenchmarking() {
c.app.ClearStatus(true)
}
}
func (c *ClusterInfo) updateStyle() {
for row := range c.GetRowCount() {
c.GetCell(row, 0).SetTextColor(c.styles.K9s.Info.FgColor.Color())
c.GetCell(row, 0).SetBackgroundColor(c.styles.BgColor())
var s tcell.Style
s = s.Bold(true)
s = s.Foreground(c.styles.K9s.Info.SectionColor.Color())
s = s.Background(c.styles.BgColor())
c.GetCell(row, 1).SetStyle(s)
}
}
// ----------------------------------------------------------------------------
// Helpers...
func flashLevel(l config.SeverityLevel) model.FlashLevel {
//nolint:exhaustive
switch l {
case config.SeverityHigh:
return model.FlashErr
case config.SeverityMedium:
return model.FlashWarn
default:
return model.FlashInfo
}
}
func flashMessage(l config.SeverityLevel) string {
//nolint:exhaustive
switch l {
case config.SeverityHigh:
return "Critical"
case config.SeverityMedium:
return "Warning"
default:
return "OK"
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/secret.go | internal/view/secret.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"k8s.io/apimachinery/pkg/labels"
)
// Secret presents a secret viewer.
type Secret struct {
ResourceViewer
}
// NewSecret returns a new viewer.
func NewSecret(gvr *client.GVR) ResourceViewer {
s := Secret{
ResourceViewer: NewOwnerExtender(NewBrowser(gvr)),
}
s.AddBindKeysFn(s.bindKeys)
return &s
}
func (s *Secret) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyX: ui.NewKeyAction("Decode", s.decodeCmd, true),
ui.KeyU: ui.NewKeyAction("UsedBy", s.refCmd, true),
})
}
func (s *Secret) refCmd(evt *tcell.EventKey) *tcell.EventKey {
return scanRefs(evt, s.App(), s.GetTable(), client.SecGVR)
}
func (s *Secret) decodeCmd(evt *tcell.EventKey) *tcell.EventKey {
path := s.GetTable().GetSelectedItem()
if path == "" {
return evt
}
o, err := s.App().factory.Get(s.GVR(), path, true, labels.Everything())
if err != nil {
s.App().Flash().Err(err)
return nil
}
mm, err := dao.ExtractSecrets(o)
if err != nil {
s.App().Flash().Err(err)
return nil
}
raw, err := data.WriteYAML(mm)
if err != nil {
s.App().Flash().Errf("Error decoding secret %s", err)
return nil
}
details := NewDetails(s.App(), "Secret Decoder", path, contentYAML, true).Update(string(raw))
if err := s.App().inject(details, false); err != nil {
s.App().Flash().Err(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/view/reference_test.go | internal/view/reference_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestReferenceNew(t *testing.T) {
s := view.NewReference(client.RefGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "References", s.Name())
assert.Len(t, s.Hints(), 5)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/logs_extender.go | internal/view/logs_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// LogsExtender adds log actions to a given viewer.
type LogsExtender struct {
ResourceViewer
optionsFn LogOptionsFunc
}
// NewLogsExtender returns a new extender.
func NewLogsExtender(v ResourceViewer, f LogOptionsFunc) ResourceViewer {
l := LogsExtender{
ResourceViewer: v,
optionsFn: f,
}
l.AddBindKeysFn(l.bindKeys)
return &l
}
// BindKeys injects new menu actions.
func (l *LogsExtender) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyL: ui.NewKeyAction("Logs", l.logsCmd(false), true),
ui.KeyP: ui.NewKeyAction("Logs Previous", l.logsCmd(true), true),
})
}
func (l *LogsExtender) logsCmd(prev bool) func(evt *tcell.EventKey) *tcell.EventKey {
return func(*tcell.EventKey) *tcell.EventKey {
path := l.GetTable().GetSelectedItem()
if path == "" {
return nil
}
if !isResourcePath(path) {
path = l.GetTable().Path
}
l.showLogs(path, prev)
return nil
}
}
func isResourcePath(p string) bool {
ns, n := client.Namespaced(p)
return ns != "" && n != ""
}
func (l *LogsExtender) showLogs(path string, prev bool) {
ns, _ := client.Namespaced(path)
_, err := l.App().factory.CanForResource(ns, client.PodGVR, client.ListAccess)
if err != nil {
l.App().Flash().Err(err)
return
}
opts := l.buildLogOpts(path, "", prev)
if l.optionsFn != nil {
if opts, err = l.optionsFn(prev); err != nil {
l.App().Flash().Err(err)
return
}
}
if err := l.App().inject(NewLog(l.GVR(), opts), false); err != nil {
l.App().Flash().Err(err)
}
}
// buildLogOpts(path, co, prev, false, config.DefaultLoggerTailCount),.
func (l *LogsExtender) buildLogOpts(path, co string, prevLogs bool) *dao.LogOptions {
cfg := l.App().Config.K9s.Logger
opts := dao.LogOptions{
Path: path,
Container: co,
Lines: cfg.TailCount,
Previous: prevLogs,
ShowTimestamp: cfg.ShowTime,
}
if opts.Container == "" {
opts.AllContainers = true
}
return &opts
}
func podLogOptions(app *App, fqn string, prev bool, m *metav1.ObjectMeta, spec *v1.PodSpec) *dao.LogOptions {
var (
cc = fetchContainers(m, spec, true)
cfg = app.Config.K9s.Logger
opts = dao.LogOptions{
Path: fqn,
Lines: cfg.TailCount,
SinceSeconds: cfg.SinceSeconds,
SingleContainer: len(cc) == 1,
ShowTimestamp: cfg.ShowTime,
Previous: prev,
}
)
if c, ok := dao.GetDefaultContainer(m, spec); ok {
opts.Container, opts.DefaultContainer = c, c
} else if len(cc) == 1 {
opts.Container = cc[0]
} else {
opts.AllContainers = true
}
return &opts
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/img_scan.go | internal/view/img_scan.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"runtime"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
const (
imgScanTitle = "Scans"
browseOSX = "open"
browseLinux = "sensible-browser"
cveGovURL = "https://nvd.nist.gov/vuln/detail/"
ghsaURL = "https://github.com/advisories/"
)
// ImageScan represents an image vulnerability scan view.
type ImageScan struct {
ResourceViewer
}
// NewImageScan returns a new scans view.
func NewImageScan(gvr *client.GVR) ResourceViewer {
v := ImageScan{}
v.ResourceViewer = NewBrowser(gvr)
v.AddBindKeysFn(v.bindKeys)
v.GetTable().SetEnterFn(v.viewCVE)
v.GetTable().SetSortCol("SEVERITY", true)
return &v
}
// Name returns the component name.
func (*ImageScan) Name() string { return imgScanTitle }
func (i *ImageScan) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, ui.KeyShiftN, tcell.KeyCtrlZ, tcell.KeyCtrlW)
aa.Bulk(ui.KeyMap{
ui.KeyShiftL: ui.NewKeyAction("Sort Lib", i.GetTable().SortColCmd("LIBRARY", false), true),
ui.KeyShiftS: ui.NewKeyAction("Sort Severity", i.GetTable().SortColCmd("SEVERITY", false), true),
ui.KeyShiftF: ui.NewKeyAction("Sort Fixed-in", i.GetTable().SortColCmd("FIXED-IN", false), true),
ui.KeyShiftV: ui.NewKeyAction("Sort Vulnerability", i.GetTable().SortColCmd("VULNERABILITY", false), true),
})
}
func (*ImageScan) viewCVE(app *App, _ ui.Tabular, _ *client.GVR, path string) {
bin := browseLinux
if runtime.GOOS == "darwin" {
bin = browseOSX
}
tt := strings.Split(path, "|")
if len(tt) < 7 {
app.Flash().Errf("parse path failed: %s", path)
}
cve := tt[render.CVEParseIdx]
site := cveGovURL
if strings.Index(cve, "GHSA") == 0 {
site = ghsaURL
}
site += cve
ok, errChan, _ := run(app, &shellOpts{
background: true,
binary: bin,
args: []string{site},
})
if !ok {
app.Flash().Errf("unable to run browser command")
return
}
var errs error
for e := range errChan {
errs = errors.Join(e)
}
if errs != nil {
app.Flash().Err(errs)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/priorityclass.go | internal/view/priorityclass.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// PriorityClass presents a priority class viewer.
type PriorityClass struct {
ResourceViewer
}
// NewPriorityClass returns a new viewer.
func NewPriorityClass(gvr *client.GVR) ResourceViewer {
s := PriorityClass{
ResourceViewer: NewBrowser(gvr),
}
s.AddBindKeysFn(s.bindKeys)
return &s
}
func (s *PriorityClass) bindKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyU, ui.NewKeyAction("UsedBy", s.refCmd, true))
}
func (s *PriorityClass) refCmd(evt *tcell.EventKey) *tcell.EventKey {
return scanRefs(evt, s.App(), s.GetTable(), client.PcGVR)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/table_int_test.go | internal/view/table_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"io/fs"
"os"
"testing"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/mock"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tview"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
func TestTableSave(t *testing.T) {
v := NewTable(client.NewGVR("test"))
require.NoError(t, v.Init(makeContext(t)))
v.SetTitle("k9s-test")
require.NoError(t, ensureDumpDir("/tmp/test-dumps"))
dir := v.app.Config.K9s.ContextScreenDumpDir()
c1, _ := os.ReadDir(dir)
v.saveCmd(nil)
c2, _ := os.ReadDir(dir)
assert.Len(t, c2, len(c1)+1)
}
func TestTableNew(t *testing.T) {
v := NewTable(client.NewGVR("test"))
require.NoError(t, v.Init(makeContext(t)))
data := model1.NewTableDataWithRows(
client.NewGVR("test"),
model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "FRED"},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true, Decorator: render.AgeDecorator}},
},
model1.NewRowEventsWithEvts(
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "a", "10", "3m"},
},
},
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "b", "15", "1m"},
},
},
),
)
cdata := v.Update(data, false)
v.UpdateUI(cdata, data)
assert.Equal(t, 3, v.GetRowCount())
}
func TestTableViewFilter(t *testing.T) {
v := NewTable(client.NewGVR("test"))
require.NoError(t, v.Init(makeContext(t)))
v.SetModel(&mockTableModel{})
v.Refresh()
v.CmdBuff().SetActive(true)
v.CmdBuff().SetText("blee", "", true)
assert.Equal(t, 5, v.GetRowCount())
}
func TestTableViewSort(t *testing.T) {
v := NewTable(client.NewGVR("test"))
require.NoError(t, v.Init(makeContext(t)))
v.SetModel(new(mockTableModel))
uu := map[string]struct {
sortCol string
sorted []string
reversed []string
}{
"by_name": {
sortCol: "NAME",
sorted: []string{"r0", "r1", "r2", "r3"},
reversed: []string{"r3", "r2", "r1", "r0"},
},
"by_age": {
sortCol: "AGE",
sorted: []string{"r0", "r1", "r2", "r3"},
reversed: []string{"r3", "r2", "r1", "r0"},
},
"by_fred": {
sortCol: "FRED",
sorted: []string{"r3", "r2", "r0", "r1"},
reversed: []string{"r1", "r0", "r2", "r3"},
},
}
for k := range uu {
u := uu[k]
v.SortColCmd(u.sortCol, true)(nil)
assert.Len(t, u.sorted, v.GetRowCount()-1)
for i, s := range u.sorted {
assert.Equal(t, s, v.GetCell(i+1, 0).Text)
}
v.SortInvertCmd(nil)
assert.Len(t, u.reversed, v.GetRowCount()-1)
for i, s := range u.reversed {
assert.Equal(t, s, v.GetCell(i+1, 0).Text)
}
}
}
// ----------------------------------------------------------------------------
// Helpers...
type mockTableModel struct{}
var _ ui.Tabular = (*mockTableModel)(nil)
func (*mockTableModel) SetViewSetting(context.Context, *config.ViewSetting) {}
func (*mockTableModel) SetInstance(string) {}
func (*mockTableModel) SetLabelSelector(labels.Selector) {}
func (*mockTableModel) GetLabelSelector() labels.Selector { return nil }
func (*mockTableModel) Empty() bool { return false }
func (*mockTableModel) RowCount() int { return 1 }
func (*mockTableModel) HasMetrics() bool { return true }
func (*mockTableModel) Peek() *model1.TableData { return makeTableData() }
func (*mockTableModel) Refresh(context.Context) error { return nil }
func (*mockTableModel) ClusterWide() bool { return false }
func (*mockTableModel) GetNamespace() string { return "blee" }
func (*mockTableModel) SetNamespace(string) {}
func (*mockTableModel) ToggleToast() {}
func (*mockTableModel) AddListener(model.TableListener) {}
func (*mockTableModel) RemoveListener(model.TableListener) {}
func (*mockTableModel) Watch(context.Context) error { return nil }
func (*mockTableModel) Get(context.Context, string) (runtime.Object, error) {
return nil, nil
}
func (*mockTableModel) Delete(context.Context, string, *metav1.DeletionPropagation, dao.Grace) error {
return nil
}
func (*mockTableModel) Describe(context.Context, string) (string, error) {
return "", nil
}
func (*mockTableModel) ToYAML(context.Context, string) (string, error) {
return "", nil
}
func (*mockTableModel) InNamespace(string) bool { return true }
func (*mockTableModel) SetRefreshRate(time.Duration) {}
func makeTableData() *model1.TableData {
return model1.NewTableDataWithRows(
client.NewGVR("test"),
model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "FRED"},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
},
model1.NewRowEventsWithEvts(
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "r3", "10", "3y125d"},
},
},
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "r2", "15", "2y12d"},
},
Deltas: model1.DeltaRow{"", "", "20", ""},
},
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "r1", "20", "19h"},
},
},
model1.RowEvent{
Row: model1.Row{
Fields: model1.Fields{"ns1", "r0", "15", "10s"},
},
},
),
)
}
func makeContext(t *testing.T) context.Context {
a := NewApp(mock.NewMockConfig(t))
ctx := context.WithValue(context.Background(), internal.KeyApp, a)
return context.WithValue(ctx, internal.KeyStyles, a.Styles)
}
func ensureDumpDir(n string) error {
config.AppDumpsDir = n
if _, err := os.Stat(n); errors.Is(err, fs.ErrNotExist) {
return os.Mkdir(n, 0700)
}
if err := os.RemoveAll(n); err != nil {
return err
}
return os.Mkdir(n, 0700)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/env.go | internal/view/env.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"log/slog"
"regexp"
"sort"
"strconv"
"strings"
"github.com/derailed/k9s/internal/slogs"
)
// Env represent K9s and K8s available environment variables.
type Env map[string]string
// EnvRX match $XXX, $!XXX, ${XXX} or ${!XXX} custom arg.
// |
// | (g2)(group 3) (g5)( group 6 )
// | ( group 1 ) ( group 4 )
// | ( group 0 )
var envRX = regexp.MustCompile(`(\$(!?)([\w\-]+))|(\$\{(!?)([\w\-%/: ]+)})`)
// keyFromSubmatch extracts the name and inverse flag of a match.
func keyFromSubmatch(m []string) (key string, inverse bool) {
// group 1 matches $XXX and $!XXX args.
if m[1] != "" {
return m[3], m[2] == "!"
}
// group 4 matches ${XXX} and ${!XXX} args.
return m[6], m[5] == "!"
}
// Substitute replaces env variable keys from in a string with their corresponding values.
func (e Env) Substitute(arg string) (string, error) {
matches := envRX.FindAllStringSubmatch(arg, -1)
if len(matches) == 0 {
return arg, nil
}
// To prevent the substitution starts with the shorter environment variable,
// sort with the length of the found environment variables.
sort.Slice(matches, func(i, j int) bool {
return len(matches[i][0]) > len(matches[j][0])
})
for _, m := range matches {
key, inverse := keyFromSubmatch(m)
v, ok := e[strings.ToUpper(key)]
if !ok {
slog.Warn("No k9s environment matching key",
slogs.Matches, matches,
slogs.Key, key,
)
continue
}
if b, err := strconv.ParseBool(v); err == nil {
if inverse {
b = !b
}
v = fmt.Sprintf("%t", b)
}
arg = strings.ReplaceAll(arg, m[0], v)
}
return arg, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/context.go | internal/view/context.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
const (
renamePage = "rename"
inputField = "New name:"
)
// Context presents a context viewer.
type Context struct {
ResourceViewer
}
// NewContext returns a new viewer.
func NewContext(gvr *client.GVR) ResourceViewer {
c := Context{
ResourceViewer: NewBrowser(gvr),
}
c.GetTable().SetEnterFn(c.useCtx)
c.AddBindKeysFn(c.bindKeys)
return &c
}
func (c *Context) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, tcell.KeyCtrlSpace, ui.KeySpace)
if !c.App().Config.IsReadOnly() {
c.bindDangerousKeys(aa)
}
}
func (c *Context) bindDangerousKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyR, ui.NewKeyAction("Rename", c.renameCmd, true))
aa.Add(tcell.KeyCtrlD, ui.NewKeyAction("Delete", c.deleteCmd, true))
}
func (c *Context) renameCmd(evt *tcell.EventKey) *tcell.EventKey {
contextName := c.GetTable().GetSelectedItem()
if contextName == "" {
return evt
}
c.showRenameModal(contextName, c.renameDialogCallback)
return nil
}
func (c *Context) deleteCmd(evt *tcell.EventKey) *tcell.EventKey {
contextName := c.GetTable().GetSelectedItem()
if contextName == "" {
return evt
}
d := c.App().Styles.Dialog()
dialog.ShowConfirm(&d, c.App().Content.Pages, "Delete", fmt.Sprintf("Delete context %q?", contextName), func() {
if err := c.App().factory.Client().Config().DelContext(contextName); err != nil {
c.App().Flash().Err(err)
return
}
c.Refresh()
}, func() {})
return nil
}
func (c *Context) renameDialogCallback(form *tview.Form, contextName string) error {
app := c.App()
input := form.GetFormItemByLabel(inputField).(*tview.InputField)
if err := app.factory.Client().Config().RenameContext(contextName, input.GetText()); err != nil {
c.App().Flash().Err(err)
return nil
}
c.Refresh()
return nil
}
func (c *Context) showRenameModal(name string, ok func(form *tview.Form, contextName string) error) {
app := c.App()
styles := app.Styles.Dialog()
f := tview.NewForm().
SetItemPadding(0).
SetButtonsAlign(tview.AlignCenter).
SetButtonBackgroundColor(styles.ButtonBgColor.Color()).
SetButtonTextColor(styles.ButtonFgColor.Color()).
SetLabelColor(styles.LabelFgColor.Color()).
SetFieldTextColor(styles.FieldFgColor.Color())
f.AddInputField(inputField, name, 0, nil, nil).
AddButton("OK", func() {
if err := ok(f, name); err != nil {
app.Flash().Err(err)
return
}
app.Content.Pages.RemovePage(renamePage)
}).
AddButton("Cancel", func() {
app.Content.RemovePage(renamePage)
})
m := tview.NewModalForm("<Rename>", f)
m.SetText(fmt.Sprintf("Rename context %q?", name))
m.SetDoneFunc(func(int, string) {
app.Content.RemovePage(renamePage)
})
app.Content.AddPage(renamePage, m, false, false)
app.Content.ShowPage(renamePage)
for i := range f.GetButtonCount() {
f.GetButton(i).
SetBackgroundColorActivated(styles.ButtonFocusBgColor.Color()).
SetLabelColorActivated(styles.ButtonFocusFgColor.Color())
}
}
func (c *Context) useCtx(app *App, _ ui.Tabular, gvr *client.GVR, path string) {
slog.Debug("Using context",
slogs.GVR, gvr,
slogs.FQN, path,
)
if err := useContext(app, path); err != nil {
app.Flash().Err(err)
return
}
c.App().clearHistory()
c.Refresh()
c.GetTable().Select(1, 0)
}
func useContext(app *App, name string) error {
if app.Content.Top() != nil {
app.Content.Top().Stop()
}
res, err := dao.AccessorFor(app.factory, client.CtGVR)
if err != nil {
return err
}
switcher, ok := res.(dao.Switchable)
if !ok {
return errors.New("expecting a switchable resource")
}
app.Config.K9s.ToggleContextSwitch(true)
defer app.Config.K9s.ToggleContextSwitch(false)
// Save config prior to context switch...
if err := app.Config.Save(true); err != nil {
slog.Error("Fail to save config to disk", slogs.Subsys, "config", slogs.Error, err)
}
if err := switcher.Switch(name); err != nil {
slog.Error("Context switch failed during use command", slogs.Error, err)
return err
}
return app.switchContext(cmd.NewInterpreter("ctx "+name), true)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/helm_chart.go | internal/view/helm_chart.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// HelmChart represents a helm chart view.
type HelmChart struct {
ResourceViewer
}
// NewHelmChart returns a new helm-chart view.
func NewHelmChart(gvr *client.GVR) ResourceViewer {
c := HelmChart{
ResourceViewer: NewValueExtender(NewBrowser(gvr)),
}
c.GetTable().SetBorderFocusColor(tcell.ColorMediumSpringGreen)
c.GetTable().SetSelectedStyle(tcell.StyleDefault.
Foreground(tcell.ColorWhite).
Background(tcell.ColorMediumSpringGreen).Attributes(tcell.AttrNone))
c.AddBindKeysFn(c.bindKeys)
c.GetTable().SetEnterFn(c.viewReleases)
c.SetContextFn(c.chartContext)
return &c
}
func (*HelmChart) chartContext(ctx context.Context) context.Context {
return ctx
}
func (c *HelmChart) bindKeys(aa *ui.KeyActions) {
aa.Delete(tcell.KeyCtrlS)
aa.Bulk(ui.KeyMap{
ui.KeyR: ui.NewKeyAction("Releases", c.historyCmd, true),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", c.GetTable().SortColCmd(statusCol, true), false),
})
}
func (c *HelmChart) viewReleases(app *App, _ ui.Tabular, _ *client.GVR, _ string) {
v := NewHistory(client.HmhGVR)
v.SetContextFn(c.helmContext)
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func (c *HelmChart) historyCmd(evt *tcell.EventKey) *tcell.EventKey {
path := c.GetTable().GetSelectedItem()
if path == "" {
return evt
}
c.viewReleases(c.App(), c.GetTable().GetModel(), c.GVR(), path)
return nil
}
func (c *HelmChart) helmContext(ctx context.Context) context.Context {
path := c.GetTable().GetSelectedItem()
if path == "" {
return ctx
}
ctx = context.WithValue(ctx, internal.KeyFQN, path)
return context.WithValue(ctx, internal.KeyPath, path)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/dp_test.go | internal/view/dp_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDeploy(t *testing.T) {
v := view.NewDeploy(client.DpGVR)
require.NoError(t, v.Init(makeCtx(t)))
assert.Equal(t, "Deployments", v.Name())
assert.Len(t, v.Hints(), 17)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/svc_test.go | internal/view/svc_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func init() {
dao.MetaAccess.RegisterMeta(client.DirGVR.String(), &metav1.APIResource{
Name: "dirs",
SingularName: "dir",
Kind: "Directory",
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.PodGVR.String(), &metav1.APIResource{
Name: "pods",
SingularName: "pod",
Namespaced: true,
Kind: "Pods",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.NsGVR.String(), &metav1.APIResource{
Name: "namespaces",
SingularName: "namespace",
Namespaced: true,
Kind: "Namespaces",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.SvcGVR.String(), &metav1.APIResource{
Name: "services",
SingularName: "service",
Namespaced: true,
Kind: "Services",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.SecGVR.String(), &metav1.APIResource{
Name: "secrets",
SingularName: "secret",
Namespaced: true,
Kind: "Secrets",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.PcGVR.String(), &metav1.APIResource{
Name: "priorityclasses",
SingularName: "priorityclass",
Namespaced: false,
Kind: "PriorityClass",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.CmGVR.String(), &metav1.APIResource{
Name: "configmaps",
SingularName: "configmap",
Namespaced: true,
Kind: "ConfigMaps",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.RefGVR.String(), &metav1.APIResource{
Name: "references",
SingularName: "reference",
Namespaced: true,
Kind: "References",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.AliGVR.String(), &metav1.APIResource{
Name: "aliases",
SingularName: "alias",
Namespaced: true,
Kind: "Aliases",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.CoGVR.String(), &metav1.APIResource{
Name: "containers",
SingularName: "container",
Namespaced: true,
Kind: "Containers",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.CtGVR.String(), &metav1.APIResource{
Name: "contexts",
SingularName: "context",
Namespaced: true,
Kind: "Contexts",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta("subjects", &metav1.APIResource{
Name: "subjects",
SingularName: "subject",
Namespaced: true,
Kind: "Subjects",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.RbacGVR.String(), &metav1.APIResource{
Name: "rbacs",
SingularName: "rbac",
Namespaced: true,
Kind: "Rbac",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.PfGVR.String(), &metav1.APIResource{
Name: "portforwards",
SingularName: "portforward",
Namespaced: true,
Kind: "PortForwards",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.SdGVR.String(), &metav1.APIResource{
Name: "screendumps",
SingularName: "screendump",
Namespaced: true,
Kind: "ScreenDumps",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.StsGVR.String(), &metav1.APIResource{
Name: "statefulsets",
SingularName: "statefulset",
Namespaced: true,
Kind: "StatefulSets",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.DsGVR.String(), &metav1.APIResource{
Name: "daemonsets",
SingularName: "daemonset",
Namespaced: true,
Kind: "DaemonSets",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.DpGVR.String(), &metav1.APIResource{
Name: "deployments",
SingularName: "deployment",
Namespaced: true,
Kind: "Deployments",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
dao.MetaAccess.RegisterMeta(client.PvcGVR.String(), &metav1.APIResource{
Name: "persistentvolumeclaims",
SingularName: "persistentvolumeclaim",
Namespaced: true,
Kind: "PersistentVolumeClaims",
Verbs: []string{"get", "list", "watch", "delete"},
Categories: []string{"k9s"},
})
}
func TestServiceNew(t *testing.T) {
s := view.NewService(client.SvcGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "Services", s.Name())
assert.Len(t, s.Hints(), 13)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/event.go | internal/view/event.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// Event represents a command alias view.
type Event struct {
ResourceViewer
}
// NewEvent returns a new alias view.
func NewEvent(gvr *client.GVR) ResourceViewer {
e := Event{
ResourceViewer: NewBrowser(gvr),
}
e.AddBindKeysFn(e.bindKeys)
e.GetTable().SetSortCol("LAST SEEN", false)
return &e
}
func (e *Event) bindKeys(aa *ui.KeyActions) {
aa.Delete(tcell.KeyCtrlD, ui.KeyE, ui.KeyA)
aa.Bulk(ui.KeyMap{
tcell.KeyCtrlZ: ui.NewKeyAction("Toggle Warnings/Errors", e.toggleWarnErrorCmd, false),
ui.KeyShiftL: ui.NewKeyAction("Sort LastSeen", e.GetTable().SortColCmd("LAST SEEN", false), false),
ui.KeyShiftF: ui.NewKeyAction("Sort FirstSeen", e.GetTable().SortColCmd("FIRST SEEN", false), false),
ui.KeyShiftT: ui.NewKeyAction("Sort Type", e.GetTable().SortColCmd("TYPE", true), false),
ui.KeyShiftR: ui.NewKeyAction("Sort Reason", e.GetTable().SortColCmd("REASON", true), false),
ui.KeyShiftS: ui.NewKeyAction("Sort Source", e.GetTable().SortColCmd("SOURCE", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort Count", e.GetTable().SortColCmd("COUNT", true), false),
})
}
func (e *Event) toggleWarnErrorCmd(*tcell.EventKey) *tcell.EventKey {
b, ok := e.ResourceViewer.(*Browser)
if !ok {
return nil
}
filter := b.CmdBuff().GetText()
if filter == "Warning|Error" {
e.SetFilter("", true)
e.App().Flash().Info("Showing all events")
} else {
e.SetFilter("Warning|Error", true)
e.App().Flash().Info("Showing Warning and Error events only")
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/registrar.go | internal/view/registrar.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"github.com/derailed/k9s/internal/client"
)
func loadCustomViewers() MetaViewers {
m := make(MetaViewers, 30)
coreViewers(m)
miscViewers(m)
appsViewers(m)
rbacViewers(m)
batchViewers(m)
crdViewers(m)
helmViewers(m)
return m
}
func helmViewers(vv MetaViewers) {
vv[client.HmGVR] = MetaViewer{
viewerFn: NewHelmChart,
}
}
func coreViewers(vv MetaViewers) {
vv[client.NsGVR] = MetaViewer{
viewerFn: NewNamespace,
}
vv[client.EvGVR] = MetaViewer{
viewerFn: NewEvent,
}
vv[client.PodGVR] = MetaViewer{
viewerFn: NewPod,
}
vv[client.SvcGVR] = MetaViewer{
viewerFn: NewService,
}
vv[client.NodeGVR] = MetaViewer{
viewerFn: NewNode,
}
vv[client.SecGVR] = MetaViewer{
viewerFn: NewSecret,
}
vv[client.PcGVR] = MetaViewer{
viewerFn: NewPriorityClass,
}
vv[client.CmGVR] = MetaViewer{
viewerFn: NewConfigMap,
}
vv[client.SaGVR] = MetaViewer{
viewerFn: NewServiceAccount,
}
vv[client.PvcGVR] = MetaViewer{
viewerFn: NewPersistentVolumeClaim,
}
}
func miscViewers(vv MetaViewers) {
vv[client.WkGVR] = MetaViewer{
viewerFn: NewWorkload,
}
vv[client.CtGVR] = MetaViewer{
viewerFn: NewContext,
}
vv[client.CoGVR] = MetaViewer{
viewerFn: NewContainer,
}
vv[client.ScnGVR] = MetaViewer{
viewerFn: NewImageScan,
}
vv[client.PfGVR] = MetaViewer{
viewerFn: NewPortForward,
}
vv[client.SdGVR] = MetaViewer{
viewerFn: NewScreenDump,
}
vv[client.BeGVR] = MetaViewer{
viewerFn: NewBenchmark,
}
vv[client.AliGVR] = MetaViewer{
viewerFn: NewAlias,
}
vv[client.RefGVR] = MetaViewer{
viewerFn: NewReference,
}
vv[client.PuGVR] = MetaViewer{
viewerFn: NewPulse,
}
}
func appsViewers(vv MetaViewers) {
vv[client.DpGVR] = MetaViewer{
viewerFn: NewDeploy,
}
vv[client.RsGVR] = MetaViewer{
viewerFn: NewReplicaSet,
}
vv[client.StsGVR] = MetaViewer{
viewerFn: NewStatefulSet,
}
vv[client.DsGVR] = MetaViewer{
viewerFn: NewDaemonSet,
}
}
func rbacViewers(vv MetaViewers) {
vv[client.RbacGVR] = MetaViewer{
enterFn: showRules,
}
vv[client.UsrGVR] = MetaViewer{
viewerFn: NewUser,
}
vv[client.GrpGVR] = MetaViewer{
viewerFn: NewGroup,
}
vv[client.CrGVR] = MetaViewer{
enterFn: showRules,
}
vv[client.CrbGVR] = MetaViewer{
enterFn: showRules,
}
vv[client.RoGVR] = MetaViewer{
enterFn: showRules,
}
vv[client.RobGVR] = MetaViewer{
enterFn: showRules,
}
}
func batchViewers(vv MetaViewers) {
vv[client.CjGVR] = MetaViewer{
viewerFn: NewCronJob,
}
vv[client.JobGVR] = MetaViewer{
viewerFn: NewJob,
}
}
func crdViewers(vv MetaViewers) {
vv[client.CrdGVR] = MetaViewer{
viewerFn: NewCRD,
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pf_dialog.go | internal/view/pf_dialog.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"log/slog"
"math"
"strconv"
"strings"
"github.com/derailed/k9s/internal/port"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tview"
)
const portForwardKey = "portforward"
// PortForwardCB represents a port-forward callback function.
type PortForwardCB func(ResourceViewer, string, port.PortTunnels) error
// ShowPortForwards pops a port forwarding configuration dialog.
func ShowPortForwards(v ResourceViewer, path string, ports port.ContainerPortSpecs, aa port.Annotations, okFn PortForwardCB) {
styles := v.App().Styles.Dialog()
f := tview.NewForm()
f.SetItemPadding(0)
f.SetButtonsAlign(tview.AlignCenter).
SetButtonBackgroundColor(styles.ButtonBgColor.Color()).
SetButtonTextColor(styles.ButtonFgColor.Color()).
SetLabelColor(styles.LabelFgColor.Color()).
SetFieldTextColor(styles.FieldFgColor.Color()).
SetFieldBackgroundColor(styles.BgColor.Color())
pf, err := aa.PreferredPorts(ports)
if err != nil {
slog.Warn("Unable to resolve preferred ports",
slogs.FQN, path,
slogs.Error, err,
)
}
p1, p2 := pf.ToPortSpec(ports)
fieldLen := int(math.Max(30, float64(len(p1))))
f.AddInputField("Container Port:", p1, fieldLen, nil, nil)
f.AddInputField("Local Port:", p2, fieldLen, nil, nil)
coField := f.GetFormItemByLabel("Container Port:").(*tview.InputField)
loField := f.GetFormItemByLabel("Local Port:").(*tview.InputField)
if coField.GetText() == "" {
coField.SetPlaceholder("Enter a container name::port")
}
coField.SetChangedFunc(func(s string) {
p := extractPort(s)
loField.SetText(p)
p2 = p
})
if loField.GetText() == "" {
loField.SetPlaceholder("Enter a local port")
}
address := v.App().Config.K9s.PortForwardAddress
f.AddInputField("Address:", address, fieldLen, nil, func(h string) {
address = h
})
for i := range 3 {
if field, ok := f.GetFormItem(i).(*tview.InputField); ok {
field.SetLabelColor(styles.LabelFgColor.Color())
field.SetFieldTextColor(styles.FieldFgColor.Color())
}
}
f.AddButton("OK", func() {
if coField.GetText() == "" || loField.GetText() == "" {
v.App().Flash().Err(fmt.Errorf("container to local port mismatch"))
return
}
tt, err := port.ToTunnels(address, coField.GetText(), loField.GetText())
if err != nil {
v.App().Flash().Err(err)
return
}
if err := okFn(v, path, tt); err != nil {
v.App().Flash().Err(err)
}
})
pages := v.App().Content.Pages
f.AddButton("Cancel", func() {
DismissPortForwards(v, pages)
})
for i := range 2 {
if b := f.GetButton(i); b != nil {
b.SetBackgroundColorActivated(styles.ButtonFocusBgColor.Color())
b.SetLabelColorActivated(styles.ButtonFocusFgColor.Color())
}
}
modal := tview.NewModalForm("<PortForward>", f)
msg := path
if len(ports) > 1 {
msg += "\n\nExposed Ports:\n" + ports.Dump()
}
modal.SetText(msg)
modal.SetTextColor(styles.FgColor.Color())
modal.SetBackgroundColor(styles.BgColor.Color())
modal.SetDoneFunc(func(int, string) {
DismissPortForwards(v, pages)
})
pages.AddPage(portForwardKey, modal, false, true)
pages.ShowPage(portForwardKey)
v.App().SetFocus(pages.GetPrimitive(portForwardKey))
}
// DismissPortForwards dismiss the port forward dialog.
func DismissPortForwards(v ResourceViewer, p *ui.Pages) {
p.RemovePage(portForwardKey)
v.App().SetFocus(p.CurrentPage().Item)
}
// ----------------------------------------------------------------------------
// Helpers...
func extractPort(p string) string {
tokens := strings.Split(p, "::")
if len(tokens) < 2 {
ports := strings.Split(p, ",")
for _, t := range ports {
if _, err := strconv.Atoi(strings.TrimSpace(t)); err != nil {
return ""
}
}
return p
}
return tokens[1]
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/app_test.go | internal/view/app_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/config/mock"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
)
func TestAppNew(t *testing.T) {
a := view.NewApp(mock.NewMockConfig(t))
_ = a.Init("blee", 10)
assert.Equal(t, 14, a.GetActions().Len())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/picker.go | internal/view/picker.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"k8s.io/apimachinery/pkg/labels"
)
// Picker represents a container picker.
type Picker struct {
*tview.List
actions ui.KeyActions
}
// NewPicker returns a new picker.
func NewPicker() *Picker {
return &Picker{
List: tview.NewList(),
actions: *ui.NewKeyActions(),
}
}
func (*Picker) SetCommand(*cmd.Interpreter) {}
func (*Picker) SetFilter(string, bool) {}
func (*Picker) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the view.
func (p *Picker) Init(ctx context.Context) error {
app, err := extractApp(ctx)
if err != nil {
return err
}
pickerView := app.Styles.Views().Picker
p.actions.Add(tcell.KeyEscape, ui.NewKeyAction("Back", app.PrevCmd, true))
p.SetBorder(true)
p.SetMainTextColor(pickerView.MainColor.Color())
p.ShowSecondaryText(false)
p.SetShortcutColor(pickerView.ShortcutColor.Color())
p.SetSelectedBackgroundColor(pickerView.FocusColor.Color())
p.SetTitle(fmt.Sprintf(" [%s::b]Containers Picker ", app.Styles.Frame().Title.FgColor.String()))
p.SetInputCapture(func(evt *tcell.EventKey) *tcell.EventKey {
if a, ok := p.actions.Get(evt.Key()); ok {
a.Action(evt)
evt = nil
}
return evt
})
return nil
}
// InCmdMode checks if prompt is active.
func (*Picker) InCmdMode() bool {
return false
}
// Start starts the view.
func (*Picker) Start() {}
// Stop stops the view.
func (*Picker) Stop() {}
// Name returns the component name.
func (*Picker) Name() string { return "picker" }
// Hints returns the view hints.
func (p *Picker) Hints() model.MenuHints {
return p.actions.Hints()
}
// ExtraHints returns additional hints.
func (*Picker) ExtraHints() map[string]string {
return nil
}
func (p *Picker) populate(ss []string) {
p.Clear()
for i, s := range ss {
p.AddItem(s, "Select a container", rune('a'+i), nil)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/dir_int_test.go | internal/view/dir_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestIsManifest(t *testing.T) {
uu := map[string]struct {
file string
e bool
}{
"yaml": {file: "fred.yaml", e: true},
"yml": {file: "fred.yml", e: true},
"nope": {file: "fred.txt"},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, isManifest(u.file))
})
}
}
func TestIsKustomized(t *testing.T) {
uu := map[string]struct {
path string
e bool
}{
"toast": {path: "testdata/fred"},
"yaml": {path: "testdata/kmanifests", e: true},
"yml": {path: "testdata/k1manifests", e: true},
"noExt": {path: "testdata/k2manifests", e: true},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, isKustomized(u.path))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pf_extender_test.go | internal/view/pf_extender_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/watch"
"github.com/stretchr/testify/require"
corev1 "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/informers"
)
func TestEnsurePodPortFwdAllowed(t *testing.T) {
uu := map[string]struct {
podExists bool
podPhase corev1.PodPhase
expectError bool
}{
"pod-not-exist": {
expectError: true,
},
"pod-pending": {
podExists: true,
podPhase: corev1.PodPending,
expectError: true,
},
"pod-running": {
podExists: true,
podPhase: corev1.PodRunning,
expectError: false,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
f := testFactory{}
if u.podExists {
f.expectedGet = &unstructured.Unstructured{
Object: map[string]any{
"status": map[string]any{
"phase": u.podPhase,
},
},
}
}
err := ensurePodPortFwdAllowed(f, "ns/name")
if u.expectError {
require.Error(t, err)
return
}
require.NoError(t, err)
})
}
}
type testFactory struct {
expectedGet runtime.Object
}
var _ dao.Factory = testFactory{}
func (testFactory) Client() client.Connection {
return nil
}
func (t testFactory) Get(*client.GVR, string, bool, labels.Selector) (runtime.Object, error) {
if t.expectedGet != nil {
return t.expectedGet, nil
}
return nil, errors.New("not found")
}
func (testFactory) List(*client.GVR, string, bool, labels.Selector) ([]runtime.Object, error) {
return nil, 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) Forwarders() watch.Forwarders {
return nil
}
func (testFactory) WaitForCacheSync() {}
func (testFactory) DeleteForwarder(string) {}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/secret_test.go | internal/view/secret_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSecretNew(t *testing.T) {
s := view.NewSecret(client.SecGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "Secrets", s.Name())
assert.Len(t, s.Hints(), 9)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pulse.go | internal/view/pulse.go | package view
import (
"context"
"fmt"
"image"
"log/slog"
"time"
"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/model"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/tchart"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"golang.org/x/text/cases"
"golang.org/x/text/language"
"k8s.io/apimachinery/pkg/labels"
)
const (
cpuFmt = " %s [%s::b]%s[white::-]([%s::]%sm[white::]/[%s::]%sm[-::])"
memFmt = " %s [%s::b]%s[white::-]([%s::]%sMi[white::]/[%s::]%sMi[-::])"
pulseTitle = "Pulses"
NSTitleFmt = "[fg:bg:b] %s([hilite:bg:b]%s[fg:bg:-])[fg:bg:-] "
dirLeft = 1
dirRight = -dirLeft
dirDown = 4
dirUp = -dirDown
grayC = "gray"
)
var corpusGVRs = append(model.PulseGVRs, client.CpuGVR, client.MemGVR)
type Charts map[*client.GVR]Graphable
// Graphable represents a graphic component.
type Graphable interface {
tview.Primitive
// ID returns the graph id.
ID() string
// Add adds a metric
Add(ok, fault int)
AddMetric(time.Time, float64)
// SetLegend sets the graph legend
SetLegend(string)
SetColorIndex(int)
SetMax(float64)
GetMax() float64
// SetSeriesColors sets charts series colors.
SetSeriesColors(...tcell.Color)
// GetSeriesColorNames returns the series color names.
GetSeriesColorNames() []string
// SetFocusColorNames sets the focus color names.
SetFocusColorNames(fg, bg string)
// SetBackgroundColor sets chart bg color.
SetBackgroundColor(tcell.Color)
SetBorderColor(tcell.Color) *tview.Box
// IsDial returns true if chart is a dial
IsDial() bool
}
// Pulse represents a command health view.
type Pulse struct {
*tview.Grid
app *App
gvr *client.GVR
model *model.Pulse
cancelFn context.CancelFunc
actions *ui.KeyActions
charts Charts
prevFocusIndex int
chartGVRs client.GVRs
}
// NewPulse returns a new alias view.
func NewPulse(gvr *client.GVR) ResourceViewer {
return &Pulse{
Grid: tview.NewGrid(),
model: model.NewPulse(gvr),
actions: ui.NewKeyActions(),
prevFocusIndex: -1,
}
}
// Init initializes the view.
func (p *Pulse) Init(ctx context.Context) error {
p.SetBorder(true)
p.SetGap(0, 0)
p.SetBorderPadding(0, 0, 1, 1)
var err error
if p.app, err = extractApp(ctx); err != nil {
return err
}
ns := p.app.Config.ActiveNamespace()
frame := p.app.Styles.Frame()
p.SetTitle(ui.SkinTitle(fmt.Sprintf(NSTitleFmt, pulseTitle, ns), &frame))
index, chartRow := 4, 6
if client.IsAllNamespace(ns) {
index, chartRow = 0, 8
}
p.chartGVRs = corpusGVRs[index:]
p.charts = make(Charts, len(p.chartGVRs))
var x, y, col int
for _, gvr := range p.chartGVRs[:len(p.chartGVRs)-2] {
p.charts[gvr] = p.makeGA(image.Point{X: x, Y: y}, image.Point{X: 2, Y: 2}, gvr)
col, y = col+1, y+2
if y > 6 {
y = 0
}
if col >= 4 {
col, x = 0, x+2
}
}
if p.app.Conn().HasMetrics() {
p.charts[client.CpuGVR] = p.makeSP(image.Point{X: chartRow, Y: 0}, image.Point{X: 2, Y: 4}, client.CpuGVR, "c")
p.charts[client.MemGVR] = p.makeSP(image.Point{X: chartRow, Y: 4}, image.Point{X: 2, Y: 4}, client.MemGVR, "Gi")
}
p.GetItem(0).Focus = true
p.app.SetFocus(p.charts[p.chartGVRs[0]])
p.bindKeys()
p.app.Styles.AddListener(p)
p.StylesChanged(p.app.Styles)
p.model.SetNamespace(ns)
return nil
}
// InCmdMode checks if prompt is active.
func (*Pulse) InCmdMode() bool {
return false
}
func (*Pulse) SetCommand(*cmd.Interpreter) {}
func (*Pulse) SetFilter(string, bool) {}
func (*Pulse) SetLabelSelector(labels.Selector, bool) {}
// StylesChanged notifies the skin changed.
func (p *Pulse) StylesChanged(s *config.Styles) {
p.SetBackgroundColor(s.Charts().BgColor.Color())
for _, c := range p.charts {
c.SetFocusColorNames(s.Charts().FocusFgColor.String(), s.Charts().FocusBgColor.String())
if c.IsDial() {
c.SetBackgroundColor(s.Charts().DialBgColor.Color())
c.SetSeriesColors(s.Charts().DefaultDialColors.Colors()...)
} else {
c.SetBackgroundColor(s.Charts().ChartBgColor.Color())
c.SetSeriesColors(s.Charts().DefaultChartColors.Colors()...)
}
if ss, ok := s.Charts().ResourceColors[c.ID()]; ok {
c.SetSeriesColors(ss.Colors()...)
}
}
}
// SeriesChanged update cluster time series.
func (p *Pulse) SeriesChanged(tt dao.TimeSeries) {
if len(tt) == 0 {
return
}
cpu, ok := p.charts[client.CpuGVR]
if !ok {
return
}
mem := p.charts[client.MemGVR]
if !ok {
return
}
for i := range tt {
t := tt[i]
cpu.SetMax(float64(t.Value.AllocatableCPU))
mem.SetMax(float64(t.Value.AllocatableMEM))
cpu.AddMetric(t.Time, float64(t.Value.CurrentCPU))
mem.AddMetric(t.Time, float64(t.Value.CurrentMEM))
}
last := tt[len(tt)-1]
perc := client.ToPercentage(last.Value.CurrentCPU, int64(cpu.GetMax()))
index := int(p.app.Config.K9s.Thresholds.LevelFor("cpu", perc))
cpu.SetColorIndex(int(p.app.Config.K9s.Thresholds.LevelFor("cpu", perc)))
nn := cpu.GetSeriesColorNames()
if last.Value.CurrentCPU == 0 {
nn[0] = grayC
}
if last.Value.AllocatableCPU == 0 {
nn[1] = grayC
}
cpu.SetLegend(fmt.Sprintf(cpuFmt,
cases.Title(language.English).String(client.CpuGVR.R()),
p.app.Config.K9s.Thresholds.SeverityColor("cpu", perc),
render.PrintPerc(perc),
nn[index],
render.AsThousands(last.Value.CurrentCPU),
"white",
render.AsThousands(int64(cpu.GetMax())),
))
nn = mem.GetSeriesColorNames()
if last.Value.CurrentMEM == 0 {
nn[0] = grayC
}
if last.Value.AllocatableMEM == 0 {
nn[1] = grayC
}
perc = client.ToPercentage(last.Value.CurrentMEM, int64(mem.GetMax()))
index = int(p.app.Config.K9s.Thresholds.LevelFor("memory", perc))
mem.SetColorIndex(index)
mem.SetLegend(fmt.Sprintf(memFmt,
cases.Title(language.English).String(client.MemGVR.R()),
p.app.Config.K9s.Thresholds.SeverityColor("memory", perc),
render.PrintPerc(perc),
nn[index],
render.AsThousands(last.Value.CurrentMEM),
"white",
render.AsThousands(int64(mem.GetMax())),
))
}
// PulseChanged notifies the model data changed.
func (p *Pulse) PulseChanged(pt model.HealthPoint) {
v, ok := p.charts[pt.GVR]
if !ok {
return
}
nn := v.GetSeriesColorNames()
if pt.Total == 0 {
nn[0] = grayC
}
if pt.Faults == 0 {
nn[1] = grayC
}
v.SetLegend(cases.Title(language.English).String(pt.GVR.R()))
if pt.Faults > 0 {
v.SetBorderColor(tcell.ColorDarkRed)
} else {
v.SetBorderColor(tcell.ColorDarkOliveGreen)
}
v.Add(pt.Total, pt.Faults)
}
// PulseFailed notifies the load failed.
func (p *Pulse) PulseFailed(err error) {
p.app.Flash().Err(err)
}
func (p *Pulse) bindKeys() {
p.actions.Merge(ui.NewKeyActionsFromMap(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("Goto", p.enterCmd, true),
tcell.KeyTab: ui.NewKeyAction("Next", p.nextFocusCmd(dirLeft), true),
tcell.KeyBacktab: ui.NewKeyAction("Prev", p.nextFocusCmd(dirRight), true),
tcell.KeyDown: ui.NewKeyAction("Down", p.nextFocusCmd(dirDown), false),
tcell.KeyUp: ui.NewKeyAction("Up", p.nextFocusCmd(dirUp), false),
tcell.KeyRight: ui.NewKeyAction("Next", p.nextFocusCmd(dirLeft), false),
tcell.KeyLeft: ui.NewKeyAction("Prev", p.nextFocusCmd(dirRight), false),
ui.KeyH: ui.NewKeyAction("Prev", p.nextFocusCmd(dirRight), false),
ui.KeyJ: ui.NewKeyAction("Down", p.nextFocusCmd(dirDown), false),
ui.KeyK: ui.NewKeyAction("Up", p.nextFocusCmd(dirUp), false),
ui.KeyL: ui.NewKeyAction("Next", p.nextFocusCmd(dirLeft), false),
}))
}
func (p *Pulse) keyboard(evt *tcell.EventKey) *tcell.EventKey {
key := evt.Key()
if key == tcell.KeyRune {
key = tcell.Key(evt.Rune())
}
if a, ok := p.actions.Get(key); ok {
return a.Action(evt)
}
return evt
}
func (p *Pulse) defaultContext() context.Context {
return context.WithValue(context.Background(), internal.KeyFactory, p.app.factory)
}
func (*Pulse) Restart() {}
// Start initializes resource watch loop.
func (p *Pulse) Start() {
p.Stop()
ctx := p.defaultContext()
ctx, p.cancelFn = context.WithCancel(ctx)
gaugeChan, metricsChan, err := p.model.Watch(ctx)
if err != nil {
slog.Error("Pulse watch failed", slogs.Error, err)
return
}
go func() {
for {
select {
case check, ok := <-gaugeChan:
if !ok {
return
}
p.app.QueueUpdateDraw(func() {
p.PulseChanged(check)
})
case mx, ok := <-metricsChan:
if !ok {
return
}
p.app.QueueUpdateDraw(func() {
p.SeriesChanged(mx)
})
}
}
}()
}
// Stop terminates watch loop.
func (p *Pulse) Stop() {
if p.cancelFn == nil {
return
}
p.cancelFn()
p.cancelFn = nil
}
// Refresh updates the view
func (*Pulse) Refresh() {}
// GVR returns a resource descriptor.
func (p *Pulse) GVR() *client.GVR {
return p.gvr
}
// Name returns the component name.
func (*Pulse) Name() string {
return pulseTitle
}
// App returns the current app handle.
func (p *Pulse) App() *App {
return p.app
}
// SetInstance sets specific resource instance.
func (*Pulse) SetInstance(string) {}
// SetEnvFn sets the custom environment function.
func (*Pulse) SetEnvFn(EnvFunc) {}
// AddBindKeysFn sets up extra key bindings.
func (*Pulse) AddBindKeysFn(BindKeysFunc) {}
// SetContextFn sets custom context.
func (*Pulse) SetContextFn(ContextFunc) {}
func (*Pulse) GetContextFn() ContextFunc { return nil }
// GetTable return the view table if any.
func (*Pulse) GetTable() *Table {
return nil
}
// Actions returns active menu bindings.
func (p *Pulse) Actions() *ui.KeyActions {
return p.actions
}
// Hints returns the view hints.
func (p *Pulse) Hints() model.MenuHints {
return p.actions.Hints()
}
// ExtraHints returns additional hints.
func (*Pulse) ExtraHints() map[string]string {
return nil
}
func (p *Pulse) enterCmd(*tcell.EventKey) *tcell.EventKey {
v := p.App().GetFocus()
s, ok := v.(Graphable)
if !ok {
return nil
}
g, ok := v.(Graphable)
if !ok {
return nil
}
p.prevFocusIndex = p.findIndex(g)
for i := range len(p.charts) {
gi := p.GetItem(i)
if i == p.prevFocusIndex {
gi.Focus = true
} else {
gi.Focus = false
}
}
p.Stop()
res := client.NewGVR(s.ID()).R()
if res == "cpu" || res == "memory" {
res = client.PodGVR.String()
}
p.App().SetFocus(p.App().Main)
p.App().gotoResource(res+" "+p.model.GetNamespace(), "", false, true)
return nil
}
func (p *Pulse) nextFocusCmd(direction int) func(evt *tcell.EventKey) *tcell.EventKey {
return func(*tcell.EventKey) *tcell.EventKey {
v := p.app.GetFocus()
g, ok := v.(Graphable)
if !ok {
return nil
}
currentIndex := p.findIndex(g)
nextIndex, total := currentIndex+direction, len(p.charts)
if nextIndex < 0 {
return nil
}
switch direction {
case dirLeft:
if nextIndex >= total {
return nil
}
p.prevFocusIndex = -1
case dirRight:
p.prevFocusIndex = -1
case dirUp:
if p.app.Conn().HasMetrics() {
if currentIndex >= total-2 {
if p.prevFocusIndex >= 0 && p.prevFocusIndex != currentIndex {
nextIndex = p.prevFocusIndex
} else if currentIndex == p.chartGVRs.Len()-1 {
nextIndex += 1
}
} else {
p.prevFocusIndex = currentIndex
}
}
case dirDown:
if p.app.Conn().HasMetrics() {
if currentIndex >= total-6 && currentIndex < total-2 {
switch {
case (currentIndex % 4) <= 1:
p.prevFocusIndex, nextIndex = currentIndex, total-2
case (currentIndex % 4) <= 3:
p.prevFocusIndex, nextIndex = currentIndex, total-1
}
} else if currentIndex >= total-2 {
return nil
}
}
}
if nextIndex < 0 {
nextIndex = 0
} else if nextIndex > total-1 {
nextIndex = currentIndex
}
p.GetItem(nextIndex).Focus = false
p.GetItem(nextIndex).Item.Blur()
i, v := p.nextFocus(nextIndex)
p.GetItem(i).Focus = true
p.app.SetFocus(v)
return nil
}
}
func (p *Pulse) makeSP(loc, span image.Point, gvr *client.GVR, unit string) *tchart.SparkLine {
s := tchart.NewSparkLine(gvr.String(), unit)
s.SetBackgroundColor(p.app.Styles.Charts().BgColor.Color())
if cc, ok := p.app.Styles.Charts().ResourceColors[gvr.String()]; ok {
s.SetSeriesColors(cc.Colors()...)
} else {
s.SetSeriesColors(p.app.Styles.Charts().DefaultChartColors.Colors()...)
}
s.SetLegend(fmt.Sprintf(" %s ", cases.Title(language.English).String(gvr.R())))
s.SetInputCapture(p.keyboard)
p.AddItem(s, loc.X, loc.Y, span.X, span.Y, 0, 0, false)
return s
}
func (p *Pulse) makeGA(loc, span image.Point, gvr *client.GVR) *tchart.Gauge {
g := tchart.NewGauge(gvr.String())
g.SetBorder(true)
g.SetBackgroundColor(p.app.Styles.Charts().BgColor.Color())
if cc, ok := p.app.Styles.Charts().ResourceColors[gvr.String()]; ok {
g.SetSeriesColors(cc.Colors()...)
} else {
g.SetSeriesColors(p.app.Styles.Charts().DefaultDialColors.Colors()...)
}
g.SetLegend(fmt.Sprintf(" %s ", cases.Title(language.English).String(gvr.R())))
g.SetInputCapture(p.keyboard)
p.AddItem(g, loc.X, loc.Y, span.X, span.Y, 0, 0, false)
return g
}
// ----------------------------------------------------------------------------
// Helpers
func (p *Pulse) nextFocus(index int) (int, tview.Primitive) {
if index >= len(p.chartGVRs) {
return 0, p.charts[p.chartGVRs[0]]
}
if index < 0 {
return len(p.chartGVRs) - 1, p.charts[p.chartGVRs[len(p.chartGVRs)-1]]
}
return index, p.charts[p.chartGVRs[index]]
}
func (p *Pulse) findIndex(g Graphable) int {
for i, gvr := range p.chartGVRs {
if gvr.String() == g.ID() {
return i
}
}
return 0
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/command.go | internal/view/command.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"fmt"
"log/slog"
"regexp"
"runtime/debug"
"strings"
"sync"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/view/cmd"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
)
const (
podCmd = "v1/pods"
ctxCmd = "ctx"
)
var (
customViewers MetaViewers
contextRX = regexp.MustCompile(`\s+@([\w-]+)`)
)
// Command represents a user command.
type Command struct {
app *App
alias *dao.Alias
mx sync.Mutex
}
// NewCommand returns a new command.
func NewCommand(app *App) *Command {
return &Command{
app: app,
}
}
// AliasesFor gather all known aliases for a given resource.
func (c *Command) AliasesFor(gvr *client.GVR) sets.Set[string] {
if c.alias == nil {
return sets.New[string]()
}
return c.alias.AliasesFor(gvr)
}
// Init initializes the command.
func (c *Command) Init(path string) error {
if c.app.factory != nil {
c.alias = dao.NewAlias(c.app.factory)
if _, err := c.alias.Ensure(path); err != nil {
slog.Error("Ensure aliases failed", slogs.Error, err)
return err
}
}
customViewers = loadCustomViewers()
return nil
}
// Reset resets Command and reload aliases.
func (c *Command) Reset(path string, nuke bool) error {
c.mx.Lock()
defer c.mx.Unlock()
if c.alias == nil {
return nil
}
if nuke {
c.alias.Clear()
}
if _, err := c.alias.Ensure(path); err != nil {
return err
}
return nil
}
var allowedCmds = sets.New[*client.GVR](
client.PodGVR,
client.SvcGVR,
client.DpGVR,
client.DsGVR,
client.StsGVR,
client.RsGVR,
)
func allowedXRay(gvr *client.GVR) bool {
return allowedCmds.Has(gvr)
}
func (c *Command) contextCmd(p *cmd.Interpreter, pushCmd bool) error {
ct, ok := p.ContextArg()
if !ok {
return fmt.Errorf("invalid command use `context xxx`")
}
if ct != "" {
return useContext(c.app, ct)
}
gvr, v, comd, err := c.viewMetaFor(p)
if err != nil {
return err
}
if comd != nil {
p = comd
}
return c.exec(p, gvr, c.componentFor(gvr, ct, v), true, pushCmd)
}
func (*Command) namespaceCmd(p *cmd.Interpreter) bool {
ns, ok := p.NSArg()
if !ok {
return false
}
if ns != "" {
_ = p.Reset(client.PodGVR.String(), "")
p.SwitchNS(ns)
}
return false
}
func (c *Command) aliasCmd(p *cmd.Interpreter, pushCmd bool) error {
filter, _ := p.FilterArg()
v := NewAlias(client.AliGVR)
v.SetFilter(filter, true)
return c.exec(p, client.AliGVR, v, false, pushCmd)
}
func (c *Command) xrayCmd(p *cmd.Interpreter, pushCmd bool) error {
arg, cns, ok := p.XrayArgs()
if !ok {
return errors.New("invalid command. use `xray xxx`")
}
if c.alias == nil {
return fmt.Errorf("no connection available")
}
gvr, ok := c.alias.Resolve(cmd.NewInterpreter(arg))
if !ok {
return fmt.Errorf("invalid resource name: %q", arg)
}
if !allowedXRay(gvr) {
return fmt.Errorf("unsupported resource %q", arg)
}
ns := c.app.Config.ActiveNamespace()
if cns != "" {
ns = cns
}
if err := c.app.Config.SetActiveNamespace(client.CleanseNamespace(ns)); err != nil {
return err
}
if err := c.app.switchNS(ns); err != nil {
return err
}
return c.exec(p, client.XGVR, NewXray(gvr), true, pushCmd)
}
// Run execs the command by showing associated display.
func (c *Command) run(p *cmd.Interpreter, fqn string, clearStack, pushCmd bool) error {
if c.specialCmd(p, pushCmd) {
return nil
}
gvr, v, comd, err := c.viewMetaFor(p)
if err != nil {
return err
}
if comd != nil {
p.Merge(comd)
}
if context, ok := p.HasContext(); ok {
if context != c.app.Config.ActiveContextName() {
if err := c.app.Config.Save(true); err != nil {
slog.Error("Config save failed during command exec", slogs.Error, err)
} else {
slog.Debug("Successfully saved config", slogs.Context, context)
}
}
res, err := dao.AccessorFor(c.app.factory, client.CtGVR)
if err != nil {
return err
}
switcher, ok := res.(dao.Switchable)
if !ok {
return errors.New("expecting a switchable resource")
}
if err := switcher.Switch(context); err != nil {
slog.Error("Unable to switch context", slogs.Error, err)
return err
}
if err := c.app.switchContext(p, false); err != nil {
return err
}
}
ns := c.app.Config.ActiveNamespace()
if cns, ok := p.NSArg(); ok {
ns = cns
}
if ok, err := dao.MetaAccess.IsNamespaced(gvr); ok && err == nil {
if err := c.app.switchNS(ns); err != nil {
return err
}
p.SwitchNS(ns)
} else {
p.ClearNS()
}
co := c.componentFor(gvr, fqn, v)
co.SetFilter("", true)
co.SetLabelSelector(labels.Everything(), true)
if f, ok := p.FilterArg(); ok {
co.SetFilter(f, true)
}
if f, ok := p.FuzzyArg(); ok {
co.SetFilter("-f "+f, true)
}
if sel, err := p.LabelsSelector(); err == nil {
co.SetLabelSelector(sel, false)
} else {
slog.Error("Unable to grok labels selector", slogs.Error, err)
}
return c.exec(p, gvr, co, clearStack, pushCmd)
}
func (c *Command) defaultCmd(isRoot bool) error {
if c.app.Conn() == nil || !c.app.Conn().ConnectionOK() {
return c.run(cmd.NewInterpreter("context"), "", true, true)
}
defCmd := podCmd
if isRoot {
defCmd = ctxCmd
}
p := cmd.NewInterpreter(c.app.Config.ActiveView())
if p.IsBlank() {
return c.run(p.Reset(defCmd, ""), "", true, true)
}
if err := c.run(p, "", true, true); err != nil {
slog.Error("Command exec failed. Using default command",
slogs.Command, p.GetLine(),
slogs.Error, err,
)
p = p.Reset(defCmd, "")
return c.run(p, "", true, true)
}
return nil
}
func (c *Command) specialCmd(p *cmd.Interpreter, pushCmd bool) bool {
switch {
case p.IsCowCmd():
if msg, ok := p.CowArg(); !ok {
c.app.Flash().Errf("Invalid command. Use `cow xxx`")
} else {
c.app.cowCmd(msg)
}
case p.IsBailCmd():
c.app.BailOut(0)
case p.IsHelpCmd():
_ = c.app.helpCmd(nil)
case p.IsAliasCmd():
if err := c.aliasCmd(p, pushCmd); err != nil {
c.app.Flash().Err(err)
}
case p.IsXrayCmd():
if err := c.xrayCmd(p, pushCmd); err != nil {
c.app.Flash().Err(err)
}
case p.IsRBACCmd():
if cat, sub, ok := p.RBACArgs(); !ok {
c.app.Flash().Errf("Invalid command. Use `can [u|g|s]:xxx`")
} else if err := c.app.inject(NewPolicy(c.app, cat, sub), true); err != nil {
c.app.Flash().Err(err)
}
case p.IsContextCmd():
if err := c.contextCmd(p, pushCmd); err != nil {
c.app.Flash().Err(err)
}
case p.IsNamespaceCmd():
return c.namespaceCmd(p)
case p.IsDirCmd():
if a, ok := p.DirArg(); !ok {
c.app.Flash().Errf("Invalid command. Use `dir xxx`")
} else if err := c.app.dirCmd(a, pushCmd); err != nil {
c.app.Flash().Err(err)
}
default:
return false
}
return true
}
func (c *Command) viewMetaFor(p *cmd.Interpreter) (*client.GVR, *MetaViewer, *cmd.Interpreter, error) {
if c.alias == nil {
return client.NoGVR, nil, nil, fmt.Errorf("no connection available")
}
gvr, ok := c.alias.Resolve(p)
if !ok {
return client.NoGVR, nil, nil, fmt.Errorf("`%s` command not found", p.Cmd())
}
v := MetaViewer{
viewerFn: func(gvr *client.GVR) ResourceViewer {
return NewScaleExtender(NewOwnerExtender(NewBrowser(gvr)))
},
}
if mv, ok := customViewers[gvr]; ok {
v = mv
}
return gvr, &v, p, nil
}
func (*Command) componentFor(gvr *client.GVR, fqn string, v *MetaViewer) ResourceViewer {
var view ResourceViewer
if v.viewerFn != nil {
view = v.viewerFn(gvr)
} else {
view = NewBrowser(gvr)
}
view.SetInstance(fqn)
if v.enterFn != nil {
view.GetTable().SetEnterFn(v.enterFn)
}
return view
}
func (c *Command) exec(p *cmd.Interpreter, gvr *client.GVR, comp model.Component, clearStack, pushCmd bool) (err error) {
defer func() {
if e := recover(); e != nil {
slog.Error("Failure detected during command exec", slogs.Error, e)
c.app.Content.Dump()
slog.Debug("Dumping history buffer", slogs.CmdHist, c.app.cmdHistory.List())
slog.Error("Dumping stack", slogs.Stack, string(debug.Stack()))
ci := cmd.NewInterpreter(podCmd)
currentCommand, ok := c.app.cmdHistory.Top()
if ok {
ci = ci.Reset(currentCommand, "")
}
err = c.run(ci, "", true, true)
}
}()
if comp == nil {
return fmt.Errorf("no component found for %s", gvr)
}
comp.SetCommand(p)
if clearStack {
v := contextRX.ReplaceAllString(p.GetLine(), "")
c.app.Config.SetActiveView(v)
}
if err := c.app.inject(comp, clearStack); err != nil {
return err
}
if pushCmd {
c.app.cmdHistory.Push(p.GetLine())
}
slog.Debug("History (exec)", slogs.Stack, strings.Join(c.app.cmdHistory.List(), "|"))
return
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cow.go | internal/view/cow.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"strings"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
// Cow represents a bomb viewer.
type Cow struct {
*tview.TextView
actions *ui.KeyActions
app *App
says string
}
// NewCow returns a have a cow viewer.
func NewCow(app *App, says string) *Cow {
return &Cow{
TextView: tview.NewTextView(),
app: app,
actions: ui.NewKeyActions(),
says: says,
}
}
// Init initializes the viewer.
func (c *Cow) Init(_ context.Context) error {
c.SetBorder(true)
c.SetScrollable(true).SetWrap(true).SetRegions(true)
c.SetDynamicColors(true)
c.SetHighlightColor(tcell.ColorOrange)
c.SetTitleColor(tcell.ColorAqua)
c.SetInputCapture(c.keyboard)
c.SetBorderPadding(0, 0, 1, 1)
c.updateTitle()
c.SetTextAlign(tview.AlignCenter)
c.app.Styles.AddListener(c)
c.StylesChanged(c.app.Styles)
c.bindKeys()
c.SetInputCapture(c.keyboard)
c.talk()
return nil
}
// InCmdMode checks if prompt is active.
func (*Cow) InCmdMode() bool {
return false
}
func (c *Cow) talk() {
says := c.says
if says == "" {
says = "Nothing to report here. Please move along..."
}
x, _, w, _ := c.GetRect()
c.SetText(cowTalk(says, (x+w)/2))
}
func cowTalk(says string, w int) string {
msg := fmt.Sprintf("[red::]< [::b]Ruroh? %s[::-] >", says)
buff := make([]string, 0, len(cow)+3)
buff = append(buff,
"[red::] "+strings.Repeat("─", len(says)+8),
strings.TrimSuffix(msg, "\n"),
" "+strings.Repeat("─", len(says)+8),
)
rCount := w/2 - 8
if rCount < 0 {
rCount = w / 2
}
spacer := strings.Repeat(" ", rCount)
for _, s := range cow {
buff = append(buff, "[red::b]"+spacer+s)
}
return strings.Join(buff, "\n")
}
func (c *Cow) bindKeys() {
c.actions.Add(tcell.KeyEscape, ui.NewKeyAction("Back", c.resetCmd, false))
}
func (c *Cow) keyboard(evt *tcell.EventKey) *tcell.EventKey {
if a, ok := c.actions.Get(ui.AsKey(evt)); ok {
return a.Action(evt)
}
return evt
}
// StylesChanged notifies the skin changes.
func (c *Cow) StylesChanged(s *config.Styles) {
c.SetBackgroundColor(s.BgColor())
c.SetTextColor(s.FgColor())
c.SetBorderFocusColor(s.Frame().Border.FocusColor.Color())
}
func (c *Cow) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
return c.app.PrevCmd(evt)
}
// Actions returns menu actions.
func (c *Cow) Actions() *ui.KeyActions {
return c.actions
}
// Name returns the component name.
func (*Cow) Name() string { return "cow" }
// Start starts the view updater.
func (*Cow) Start() {}
// Stop terminates the updater.
func (c *Cow) Stop() {
c.app.Styles.RemoveListener(c)
}
// Hints returns menu hints.
func (c *Cow) Hints() model.MenuHints {
return c.actions.Hints()
}
// ExtraHints returns additional hints.
func (*Cow) ExtraHints() map[string]string {
return nil
}
func (c *Cow) updateTitle() {
c.SetTitle(" Error ")
}
var cow = []string{
`\ ^__^ `,
` \ (oo)\_______ `,
` (__)\ )\/\`,
` ||----w | `,
` || || `,
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/xray.go | internal/view/xray.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
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/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/k9s/internal/xray"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"github.com/sahilm/fuzzy"
"golang.org/x/text/cases"
"golang.org/x/text/language"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
)
const xrayTitle = "Xray"
var _ ResourceViewer = (*Xray)(nil)
// Xray represents an xray tree view.
type Xray struct {
*ui.Tree
app *App
gvr *client.GVR
meta *metav1.APIResource
model *model.Tree
cancelFn context.CancelFunc
envFn EnvFunc
}
// NewXray returns a new view.
func NewXray(gvr *client.GVR) ResourceViewer {
return &Xray{
gvr: gvr,
Tree: ui.NewTree(),
model: model.NewTree(gvr),
}
}
func (*Xray) SetCommand(*cmd.Interpreter) {}
func (*Xray) SetFilter(string, bool) {}
func (*Xray) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the view.
func (x *Xray) Init(ctx context.Context) error {
x.envFn = x.k9sEnv
if err := x.Tree.Init(ctx); err != nil {
return err
}
x.SetKeyListenerFn(x.keyEntered)
var err error
x.meta, err = dao.MetaAccess.MetaFor(x.gvr)
if err != nil {
return err
}
if x.app, err = extractApp(ctx); err != nil {
return err
}
x.bindKeys()
x.SetBackgroundColor(x.app.Styles.Xray().BgColor.Color())
x.SetBorderColor(x.app.Styles.Xray().FgColor.Color())
x.SetBorderFocusColor(x.app.Styles.Frame().Border.FocusColor.Color())
x.SetGraphicsColor(x.app.Styles.Xray().GraphicColor.Color())
x.SetTitle(fmt.Sprintf(" %s-%s ", xrayTitle, cases.Title(language.Und, cases.NoLower).String(x.gvr.R())))
x.model.SetRefreshRate(x.app.Config.K9s.RefreshDuration())
x.model.SetNamespace(client.CleanseNamespace(x.app.Config.ActiveNamespace()))
x.model.AddListener(x)
x.SetChangedFunc(func(n *tview.TreeNode) {
spec, ok := n.GetReference().(xray.NodeSpec)
if !ok {
slog.Error("No ref found on node", slogs.FQN, n.GetText())
return
}
x.SetSelectedItem(spec.AsPath())
x.refreshActions()
})
x.refreshActions()
return nil
}
// InCmdMode checks if prompt is active.
func (*Xray) InCmdMode() bool {
return false
}
// ExtraHints returns additional hints.
func (x *Xray) ExtraHints() map[string]string {
if x.app.Config.K9s.UI.NoIcons {
return nil
}
return xray.EmojiInfo()
}
// SetInstance sets specific resource instance.
func (*Xray) SetInstance(string) {}
func (x *Xray) bindKeys() {
x.Actions().Bulk(ui.KeyMap{
ui.KeySlash: ui.NewSharedKeyAction("Filter Mode", x.activateCmd, false),
tcell.KeyEscape: ui.NewSharedKeyAction("Filter Reset", x.resetCmd, false),
tcell.KeyEnter: ui.NewKeyAction("Goto", x.gotoCmd, true),
})
}
func (x *Xray) keyEntered() {
x.ClearSelection()
x.update(x.filter(x.model.Peek()))
}
func (x *Xray) refreshActions() {
aa := ui.NewKeyActions()
defer func() {
if err := pluginActions(x, aa); err != nil {
slog.Warn("Plugins load failed", slogs.Error, err)
}
if err := hotKeyActions(x, aa); err != nil {
slog.Warn("HotKeys load failed", slogs.Error, err)
}
x.Actions().Merge(aa)
x.app.Menu().HydrateMenu(x.Hints())
}()
x.Actions().Clear()
x.bindKeys()
x.BindKeys()
spec := x.selectedSpec()
if spec == nil {
return
}
gvr := spec.GVR()
var err error
x.meta, err = dao.MetaAccess.MetaFor(gvr)
if err != nil {
slog.Warn("No meta found!",
slogs.GVR, gvr,
slogs.Error, err,
)
return
}
if client.Can(x.meta.Verbs, "edit") {
aa.Add(ui.KeyE, ui.NewKeyAction("Edit", x.editCmd, true))
}
if client.Can(x.meta.Verbs, "delete") {
aa.Add(tcell.KeyCtrlD, ui.NewKeyAction("Delete", x.deleteCmd, true))
}
if !dao.IsK9sMeta(x.meta) {
aa.Bulk(ui.KeyMap{
ui.KeyY: ui.NewKeyAction(yamlAction, x.viewCmd, true),
ui.KeyD: ui.NewKeyAction("Describe", x.describeCmd, true),
})
}
switch gvr {
case client.NsGVR:
x.Actions().Delete(tcell.KeyEnter)
case client.CoGVR:
x.Actions().Delete(tcell.KeyEnter)
aa.Bulk(ui.KeyMap{
ui.KeyS: ui.NewKeyAction("Shell", x.shellCmd, true),
ui.KeyL: ui.NewKeyAction("Logs", x.logsCmd(false), true),
ui.KeyP: ui.NewKeyAction("Logs Previous", x.logsCmd(true), true),
})
case client.PodGVR:
aa.Bulk(ui.KeyMap{
ui.KeyS: ui.NewKeyAction("Shell", x.shellCmd, true),
ui.KeyA: ui.NewKeyAction("Attach", x.attachCmd, true),
ui.KeyL: ui.NewKeyAction("Logs", x.logsCmd(false), true),
ui.KeyP: ui.NewKeyAction("Logs Previous", x.logsCmd(true), true),
})
}
x.Actions().Merge(aa)
}
// GetSelectedPath returns the current selection as string.
func (x *Xray) GetSelectedPath() string {
spec := x.selectedSpec()
if spec == nil {
return ""
}
return spec.Path()
}
func (x *Xray) selectedSpec() *xray.NodeSpec {
node := x.GetCurrentNode()
if node == nil {
return nil
}
ref, ok := node.GetReference().(xray.NodeSpec)
if !ok {
slog.Error("Expecting a NodeSpec",
slogs.Path, node.GetText(),
slogs.RefType, fmt.Sprintf("%T", node.GetReference()),
)
return nil
}
return &ref
}
// EnvFn returns an plugin env function if available.
func (x *Xray) EnvFn() EnvFunc {
return x.envFn
}
func (x *Xray) k9sEnv() Env {
env := k8sEnv(x.app.Conn().Config())
spec := x.selectedSpec()
if spec == nil {
return env
}
env["FILTER"] = x.CmdBuff().GetText()
if env["FILTER"] == "" {
ns, n := client.Namespaced(spec.Path())
env["NAMESPACE"], env["FILTER"] = ns, n
}
switch spec.GVR() {
case client.CoGVR:
_, co := client.Namespaced(spec.Path())
env["CONTAINER"] = co
ns, n := client.Namespaced(*spec.ParentPath())
env["NAMESPACE"], env["POD"], env["NAME"] = ns, n, co
default:
ns, n := client.Namespaced(spec.Path())
env["NAMESPACE"], env["NAME"] = ns, n
}
return env
}
// Aliases returns all available aliases.
func (x *Xray) Aliases() sets.Set[string] {
return aliases(x.meta, x.app.command.AliasesFor(client.NewGVRFromMeta(x.meta)))
}
func (x *Xray) logsCmd(prev bool) func(evt *tcell.EventKey) *tcell.EventKey {
return func(*tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return nil
}
x.showLogs(spec, prev)
return nil
}
}
func (x *Xray) showLogs(spec *xray.NodeSpec, prev bool) {
// Need to load and wait for pods
path, co := spec.Path(), ""
if spec.GVR() == client.CoGVR {
_, coName := client.Namespaced(spec.Path())
path, co = *spec.ParentPath(), coName
}
ns, _ := client.Namespaced(path)
_, err := x.app.factory.CanForResource(ns, client.PodGVR, client.ListAccess)
if err != nil {
x.app.Flash().Err(err)
return
}
opts := dao.LogOptions{
Path: path,
Container: co,
Previous: prev,
}
if err := x.app.inject(NewLog(client.PodGVR, &opts), false); err != nil {
x.app.Flash().Err(err)
}
}
func (x *Xray) shellCmd(*tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return nil
}
if spec.Status() != "ok" {
x.app.Flash().Errf("%s is not in a running state", spec.Path())
return nil
}
path, co := spec.Path(), ""
if spec.GVR() == client.CoGVR {
_, co = client.Namespaced(spec.Path())
path = *spec.ParentPath()
}
if err := containerShellIn(x.app, x, path, co); err != nil {
x.app.Flash().Err(err)
}
return nil
}
func (x *Xray) attachCmd(*tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return nil
}
if spec.Status() != "ok" {
x.app.Flash().Errf("%s is not in a running state", spec.Path())
return nil
}
path, co := spec.Path(), ""
if spec.GVR() == client.CoGVR {
path = *spec.ParentPath()
}
if err := containerAttachIn(x.app, x, path, co); err != nil {
x.app.Flash().Err(err)
}
return nil
}
func (x *Xray) viewCmd(evt *tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return evt
}
ctx := x.defaultContext()
raw, err := x.model.ToYAML(ctx, spec.GVR(), spec.Path())
if err != nil {
x.App().Flash().Errf("unable to get resource %q -- %s", spec.GVR(), err)
return nil
}
details := NewDetails(x.app, yamlAction, spec.Path(), contentYAML, true).Update(raw)
if err := x.app.inject(details, false); err != nil {
x.app.Flash().Err(err)
}
return nil
}
func (x *Xray) deleteCmd(evt *tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return evt
}
x.Stop()
defer x.Start()
{
meta, err := dao.MetaAccess.MetaFor(spec.GVR())
if err != nil {
slog.Warn("No meta found!",
slogs.GVR, spec.GVR(),
slogs.Error, err,
)
return nil
}
x.resourceDelete(spec.GVR(), spec, fmt.Sprintf("Delete %s %s?", meta.SingularName, spec.Path()))
}
return nil
}
func (x *Xray) describeCmd(evt *tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return evt
}
x.describe(spec.GVR(), spec.Path())
return nil
}
func (x *Xray) describe(gvr *client.GVR, path string) {
ctx := context.Background()
ctx = context.WithValue(ctx, internal.KeyFactory, x.app.factory)
yaml, err := x.model.Describe(ctx, gvr, path)
if err != nil {
x.app.Flash().Errf("Describe command failed: %s", err)
return
}
details := NewDetails(x.app, "Describe", path, contentYAML, true).Update(yaml)
if err := x.app.inject(details, false); err != nil {
x.app.Flash().Err(err)
}
}
func (x *Xray) editCmd(evt *tcell.EventKey) *tcell.EventKey {
spec := x.selectedSpec()
if spec == nil {
return evt
}
x.Stop()
defer x.Start()
{
ns, n := client.Namespaced(spec.Path())
args := make([]string, 0, 10)
args = append(args,
"edit",
spec.GVR().R(),
"-n", ns,
"--context", x.app.Config.K9s.ActiveContextName(),
)
if cfg := x.app.Conn().Config().Flags().KubeConfig; cfg != nil && *cfg != "" {
args = append(args, "--kubeconfig", *cfg)
}
if err := runK(x.app, &shellOpts{args: append(args, n)}); err != nil {
x.app.Flash().Errf("Edit exec failed: %s", err)
}
}
return evt
}
func (x *Xray) activateCmd(evt *tcell.EventKey) *tcell.EventKey {
if x.app.InCmdMode() {
return evt
}
x.app.ResetPrompt(x.CmdBuff())
return nil
}
func (x *Xray) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !x.CmdBuff().InCmdMode() {
x.CmdBuff().Reset()
return x.app.PrevCmd(evt)
}
x.CmdBuff().Reset()
x.model.ClearFilter()
x.Start()
return nil
}
func (x *Xray) gotoCmd(*tcell.EventKey) *tcell.EventKey {
if x.CmdBuff().IsActive() {
if internal.IsLabelSelector(x.CmdBuff().GetText()) {
x.Start()
}
x.CmdBuff().SetActive(false)
x.GetRoot().ExpandAll()
return nil
}
spec := x.selectedSpec()
if spec == nil {
return nil
}
if len(strings.Split(spec.Path(), "/")) == 1 {
return nil
}
x.app.gotoResource(spec.GVR().String(), spec.Path(), false, true)
return nil
}
func (x *Xray) filter(root *xray.TreeNode) *xray.TreeNode {
q := x.CmdBuff().GetText()
if x.CmdBuff().Empty() || internal.IsLabelSelector(q) {
return root
}
x.UpdateTitle()
if f, ok := internal.IsFuzzySelector(q); ok {
return root.Filter(f, fuzzyFilter)
}
if internal.IsInverseSelector(q) {
return root.Filter(q, rxInverseFilter)
}
return root.Filter(q, rxFilter)
}
// TreeNodeSelected callback for node selection.
func (x *Xray) TreeNodeSelected() {
x.app.QueueUpdateDraw(func() {
n := x.GetCurrentNode()
if n != nil {
n.SetColor(x.app.Styles.Xray().CursorColor.Color())
}
})
}
// TreeLoadFailed notifies the load failed.
func (x *Xray) TreeLoadFailed(err error) {
x.app.Flash().Err(err)
}
func (x *Xray) update(node *xray.TreeNode) {
root := makeTreeNode(node, x.ExpandNodes(), x.app.Config.K9s.UI.NoIcons, x.app.Styles)
if node == nil {
x.app.QueueUpdateDraw(func() {
x.SetRoot(root)
})
return
}
for _, c := range node.Children {
x.hydrate(root, c)
}
if x.GetSelectedItem() == "" {
x.SetSelectedItem(node.Spec().Path())
}
x.app.QueueUpdateDraw(func() {
x.SetRoot(root)
root.Walk(func(node, parent *tview.TreeNode) bool {
spec, ok := node.GetReference().(xray.NodeSpec)
if !ok {
slog.Error("Expecting a NodeSpec",
slogs.FQN, node.GetText(),
slogs.RefType, fmt.Sprintf("%T", node.GetReference()),
)
return false
}
// BOZO!! Figure this out expand/collapse but the root
if parent != nil {
node.SetExpanded(x.ExpandNodes())
} else {
node.SetExpanded(true)
}
if spec.AsPath() == x.GetSelectedItem() {
node.SetExpanded(true).SetSelectable(true)
x.SetCurrentNode(node)
}
return true
})
})
}
// TreeChanged notifies the model data changed.
func (x *Xray) TreeChanged(node *xray.TreeNode) {
x.Count = node.Count(x.gvr)
x.update(x.filter(node))
x.UpdateTitle()
}
func (x *Xray) hydrate(parent *tview.TreeNode, n *xray.TreeNode) {
node := makeTreeNode(n, x.ExpandNodes(), x.app.Config.K9s.UI.NoIcons, x.app.Styles)
for _, c := range n.Children {
x.hydrate(node, c)
}
parent.AddChild(node)
}
// SetEnvFn sets the custom environment function.
func (*Xray) SetEnvFn(EnvFunc) {}
// Refresh updates the view.
func (*Xray) Refresh() {}
// BufferCompleted indicates the buffer was changed.
func (x *Xray) BufferCompleted(_, _ string) {
x.update(x.filter(x.model.Peek()))
}
// BufferChanged indicates the buffer was changed.
func (*Xray) BufferChanged(_, _ string) {}
// BufferActive indicates the buff activity changed.
func (x *Xray) BufferActive(state bool, k model.BufferKind) {
x.app.BufferActive(state, k)
}
func (x *Xray) defaultContext() context.Context {
ctx := context.WithValue(context.Background(), internal.KeyFactory, x.app.factory)
ctx = context.WithValue(ctx, internal.KeyFields, "")
if x.CmdBuff().Empty() {
ctx = context.WithValue(ctx, internal.KeyLabels, labels.Everything())
} else {
if sel, err := ui.ExtractLabelSelector(x.CmdBuff().GetText()); err == nil {
ctx = context.WithValue(ctx, internal.KeyLabels, sel)
}
}
return ctx
}
// Start initializes resource watch loop.
func (x *Xray) Start() {
x.Stop()
x.CmdBuff().AddListener(x)
ctx := x.defaultContext()
ctx, x.cancelFn = context.WithCancel(ctx)
x.model.Watch(ctx)
x.UpdateTitle()
}
// Stop terminates watch loop.
func (x *Xray) Stop() {
if x.cancelFn == nil {
return
}
x.cancelFn()
x.cancelFn = nil
x.CmdBuff().RemoveListener(x)
}
// AddBindKeysFn sets up extra key bindings.
func (*Xray) AddBindKeysFn(BindKeysFunc) {}
// SetContextFn sets custom context.
func (*Xray) SetContextFn(ContextFunc) {}
// Name returns the component name.
func (*Xray) Name() string { return "XRay" }
// GetTable returns the underlying table.
func (*Xray) GetTable() *Table { return nil }
// GVR returns a resource descriptor.
func (x *Xray) GVR() *client.GVR { return x.gvr }
// App returns the current app handle.
func (x *Xray) App() *App {
return x.app
}
// UpdateTitle updates the view title.
func (x *Xray) UpdateTitle() {
t := x.styleTitle()
x.app.QueueUpdateDraw(func() {
x.SetTitle(t)
})
}
func (x *Xray) styleTitle() string {
base := fmt.Sprintf("%s-%s", xrayTitle, cases.Title(language.Und, cases.NoLower).String(x.gvr.R()))
ns := x.model.GetNamespace()
if client.IsAllNamespaces(ns) {
ns = client.NamespaceAll
}
var (
title string
styles = x.app.Styles.Frame()
)
if ns == client.ClusterScope {
title = ui.SkinTitle(fmt.Sprintf(ui.TitleFmt, base, render.AsThousands(int64(x.Count))), &styles)
} else {
title = ui.SkinTitle(fmt.Sprintf(ui.NSTitleFmt, base, ns, render.AsThousands(int64(x.Count))), &styles)
}
buff := x.CmdBuff().GetText()
if buff == "" {
return title
}
if internal.IsLabelSelector(buff) {
if sel, err := ui.ExtractLabelSelector(buff); err == nil {
buff = sel.String()
}
}
return title + ui.SkinTitle(fmt.Sprintf(ui.SearchFmt, buff), &styles)
}
func (x *Xray) resourceDelete(gvr *client.GVR, spec *xray.NodeSpec, msg string) {
d := x.app.Styles.Dialog()
dialog.ShowDelete(&d, x.app.Content.Pages, msg, func(_ *metav1.DeletionPropagation, force bool) {
x.app.Flash().Infof("Delete resource %s %s", spec.GVR(), spec.Path())
accessor, err := dao.AccessorFor(x.app.factory, gvr)
if err != nil {
slog.Error("No accessor found",
slogs.GVR, gvr,
slogs.Error, err,
)
return
}
nuker, ok := accessor.(dao.Nuker)
if !ok {
x.app.Flash().Errf("Invalid nuker %T", accessor)
return
}
grace := dao.DefaultGrace
if force {
grace = dao.ForceGrace
}
if err := nuker.Delete(context.Background(), spec.Path(), nil, grace); err != nil {
x.app.Flash().Errf("Delete failed with `%s", err)
} else {
x.app.Flash().Infof("%s `%s deleted successfully", x.GVR(), spec.Path())
x.app.factory.DeleteForwarder(spec.Path())
}
x.Refresh()
}, func() {})
}
// ----------------------------------------------------------------------------
// Helpers...
func fuzzyFilter(q, path string) bool {
q = strings.TrimSpace(q[2:])
mm := fuzzy.Find(q, []string{path})
return len(mm) > 0
}
func rxFilter(q, path string) bool {
rx := regexp.MustCompile(`(?i)` + q)
tokens := strings.Split(path, xray.PathSeparator)
for _, t := range tokens {
if rx.MatchString(t) {
return true
}
}
return false
}
func rxInverseFilter(q, path string) bool {
q = strings.TrimSpace(q[1:])
rx := regexp.MustCompile(`(?i)` + q)
tokens := strings.Split(path, xray.PathSeparator)
for _, t := range tokens {
if rx.MatchString(t) {
return false
}
}
return true
}
func makeTreeNode(node *xray.TreeNode, expanded, showIcons bool, styles *config.Styles) *tview.TreeNode {
n := tview.NewTreeNode("No data...")
if node != nil {
n.SetText(node.Title(showIcons))
n.SetReference(node.Spec())
}
n.SetSelectable(true)
n.SetExpanded(expanded)
n.SetColor(styles.Xray().CursorColor.Color())
n.SetSelectedFunc(func() {
n.SetExpanded(!n.IsExpanded())
})
return n
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/table_helper.go | internal/view/table_helper.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"encoding/csv"
"fmt"
"log/slog"
"os"
"path/filepath"
"strings"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
)
func computeFilename(dumpPath, ns, title, path string) (string, error) {
now := time.Now().UnixNano()
dir := dumpPath
if err := ensureDir(dir); err != nil {
return "", err
}
name := title + "-" + data.SanitizeFileName(path)
if path == "" {
name = title
}
var fName string
if ns == client.ClusterScope {
fName = fmt.Sprintf(ui.NoNSFmat, name, now)
} else {
fName = fmt.Sprintf(ui.FullFmat, name, ns, now)
}
return strings.ToLower(filepath.Join(dir, fName)), nil
}
func saveTable(dir, title, path string, mdata *model1.TableData) (string, error) {
ns := mdata.GetNamespace()
if client.IsClusterWide(ns) {
ns = client.NamespaceAll
}
fPath, err := computeFilename(dir, ns, title, path)
if err != nil {
return "", err
}
slog.Debug("Saving table to disk", slogs.FileName, fPath)
mod := os.O_CREATE | os.O_WRONLY
out, err := os.OpenFile(fPath, mod, 0600)
if err != nil {
return "", err
}
defer func() {
if err := out.Close(); err != nil {
slog.Error("Closing file failed",
slogs.Path, fPath,
slogs.Error, err,
)
}
}()
w := csv.NewWriter(out)
_ = w.Write(mdata.ColumnNames(true))
mdata.RowsRange(func(_ int, re model1.RowEvent) bool {
_ = w.Write(re.Row.Fields)
return true
})
w.Flush()
if err := w.Error(); err != nil {
return "", err
}
return fPath, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/image_extender.go | internal/view/image_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"strings"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
corev1 "k8s.io/api/core/v1"
)
const imageKey = "setImage"
type imageFormSpec struct {
name, dockerImage, newDockerImage string
init bool
}
func (m *imageFormSpec) modified() bool {
newDockerImage := strings.TrimSpace(m.newDockerImage)
return newDockerImage != "" && m.dockerImage != newDockerImage
}
func (m *imageFormSpec) imageSpec() dao.ImageSpec {
ret := dao.ImageSpec{
Name: m.name,
Init: m.init,
}
if m.modified() {
ret.DockerImage = strings.TrimSpace(m.newDockerImage)
} else {
ret.DockerImage = m.dockerImage
}
return ret
}
// ImageExtender provides for overriding container images.
type ImageExtender struct {
ResourceViewer
}
// NewImageExtender returns a new extender.
func NewImageExtender(r ResourceViewer) ResourceViewer {
s := ImageExtender{ResourceViewer: r}
s.AddBindKeysFn(s.bindKeys)
return &s
}
func (s *ImageExtender) bindKeys(aa *ui.KeyActions) {
if s.App().Config.IsReadOnly() {
return
}
aa.Add(ui.KeyI, ui.NewKeyAction("Set Image", s.setImageCmd, false))
}
func (s *ImageExtender) setImageCmd(*tcell.EventKey) *tcell.EventKey {
path := s.GetTable().GetSelectedItem()
if path == "" {
return nil
}
s.Stop()
defer s.Start()
if err := s.showImageDialog(path); err != nil {
s.App().Flash().Err(err)
}
return nil
}
func (s *ImageExtender) showImageDialog(path string) error {
form, err := s.makeSetImageForm(path)
if err != nil {
return err
}
confirm := tview.NewModalForm("<Set image>", form)
confirm.SetText(fmt.Sprintf("Set image %s %s", s.GVR(), path))
confirm.SetDoneFunc(func(int, string) {
s.dismissDialog()
})
s.App().Content.AddPage(imageKey, confirm, false, false)
s.App().Content.ShowPage(imageKey)
return nil
}
func (s *ImageExtender) makeSetImageForm(fqn string) (*tview.Form, error) {
podSpec, err := s.getPodSpec(fqn)
if err != nil {
return nil, err
}
formContainerLines := make([]*imageFormSpec, 0, len(podSpec.InitContainers)+len(podSpec.Containers))
for i := range podSpec.InitContainers {
spec := podSpec.InitContainers[i]
formContainerLines = append(formContainerLines, &imageFormSpec{init: true, name: spec.Name, dockerImage: spec.Image})
}
for i := range podSpec.Containers {
spec := podSpec.Containers[i]
formContainerLines = append(formContainerLines, &imageFormSpec{name: spec.Name, dockerImage: spec.Image})
}
styles := s.App().Styles.Dialog()
f := tview.NewForm().
SetItemPadding(0).
SetButtonsAlign(tview.AlignCenter).
SetButtonBackgroundColor(styles.ButtonBgColor.Color()).
SetButtonTextColor(styles.ButtonFgColor.Color()).
SetLabelColor(styles.LabelFgColor.Color()).
SetFieldTextColor(styles.FieldFgColor.Color()).
AddButton("OK", func() {
defer s.dismissDialog()
var imageSpecsModified dao.ImageSpecs
for _, v := range formContainerLines {
if v.modified() {
imageSpecsModified = append(imageSpecsModified, v.imageSpec())
}
}
ctx, cancel := context.WithTimeout(context.Background(), s.App().Conn().Config().CallTimeout())
defer cancel()
if err := s.setImages(ctx, fqn, imageSpecsModified); err != nil {
slog.Error("Unable to set image name",
slogs.FQN, fqn,
slogs.Error, err,
)
s.App().Flash().Err(err)
return
}
s.App().Flash().Infof("Resource %s:%s image updated successfully", s.GVR(), fqn)
}).
AddButton("Cancel", func() {
s.dismissDialog()
})
for i := range formContainerLines {
ctn := formContainerLines[i]
f.AddInputField(ctn.name, ctn.dockerImage, 0, nil, func(changed string) {
ctn.newDockerImage = changed
})
}
for i := range f.GetButtonCount() {
f.GetButton(i).
SetBackgroundColorActivated(styles.ButtonFocusBgColor.Color()).
SetLabelColorActivated(styles.ButtonFocusFgColor.Color())
}
return f, nil
}
func (s *ImageExtender) dismissDialog() {
s.App().Content.RemovePage(imageKey)
}
func (s *ImageExtender) getPodSpec(path string) (*corev1.PodSpec, error) {
res, err := dao.AccessorFor(s.App().factory, s.GVR())
if err != nil {
return nil, err
}
resourceWPodSpec, ok := res.(dao.ContainsPodSpec)
if !ok {
return nil, fmt.Errorf("expecting a ContainsPodSpec for %q but got %T", s.GVR(), res)
}
return resourceWPodSpec.GetPodSpec(path)
}
func (s *ImageExtender) setImages(ctx context.Context, path string, imageSpecs dao.ImageSpecs) error {
res, err := dao.AccessorFor(s.App().factory, s.GVR())
if err != nil {
return err
}
resourceWPodSpec, ok := res.(dao.ContainsPodSpec)
if !ok {
return fmt.Errorf("expecting a scalable resource for %q", s.GVR())
}
return resourceWPodSpec.SetImages(ctx, path, imageSpecs)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/help.go | internal/view/help.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"sort"
"strconv"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"k8s.io/apimachinery/pkg/labels"
)
const (
helpTitle = "Help"
helpTitleFmt = " [aqua::b]%s "
)
// HelpFunc processes menu hints.
type HelpFunc func() model.MenuHints
// Help presents a help viewer.
type Help struct {
*Table
styles *config.Styles
hints HelpFunc
maxKey, maxDesc, maxRows int
}
// NewHelp returns a new help viewer.
func NewHelp(app *App) *Help {
return &Help{
Table: NewTable(client.HlpGVR),
hints: app.Content.Top().Hints,
}
}
func (*Help) SetCommand(*cmd.Interpreter) {}
func (*Help) SetFilter(string, bool) {}
func (*Help) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the component.
func (h *Help) Init(ctx context.Context) error {
if err := h.Table.Init(ctx); err != nil {
return err
}
h.SetSelectable(false, false)
h.resetTitle()
h.SetBorder(true)
h.SetBorderPadding(0, 0, 1, 1)
h.bindKeys()
h.build()
h.app.Styles.AddListener(h)
h.StylesChanged(h.app.Styles)
return nil
}
// InCmdMode checks if prompt is active.
func (*Help) InCmdMode() bool {
return false
}
// StylesChanged notifies skin changed.
func (h *Help) StylesChanged(s *config.Styles) {
h.styles = s
h.SetBackgroundColor(s.BgColor())
h.updateStyle()
}
func (h *Help) bindKeys() {
h.Actions().Delete(ui.KeySpace, tcell.KeyCtrlSpace, tcell.KeyCtrlS, ui.KeySlash)
h.Actions().Bulk(ui.KeyMap{
tcell.KeyEscape: ui.NewKeyAction("Back", h.app.PrevCmd, true),
ui.KeyQ: ui.NewKeyAction("Back", h.app.PrevCmd, false),
ui.KeyHelp: ui.NewKeyAction("Back", h.app.PrevCmd, false),
tcell.KeyEnter: ui.NewKeyAction("Back", h.app.PrevCmd, false),
})
}
func (h *Help) computeMaxes(hh model.MenuHints) {
h.maxKey, h.maxDesc = 0, 0
for _, hint := range hh {
if len(hint.Mnemonic) > h.maxKey {
h.maxKey = len(hint.Mnemonic)
}
if len(hint.Description) > h.maxDesc {
h.maxDesc = len(hint.Description)
}
}
h.maxKey += 2
}
func (h *Help) computeExtraMaxes(ee map[string]string) {
h.maxDesc = 0
for k := range ee {
if len(k) > h.maxDesc {
h.maxDesc = len(k)
}
}
}
func (h *Help) build() {
h.Clear()
sections := []string{"RESOURCE", "GENERAL", "NAVIGATION"}
h.maxRows = len(h.showGeneral())
ff := []HelpFunc{
h.hints,
h.showGeneral,
h.showNav,
}
var col int
extras := h.app.Content.Top().ExtraHints()
for i, section := range sections {
hh := ff[i]()
sort.Sort(hh)
h.computeMaxes(hh)
if extras != nil {
h.computeExtraMaxes(extras)
}
h.addSection(col, section, hh)
if i == 0 && extras != nil {
h.addExtras(extras, col, len(hh))
}
col += 2
}
if hh, err := h.showHotKeys(); err == nil {
h.computeMaxes(hh)
h.addSection(col, "HOTKEYS", hh)
}
}
func (h *Help) addExtras(extras map[string]string, col, size int) {
kk := make([]string, 0, len(extras))
for k := range extras {
kk = append(kk, k)
}
sort.StringSlice(kk).Sort()
row := size + 1
for _, k := range kk {
h.SetCell(row, col, padCell(extras[k], h.maxKey))
h.SetCell(row, col+1, padCell(k, h.maxDesc))
row++
}
}
func (*Help) showNav() model.MenuHints {
return model.MenuHints{
{
Mnemonic: "g",
Description: "Goto Top",
},
{
Mnemonic: "Shift-g",
Description: "Goto Bottom",
},
{
Mnemonic: "Ctrl-b",
Description: "Page Up",
},
{
Mnemonic: "Ctrl-f",
Description: "Page Down",
},
{
Mnemonic: "h",
Description: "Left",
},
{
Mnemonic: "l",
Description: "Right",
},
{
Mnemonic: "k",
Description: "Up",
},
{
Mnemonic: "j",
Description: "Down",
},
{
Mnemonic: "[",
Description: "History Back",
},
{
Mnemonic: "]",
Description: "History Forward",
},
{
Mnemonic: "-",
Description: "Last Used Command",
},
}
}
func (h *Help) showHotKeys() (model.MenuHints, error) {
hh := config.NewHotKeys()
if err := hh.Load(h.App().Config.ContextHotkeysPath()); err != nil {
return nil, fmt.Errorf("no hotkey configuration found")
}
kk := make(sort.StringSlice, 0, len(hh.HotKey))
for k := range hh.HotKey {
kk = append(kk, k)
}
kk.Sort()
mm := make(model.MenuHints, 0, len(hh.HotKey))
for _, k := range kk {
mm = append(mm, model.MenuHint{
Mnemonic: hh.HotKey[k].ShortCut,
Description: hh.HotKey[k].Description,
})
}
return mm, nil
}
func (*Help) showGeneral() model.MenuHints {
return model.MenuHints{
{
Mnemonic: "?",
Description: "Help",
},
{
Mnemonic: "Ctrl-a",
Description: "Aliases",
},
{
Mnemonic: ":cmd",
Description: "Command mode",
},
{
Mnemonic: "/term",
Description: "Filter mode",
},
{
Mnemonic: "esc",
Description: "Back/Clear",
},
{
Mnemonic: "q",
Description: "Back",
},
{
Mnemonic: "tab",
Description: "Field Next",
},
{
Mnemonic: "backtab",
Description: "Field Previous",
},
{
Mnemonic: "Ctrl-r",
Description: "Reload",
},
{
Mnemonic: "Ctrl-u",
Description: "Command Clear",
},
{
Mnemonic: "Ctrl-e",
Description: "Toggle Header",
},
{
Mnemonic: "Ctrl-g",
Description: "Toggle Crumbs",
},
{
Mnemonic: ":q",
Description: "Quit",
},
{
Mnemonic: "space",
Description: "Mark",
},
{
Mnemonic: "Ctrl-space",
Description: "Mark Range",
},
{
Mnemonic: "Ctrl-\\",
Description: "Mark Clear",
},
{
Mnemonic: "Ctrl-s",
Description: "Save",
},
}
}
func (h *Help) resetTitle() {
h.SetTitle(fmt.Sprintf(helpTitleFmt, helpTitle))
}
func (h *Help) addSpacer(c int) {
cell := tview.NewTableCell(render.Pad("", h.maxKey))
cell.SetExpansion(1)
h.SetCell(0, c, cell)
}
func (h *Help) addSection(c int, title string, hh model.MenuHints) {
if len(hh) > h.maxRows {
h.maxRows = len(hh)
}
row := 0
h.SetCell(row, c, h.titleCell(title))
h.addSpacer(c + 1)
row++
for _, hint := range hh {
col := c
h.SetCell(row, col, padCellWithRef(ui.ToMnemonic(hint.Mnemonic), h.maxKey, hint.Mnemonic))
col++
h.SetCell(row, col, padCell(hint.Description, h.maxDesc))
row++
}
if len(hh) >= h.maxRows {
return
}
for i := h.maxRows - len(hh); i > 0; i-- {
col := c
h.SetCell(row, col, padCell("", h.maxKey))
col++
h.SetCell(row, col, padCell("", h.maxDesc))
row++
}
}
func (h *Help) updateStyle() {
var (
style = tcell.StyleDefault.Background(h.styles.K9s.Help.BgColor.Color())
key = style.Foreground(h.styles.K9s.Help.KeyColor.Color()).Bold(true)
numKey = style.Foreground(h.app.Styles.K9s.Help.NumKeyColor.Color()).Bold(true)
info = style.Foreground(h.app.Styles.K9s.Help.FgColor.Color())
heading = style.Foreground(h.app.Styles.K9s.Help.SectionColor.Color())
)
for col := range h.GetColumnCount() {
for row := range h.GetRowCount() {
c := h.GetCell(row, col)
if c == nil {
continue
}
switch {
case row == 0:
c.SetStyle(heading)
case col%2 != 0:
c.SetStyle(info)
default:
if _, err := strconv.Atoi(extractRef(c)); err == nil {
c.SetStyle(numKey)
continue
}
c.SetStyle(key)
}
}
}
}
// ----------------------------------------------------------------------------
// Helpers...
func extractRef(c *tview.TableCell) string {
if ref, ok := c.GetReference().(string); ok {
return ref
}
return c.Text
}
func (h *Help) titleCell(title string) *tview.TableCell {
c := tview.NewTableCell(title)
c.SetTextColor(h.Styles().K9s.Help.SectionColor.Color())
c.SetAttributes(tcell.AttrBold)
c.SetExpansion(1)
c.SetAlign(tview.AlignLeft)
return c
}
func padCellWithRef(s string, width int, ref any) *tview.TableCell {
return padCell(s, width).SetReference(ref)
}
func padCell(s string, width int) *tview.TableCell {
return tview.NewTableCell(render.Pad(s, width))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/logger.go | internal/view/logger.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
// Logger represents a generic log viewer.
type Logger struct {
*tview.TextView
actions *ui.KeyActions
app *App
title, subject string
cmdBuff *model.FishBuff
}
// NewLogger returns a logger viewer.
func NewLogger(app *App) *Logger {
return &Logger{
TextView: tview.NewTextView(),
app: app,
actions: ui.NewKeyActions(),
cmdBuff: model.NewFishBuff('/', model.FilterBuffer),
}
}
// Init initializes the viewer.
func (l *Logger) Init(_ context.Context) error {
if l.title != "" {
l.SetBorder(true)
}
l.SetScrollable(true).SetWrap(true)
l.SetDynamicColors(true)
l.SetHighlightColor(tcell.ColorOrange)
l.SetTitleColor(tcell.ColorAqua)
l.SetInputCapture(l.keyboard)
l.SetBorderPadding(0, 0, 1, 1)
l.app.Styles.AddListener(l)
l.StylesChanged(l.app.Styles)
l.app.Prompt().SetModel(l.cmdBuff)
l.cmdBuff.AddListener(l)
l.bindKeys()
l.SetInputCapture(l.keyboard)
return nil
}
// BufferChanged indicates the buffer was changed.
func (*Logger) BufferChanged(_, _ string) {}
// BufferCompleted indicates input was accepted.
func (*Logger) BufferCompleted(_, _ string) {}
// BufferActive indicates the buff activity changed.
func (l *Logger) BufferActive(state bool, k model.BufferKind) {
l.app.BufferActive(state, k)
}
func (l *Logger) bindKeys() {
l.actions.Bulk(ui.KeyMap{
tcell.KeyEscape: ui.NewKeyAction("Back", l.resetCmd, false),
ui.KeyQ: ui.NewKeyAction("Back", l.resetCmd, false),
tcell.KeyCtrlS: ui.NewKeyAction("Save", l.saveCmd, false),
ui.KeyC: ui.NewKeyAction("Copy", cpCmd(l.app.Flash(), l.TextView), true),
ui.KeySlash: ui.NewSharedKeyAction("Filter Mode", l.activateCmd, false),
tcell.KeyDelete: ui.NewSharedKeyAction("Erase", l.eraseCmd, false),
})
}
func (l *Logger) keyboard(evt *tcell.EventKey) *tcell.EventKey {
if a, ok := l.actions.Get(ui.AsKey(evt)); ok {
return a.Action(evt)
}
return evt
}
// StylesChanged notifies the skin changed.
func (l *Logger) StylesChanged(*config.Styles) {
l.SetBackgroundColor(l.app.Styles.BgColor())
l.SetTextColor(l.app.Styles.FgColor())
l.SetBorderFocusColor(l.app.Styles.Frame().Border.FocusColor.Color())
}
// SetSubject updates the subject.
func (l *Logger) SetSubject(s string) {
l.subject = s
}
// Actions returns menu actions.
func (l *Logger) Actions() *ui.KeyActions {
return l.actions
}
// Name returns the component name.
func (l *Logger) Name() string { return l.title }
// Start starts the view updater.
func (*Logger) Start() {}
// Stop terminates the updater.
func (l *Logger) Stop() {
l.app.Styles.RemoveListener(l)
}
// Hints returns menu hints.
func (l *Logger) Hints() model.MenuHints {
return l.actions.Hints()
}
// ExtraHints returns additional hints.
func (*Logger) ExtraHints() map[string]string {
return nil
}
func (l *Logger) activateCmd(evt *tcell.EventKey) *tcell.EventKey {
if l.app.InCmdMode() {
return evt
}
l.app.ResetPrompt(l.cmdBuff)
return nil
}
func (l *Logger) eraseCmd(*tcell.EventKey) *tcell.EventKey {
if !l.cmdBuff.IsActive() {
return nil
}
l.cmdBuff.Delete()
return nil
}
func (l *Logger) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !l.cmdBuff.InCmdMode() {
l.cmdBuff.Reset()
return l.app.PrevCmd(evt)
}
l.cmdBuff.SetActive(false)
l.cmdBuff.Reset()
return nil
}
func (l *Logger) saveCmd(*tcell.EventKey) *tcell.EventKey {
if path, err := saveYAML(l.app.Config.K9s.ContextScreenDumpDir(), l.title, l.GetText(true)); err != nil {
l.app.Flash().Err(err)
} else {
l.app.Flash().Infof("Log %s saved successfully!", path)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/user.go | internal/view/user.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// User presents a user viewer.
type User struct {
ResourceViewer
}
// NewUser returns a new subject viewer.
func NewUser(gvr *client.GVR) ResourceViewer {
u := User{ResourceViewer: NewBrowser(gvr)}
u.AddBindKeysFn(u.bindKeys)
u.SetContextFn(u.subjectCtx)
return &u
}
func (u *User) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, ui.KeyShiftP, tcell.KeyCtrlSpace, ui.KeySpace, tcell.KeyCtrlD, ui.KeyE)
aa.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("Rules", u.policyCmd, true),
ui.KeyShiftK: ui.NewKeyAction("Sort Kind", u.GetTable().SortColCmd("KIND", true), false),
})
}
func (*User) subjectCtx(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeySubjectKind, "User")
}
func (u *User) policyCmd(evt *tcell.EventKey) *tcell.EventKey {
path := u.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if err := u.App().inject(NewPolicy(u.App(), "User", path), false); err != nil {
u.App().Flash().Err(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/view/sts.go | internal/view/sts.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
appsv1 "k8s.io/api/apps/v1"
)
// StatefulSet represents a statefulset viewer.
type StatefulSet struct {
ResourceViewer
}
// NewStatefulSet returns a new viewer.
func NewStatefulSet(gvr *client.GVR) ResourceViewer {
var s StatefulSet
s.ResourceViewer = NewPortForwardExtender(
NewVulnerabilityExtender(
NewRestartExtender(
NewScaleExtender(
NewImageExtender(
NewOwnerExtender(
NewLogsExtender(NewBrowser(gvr), s.logOptions),
),
),
),
),
),
)
s.AddBindKeysFn(s.bindKeys)
s.GetTable().SetEnterFn(s.showPods)
return &s
}
func (s *StatefulSet) logOptions(prev bool) (*dao.LogOptions, error) {
path := s.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("you must provide a selection")
}
sts, err := s.getInstance(path)
if err != nil {
return nil, err
}
return podLogOptions(s.App(), path, prev, &sts.ObjectMeta, &sts.Spec.Template.Spec), nil
}
func (s *StatefulSet) bindKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyShiftR, ui.NewKeyAction("Sort Ready", s.GetTable().SortColCmd(readyCol, true), false))
}
func (s *StatefulSet) showPods(app *App, _ ui.Tabular, _ *client.GVR, path string) {
i, err := s.getInstance(path)
if err != nil {
app.Flash().Err(err)
return
}
showPodsFromSelector(app, path, i.Spec.Selector)
}
func (s *StatefulSet) getInstance(path string) (*appsv1.StatefulSet, error) {
var sts dao.StatefulSet
return sts.GetInstance(s.App().factory, path)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/app.go | internal/view/app.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"maps"
"os"
"os/signal"
"sort"
"strings"
"sync/atomic"
"syscall"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/k9s/internal/vul"
"github.com/derailed/k9s/internal/watch"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
// ExitStatus indicates UI exit conditions.
var ExitStatus = ""
const (
splashDelay = 1 * time.Second
clusterRefresh = 15 * time.Second
clusterInfoWidth = 50
clusterInfoPad = 15
)
// App represents an application view.
type App struct {
version string
*ui.App
Content *PageStack
command *Command
factory *watch.Factory
cancelFn context.CancelFunc
clusterModel *model.ClusterInfo
cmdHistory *model.History
filterHistory *model.History
conRetry int32
showHeader bool
showLogo bool
showCrumbs bool
}
// NewApp returns a K9s app instance.
func NewApp(cfg *config.Config) *App {
a := App{
App: ui.NewApp(cfg, cfg.K9s.ActiveContextName()),
cmdHistory: model.NewHistory(model.MaxHistory),
filterHistory: model.NewHistory(model.MaxHistory),
Content: NewPageStack(),
}
a.ReloadStyles()
a.Views()["statusIndicator"] = ui.NewStatusIndicator(a.App, a.Styles)
a.Views()["clusterInfo"] = NewClusterInfo(&a)
return &a
}
// ReloadStyles reloads skin file.
func (a *App) ReloadStyles() {
a.RefreshStyles(a)
}
// UpdateClusterInfo updates clusterInfo panel
func (a *App) UpdateClusterInfo() {
if a.factory != nil {
a.clusterModel.Reset(a.factory)
}
}
// ConOK checks the connection is cool, returns false otherwise.
func (a *App) ConOK() bool {
return atomic.LoadInt32(&a.conRetry) == 0
}
// Init initializes the application.
func (a *App) Init(version string, _ int) error {
a.version = model.NormalizeVersion(version)
ctx := context.WithValue(context.Background(), internal.KeyApp, a)
if err := a.Content.Init(ctx); err != nil {
return err
}
a.Content.AddListener(a.Crumbs())
a.Content.AddListener(a.Menu())
a.App.Init()
a.SetInputCapture(a.keyboard)
a.bindKeys()
// Allow initialization even without a valid connection
// We'll fall back to context view in defaultCmd
if a.Conn() != nil {
ns := a.Config.ActiveNamespace()
a.factory = watch.NewFactory(a.Conn())
a.initFactory(ns)
a.clusterModel = model.NewClusterInfo(a.factory, a.version, a.Config.K9s)
a.clusterModel.AddListener(a.clusterInfo())
a.clusterModel.AddListener(a.statusIndicator())
if a.Conn().ConnectionOK() {
a.clusterModel.Refresh()
a.clusterInfo().Init()
}
}
a.command = NewCommand(a)
if err := a.command.Init(a.Config.ContextAliasesPath()); err != nil {
return err
}
a.CmdBuff().SetSuggestionFn(a.suggestCommand())
a.layout(ctx)
a.initSignals()
if a.Config.K9s.ImageScans.Enable {
a.initImgScanner(version)
}
a.ReloadStyles()
return nil
}
func (*App) stopImgScanner() {
if vul.ImgScanner != nil {
vul.ImgScanner.Stop()
}
}
func (a *App) clearHistory() {
a.cmdHistory.Clear()
a.filterHistory.Clear()
}
func (a *App) initImgScanner(version string) {
defer func(t time.Time) {
slog.Debug("Scanner init time", slogs.Elapsed, time.Since(t))
}(time.Now())
vul.ImgScanner = vul.NewImageScanner(a.Config.K9s.ImageScans, slog.Default())
go vul.ImgScanner.Init("k9s", version)
}
func (a *App) layout(ctx context.Context) {
flash := ui.NewFlash(a.App)
go flash.Watch(ctx, a.Flash().Channel())
main := tview.NewFlex().SetDirection(tview.FlexRow)
main.AddItem(a.statusIndicator(), 1, 1, false)
main.AddItem(a.Content, 0, 10, true)
if !a.Config.K9s.IsCrumbsless() {
main.AddItem(a.Crumbs(), 1, 1, false)
}
main.AddItem(flash, 1, 1, false)
a.Main.AddPage("main", main, true, false)
a.toggleHeader(!a.Config.K9s.IsHeadless(), !a.Config.K9s.IsLogoless())
if !a.Config.K9s.IsSplashless() {
a.Main.AddPage("splash", ui.NewSplash(a.Styles, a.version), true, true)
}
}
func (*App) initSignals() {
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGHUP)
go func(sig chan os.Signal) {
<-sig
os.Exit(0)
}(sig)
}
func (a *App) suggestCommand() model.SuggestionFunc {
contextNames, err := a.contextNames()
if err != nil {
slog.Error("Failed to list contexts", slogs.Error, err)
}
return func(s string) (entries sort.StringSlice) {
if s == "" {
if a.cmdHistory.Empty() {
return
}
return a.cmdHistory.List()
}
ls := strings.ToLower(s)
for alias := range maps.Keys(a.command.alias.Alias) {
if suggest, ok := cmd.ShouldAddSuggest(ls, alias); ok {
entries = append(entries, suggest)
}
}
namespaceNames, err := a.factory.Client().ValidNamespaceNames()
if err != nil {
slog.Error("Failed to obtain list of namespaces", slogs.Error, err)
}
entries = append(entries, cmd.SuggestSubCommand(s, namespaceNames, contextNames)...)
if len(entries) == 0 {
return nil
}
entries.Sort()
return
}
}
func (a *App) contextNames() ([]string, error) {
// Return empty list if no factory
if a.factory == nil {
return []string{}, nil
}
contexts, err := a.factory.Client().Config().Contexts()
if err != nil {
return nil, err
}
contextNames := make([]string, 0, len(contexts))
for ctxName := range contexts {
contextNames = append(contextNames, ctxName)
}
return contextNames, nil
}
func (a *App) keyboard(evt *tcell.EventKey) *tcell.EventKey {
if k, ok := a.HasAction(ui.AsKey(evt)); ok && !a.Content.IsTopDialog() {
return k.Action(evt)
}
return evt
}
func (a *App) bindKeys() {
a.AddActions(ui.NewKeyActionsFromMap(ui.KeyMap{
tcell.KeyCtrlE: ui.NewSharedKeyAction("ToggleHeader", a.toggleHeaderCmd, false),
tcell.KeyCtrlG: ui.NewSharedKeyAction("ToggleCrumbs", a.toggleCrumbsCmd, false),
ui.KeyHelp: ui.NewSharedKeyAction("Help", a.helpCmd, false),
ui.KeyLeftBracket: ui.NewSharedKeyAction("Go Back", a.previousCommand, false),
ui.KeyRightBracket: ui.NewSharedKeyAction("Go Forward", a.nextCommand, false),
ui.KeyDash: ui.NewSharedKeyAction("Last View", a.lastCommand, false),
tcell.KeyCtrlA: ui.NewSharedKeyAction("Aliases", a.aliasCmd, false),
tcell.KeyEnter: ui.NewKeyAction("Goto", a.gotoCmd, false),
tcell.KeyCtrlC: ui.NewKeyAction("Quit", a.quitCmd, false),
}))
}
// ActiveView returns the currently active view.
func (a *App) ActiveView() model.Component {
return a.Content.GetPrimitive("main").(model.Component)
}
func (a *App) toggleHeader(header, logo bool) {
a.showHeader, a.showLogo = header, logo
flex, ok := a.Main.GetPrimitive("main").(*tview.Flex)
if !ok {
slog.Error("Expecting flex view main panel. Exiting!")
os.Exit(1)
}
if a.showHeader {
flex.RemoveItemAtIndex(0)
flex.AddItemAtIndex(0, a.buildHeader(), 7, 1, false)
} else {
flex.RemoveItemAtIndex(0)
flex.AddItemAtIndex(0, a.statusIndicator(), 1, 1, false)
}
}
func (a *App) toggleCrumbs(flag bool) {
a.showCrumbs = flag
flex, ok := a.Main.GetPrimitive("main").(*tview.Flex)
if !ok {
slog.Error("Expecting valid flex view main panel. Exiting!")
os.Exit(1)
}
if a.showCrumbs {
if _, ok := flex.ItemAt(2).(*ui.Crumbs); !ok {
flex.AddItemAtIndex(2, a.Crumbs(), 1, 1, false)
}
} else {
flex.RemoveItemAtIndex(2)
}
}
func (a *App) buildHeader() tview.Primitive {
header := tview.NewFlex()
header.SetBackgroundColor(a.Styles.BgColor())
header.SetDirection(tview.FlexColumn)
if !a.showHeader {
return header
}
clWidth := clusterInfoWidth
if a.Conn() != nil && a.Conn().ConnectionOK() {
n, err := a.Conn().Config().CurrentClusterName()
if err == nil {
size := len(n) + clusterInfoPad
if size > clWidth {
clWidth = size
}
}
}
header.AddItem(a.clusterInfo(), clWidth, 1, false)
header.AddItem(a.Menu(), 0, 1, false)
if a.showLogo {
header.AddItem(a.Logo(), 26, 1, false)
}
return header
}
// Halt stop the application event loop.
func (a *App) Halt() {
if a.cancelFn != nil {
a.cancelFn()
a.cancelFn = nil
}
}
// Resume restarts the app event loop.
func (a *App) Resume() {
var ctx context.Context
ctx, a.cancelFn = context.WithCancel(context.Background())
go a.clusterUpdater(ctx)
if a.Config.K9s.UI.Reactive {
if err := a.ConfigWatcher(ctx, a); err != nil {
slog.Warn("ConfigWatcher failed", slogs.Error, err)
}
if err := a.SkinsDirWatcher(ctx, a); err != nil {
slog.Warn("SkinsWatcher failed", slogs.Error, err)
}
if err := a.CustomViewsWatcher(ctx, a); err != nil {
slog.Warn("CustomView watcher failed", slogs.Error, err)
}
}
}
func (a *App) clusterUpdater(ctx context.Context) {
if a.Conn() == nil || !a.Conn().ConnectionOK() || a.factory == nil || a.clusterModel == nil {
slog.Debug("Skipping cluster updater - no valid connection")
return
}
if err := a.refreshCluster(ctx); err != nil {
slog.Error("Cluster updater failed!", slogs.Error, err)
return
}
bf := model.NewExpBackOff(ctx, clusterRefresh, 2*time.Minute)
delay := clusterRefresh
for {
select {
case <-ctx.Done():
slog.Debug("ClusterInfo updater canceled!")
return
case <-time.After(delay):
if err := a.refreshCluster(ctx); err != nil {
slog.Error("Cluster updates failed. Giving up ;(", slogs.Error, err)
if delay = bf.NextBackOff(); delay == backoff.Stop {
a.BailOut(1)
return
}
} else {
bf.Reset()
delay = clusterRefresh
}
}
}
}
func (a *App) refreshCluster(context.Context) error {
if a.Conn() == nil || a.factory == nil || a.clusterModel == nil {
return nil
}
c := a.Content.Top()
if ok := a.Conn().CheckConnectivity(); ok {
if atomic.LoadInt32(&a.conRetry) > 0 {
atomic.StoreInt32(&a.conRetry, 0)
a.Status(model.FlashInfo, "K8s connectivity OK")
if c != nil {
c.Start()
}
} else {
a.ClearStatus(true)
}
a.factory.ValidatePortForwards()
} else if c != nil {
atomic.AddInt32(&a.conRetry, 1)
c.Stop()
}
count, maxConnRetry := atomic.LoadInt32(&a.conRetry), a.Config.K9s.MaxConnRetry
if count >= maxConnRetry {
slog.Error("Conn check failed. Bailing out!",
slogs.Retry, count,
slogs.MaxRetries, maxConnRetry,
)
ExitStatus = fmt.Sprintf("Lost K8s connection (%d). Bailing out!", count)
a.BailOut(1)
}
if count > 0 {
a.Status(model.FlashWarn, fmt.Sprintf("Dial K8s Toast [%d/%d]", count, maxConnRetry))
return fmt.Errorf("conn check failed (%d/%d)", count, maxConnRetry)
}
// Reload alias
go func() {
if err := a.command.Reset(a.Config.ContextAliasesPath(), false); err != nil {
slog.Warn("Command reset failed", slogs.Error, err)
a.QueueUpdateDraw(func() {
a.Logo().Warn("Aliases load failed!")
})
}
}()
// Update cluster info
a.clusterModel.Refresh()
return nil
}
func (a *App) switchNS(ns string) error {
if a.Config.ActiveNamespace() == ns {
return nil
}
if ns == client.ClusterScope {
ns = client.BlankNamespace
}
if err := a.Config.SetActiveNamespace(ns); err != nil {
return err
}
return a.factory.SetActiveNS(ns)
}
func (a *App) switchContext(ci *cmd.Interpreter, force bool) error {
contextName, ok := ci.HasContext()
if (!ok || a.Config.ActiveContextName() == contextName) && !force {
return nil
}
a.Halt()
defer a.Resume()
{
a.Config.Reset()
ct, err := a.Config.ActivateContext(contextName)
if err != nil {
return err
}
if cns, ok := ci.NSArg(); ok {
ct.Namespace.Active = cns
}
p := cmd.NewInterpreter(a.Config.ActiveView())
p.ResetContextArg()
if p.IsContextCmd() {
a.Config.SetActiveView(client.PodGVR.String())
}
ns := a.Config.ActiveNamespace()
if !a.Conn().IsValidNamespace(ns) {
slog.Warn("Unable to validate namespace", slogs.Namespace, ns)
if err := a.Config.SetActiveNamespace(ns); err != nil {
return err
}
}
a.Flash().Infof("Using %q namespace", ns)
if err := a.Config.Save(true); err != nil {
slog.Error("Fail to save config to disk", slogs.Subsys, "config", slogs.Error, err)
}
if a.factory == nil && a.Conn() != nil {
a.factory = watch.NewFactory(a.Conn())
a.clusterModel = model.NewClusterInfo(a.factory, a.version, a.Config.K9s)
a.clusterModel.AddListener(a.clusterInfo())
a.clusterModel.AddListener(a.statusIndicator())
}
if a.factory != nil {
a.initFactory(ns)
}
if err := a.command.Reset(a.Config.ContextAliasesPath(), true); err != nil {
return err
}
slog.Debug("Switching Context",
slogs.Context, contextName,
slogs.Namespace, ns,
slogs.View, a.Config.ActiveView(),
)
a.Flash().Infof("Switching context to %q::%q", contextName, ns)
a.ReloadStyles()
a.gotoResource(a.Config.ActiveView(), "", true, true)
if a.clusterModel != nil {
a.clusterModel.Reset(a.factory)
}
}
return nil
}
func (a *App) initFactory(ns string) {
a.factory.Terminate()
a.factory.Start(ns)
}
// BailOut exists the application.
func (a *App) BailOut(exitCode int) {
defer func() {
if err := recover(); err != nil {
slog.Error("Bailout failed", slogs.Error, err)
}
}()
if err := nukeK9sShell(a); err != nil {
slog.Error("Unable to nuke k9s shell pod", slogs.Error, err)
}
a.stopImgScanner()
a.factory.Terminate()
a.App.BailOut(exitCode)
}
// Run starts the application loop.
func (a *App) Run() error {
a.Resume()
go func() {
if !a.Config.K9s.IsSplashless() {
<-time.After(splashDelay)
}
a.QueueUpdateDraw(func() {
a.Main.SwitchToPage("main")
// if command bar is already active, focus it
if a.CmdBuff().IsActive() {
a.SetFocus(a.Prompt())
}
})
}()
if err := a.command.defaultCmd(true); err != nil {
return err
}
a.SetRunning(true)
if err := a.Application.Run(); err != nil {
return err
}
return nil
}
// Status reports a new app status for display.
func (a *App) Status(l model.FlashLevel, msg string) {
a.QueueUpdateDraw(func() {
if a.showHeader {
a.setLogo(l, msg)
} else {
a.setIndicator(l, msg)
}
})
}
// IsBenchmarking check if benchmarks are active.
func (a *App) IsBenchmarking() bool {
return a.Logo().IsBenchmarking()
}
// ClearStatus reset logo back to normal.
func (a *App) ClearStatus(flash bool) {
a.QueueUpdate(func() {
a.Logo().Reset()
if flash {
a.Flash().Clear()
}
})
}
func (a *App) setLogo(l model.FlashLevel, msg string) {
switch l {
case model.FlashErr:
a.Logo().Err(msg)
case model.FlashWarn:
a.Logo().Warn(msg)
case model.FlashInfo:
a.Logo().Info(msg)
default:
a.Logo().Reset()
}
}
func (a *App) setIndicator(l model.FlashLevel, msg string) {
switch l {
case model.FlashErr:
a.statusIndicator().Err(msg)
case model.FlashWarn:
a.statusIndicator().Warn(msg)
case model.FlashInfo:
a.statusIndicator().Info(msg)
default:
a.statusIndicator().Reset()
}
}
// PrevCmd pops the command stack.
func (a *App) PrevCmd(*tcell.EventKey) *tcell.EventKey {
if !a.Content.IsLast() {
a.Content.Pop()
}
return nil
}
func (a *App) toggleHeaderCmd(evt *tcell.EventKey) *tcell.EventKey {
if a.Prompt().InCmdMode() {
return evt
}
a.QueueUpdateDraw(func() {
a.showHeader = !a.showHeader
a.toggleHeader(a.showHeader, a.showLogo)
})
return nil
}
func (a *App) toggleCrumbsCmd(evt *tcell.EventKey) *tcell.EventKey {
if a.Prompt().InCmdMode() {
return evt
}
a.QueueUpdateDraw(func() {
a.showCrumbs = !a.showCrumbs
a.toggleCrumbs(a.showCrumbs)
})
return nil
}
func (a *App) gotoCmd(evt *tcell.EventKey) *tcell.EventKey {
if a.CmdBuff().IsActive() && !a.CmdBuff().Empty() {
a.gotoResource(a.GetCmd(), "", true, true)
a.ResetCmd()
return nil
}
return evt
}
func (a *App) cowCmd(msg string) {
d := a.Styles.Dialog()
dialog.ShowError(&d, a.Content.Pages, msg)
}
func (a *App) dirCmd(path string, pushCmd bool) error {
slog.Debug("Exec Dir command", slogs.Path, path)
_, err := os.Stat(path)
if err != nil {
return err
}
if path == "." {
dir, err := os.Getwd()
if err == nil {
path = dir
}
}
if pushCmd {
a.cmdHistory.Push("dir " + path)
}
return a.inject(NewDir(path), true)
}
func (a *App) quitCmd(evt *tcell.EventKey) *tcell.EventKey {
noExit := a.Config.K9s.NoExitOnCtrlC
if a.InCmdMode() {
if isBailoutEvt(evt) && noExit {
return nil
}
return evt
}
if !noExit {
a.BailOut(0)
}
return nil
}
func (a *App) helpCmd(evt *tcell.EventKey) *tcell.EventKey {
if evt != nil && evt.Rune() == '?' && a.Prompt().InCmdMode() {
return evt
}
top := a.Content.Top()
if top != nil && top.Name() == "help" {
a.Content.Pop()
return nil
}
if err := a.inject(NewHelp(a), false); err != nil {
a.Flash().Err(err)
}
a.Prompt().Deactivate()
return nil
}
// previousCommand returns to the command prior to the current one in the history
func (a *App) previousCommand(evt *tcell.EventKey) *tcell.EventKey {
if evt != nil && evt.Rune() == rune(ui.KeyLeftBracket) && a.Prompt().InCmdMode() {
return evt
}
c, ok := a.cmdHistory.Back()
if !ok {
a.App.Flash().Warn("Can't go back any further")
return evt
}
a.gotoResource(c, "", true, false)
return nil
}
// nextCommand returns to the command subsequent to the current one in the history
func (a *App) nextCommand(evt *tcell.EventKey) *tcell.EventKey {
if evt != nil && evt.Rune() == rune(ui.KeyRightBracket) && a.Prompt().InCmdMode() {
return evt
}
c, ok := a.cmdHistory.Forward()
if !ok {
a.App.Flash().Warn("Can't go forward any further")
return evt
}
// We go to the resource before updating the history so that
// gotoResource doesn't add this command to the history
a.gotoResource(c, "", true, false)
return nil
}
// lastCommand switches between the last command and the current one a la `cd -`
func (a *App) lastCommand(evt *tcell.EventKey) *tcell.EventKey {
if evt != nil && evt.Rune() == ui.KeyDash && a.Prompt().InCmdMode() {
return evt
}
c, ok := a.cmdHistory.Top()
if !ok {
a.App.Flash().Warn("No previous view to switch to")
return evt
}
a.gotoResource(c, "", true, false)
return nil
}
func (a *App) aliasCmd(*tcell.EventKey) *tcell.EventKey {
if a.Content.Top() != nil && a.Content.Top().Name() == aliasTitle {
a.Content.Pop()
return nil
}
if err := a.inject(NewAlias(client.AliGVR), false); err != nil {
a.Flash().Err(err)
}
return nil
}
func (a *App) gotoResource(c, path string, clearStack, pushCmd bool) {
err := a.command.run(cmd.NewInterpreter(c), path, clearStack, pushCmd)
if err != nil {
d := a.Styles.Dialog()
dialog.ShowError(&d, a.Content.Pages, err.Error())
}
}
func (a *App) inject(c model.Component, clearStack bool) error {
ctx := context.WithValue(context.Background(), internal.KeyApp, a)
if err := c.Init(ctx); err != nil {
slog.Error("Component init failed",
slogs.Error, err,
slogs.CompName, c.Name(),
)
return err
}
if clearStack {
a.Content.Clear()
}
a.Content.Push(c)
return nil
}
func (a *App) clusterInfo() *ClusterInfo {
return a.Views()["clusterInfo"].(*ClusterInfo)
}
func (a *App) statusIndicator() *ui.StatusIndicator {
return a.Views()["statusIndicator"].(*ui.StatusIndicator)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cronjob.go | internal/view/cronjob.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"strings"
"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/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
batchv1 "k8s.io/api/batch/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
const (
suspendDialogKey = "suspend"
lastScheduledCol = "LAST_SCHEDULE"
defaultSuspendStatus = "true"
)
// CronJob represents a cronjob viewer.
type CronJob struct {
ResourceViewer
}
// NewCronJob returns a new viewer.
func NewCronJob(gvr *client.GVR) ResourceViewer {
c := CronJob{ResourceViewer: NewVulnerabilityExtender(
NewOwnerExtender(NewBrowser(gvr)),
)}
c.AddBindKeysFn(c.bindKeys)
c.GetTable().SetEnterFn(c.showJobs)
return &c
}
func (*CronJob) showJobs(app *App, _ ui.Tabular, gvr *client.GVR, fqn string) {
slog.Debug("Showing Jobs", slogs.GVR, gvr, slogs.FQN, fqn)
o, err := app.factory.Get(gvr, fqn, true, labels.Everything())
if err != nil {
app.Flash().Err(err)
return
}
var cj batchv1.CronJob
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &cj)
if err != nil {
app.Flash().Err(err)
return
}
ns, _ := client.Namespaced(fqn)
if err := app.Config.SetActiveNamespace(ns); err != nil {
slog.Error("Unable to set active namespace during show pods", slogs.Error, err)
}
v := NewJob(client.JobGVR)
v.SetContextFn(jobCtx(fqn, string(cj.UID)))
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func jobCtx(fqn, uid string) ContextFunc {
return func(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, fqn)
return context.WithValue(ctx, internal.KeyUID, uid)
}
}
func (c *CronJob) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyT: ui.NewKeyAction("Trigger", c.triggerCmd, true),
ui.KeyS: ui.NewKeyAction("Suspend/Resume", c.toggleSuspendCmd, true),
ui.KeyShiftL: ui.NewKeyAction("Sort LastScheduled", c.GetTable().SortColCmd(lastScheduledCol, true), false),
})
}
func (c *CronJob) triggerCmd(evt *tcell.EventKey) *tcell.EventKey {
fqns := c.GetTable().GetSelectedItems()
if len(fqns) == 0 {
return evt
}
msg := fmt.Sprintf("Trigger CronJob: %s?", fqns[0])
if len(fqns) > 1 {
msg = fmt.Sprintf("Trigger %d CronJobs?", len(fqns))
}
d := c.App().Styles.Dialog()
dialog.ShowConfirm(&d, c.App().Content.Pages, "Confirm Job Trigger", msg, func() {
res, err := dao.AccessorFor(c.App().factory, c.GVR())
if err != nil {
c.App().Flash().Err(fmt.Errorf("no accessor for %q", c.GVR()))
return
}
runner, ok := res.(dao.Runnable)
if !ok {
c.App().Flash().Err(fmt.Errorf("expecting a job runner resource for %q", c.GVR()))
return
}
for _, fqn := range fqns {
if err := runner.Run(fqn); err != nil {
c.App().Flash().Errf("CronJob trigger failed for %s: %v", fqn, err)
} else {
c.App().Flash().Infof("Triggered Job %s %s", c.GVR(), fqn)
}
}
}, func() {})
return nil
}
func (c *CronJob) toggleSuspendCmd(evt *tcell.EventKey) *tcell.EventKey {
table := c.GetTable()
sel := table.GetSelectedItem()
if sel == "" {
return evt
}
cell := table.GetCell(c.GetTable().GetSelectedRowIndex(), c.GetTable().NameColIndex()+2)
if cell == nil {
c.App().Flash().Errf("Unable to assert current status")
return nil
}
c.Stop()
defer c.Start()
c.showSuspendDialog(cell, sel)
return nil
}
func (c *CronJob) showSuspendDialog(cell *tview.TableCell, sel string) {
title := "Suspend"
if strings.TrimSpace(cell.Text) == defaultSuspendStatus {
title = "Resume"
}
d := c.App().Styles.Dialog()
dialog.ShowConfirm(&d, c.App().Content.Pages, title, sel, func() {
ctx, cancel := context.WithTimeout(context.Background(), c.App().Conn().Config().CallTimeout())
defer cancel()
res, err := dao.AccessorFor(c.App().factory, c.GVR())
if err != nil {
c.App().Flash().Err(fmt.Errorf("no accessor for %q", c.GVR()))
return
}
cronJob, ok := res.(*dao.CronJob)
if !ok {
c.App().Flash().Errf("expecting a cron job for %q", c.GVR())
return
}
if err := cronJob.ToggleSuspend(ctx, sel); err != nil {
c.App().Flash().Errf("Cronjob %s failed for %v", strings.ToLower(title), err)
return
}
}, func() {})
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/vul_extender.go | internal/view/vul_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// VulnerabilityExtender adds vul image scan extensions.
type VulnerabilityExtender struct {
ResourceViewer
}
// NewVulnerabilityExtender returns a new extender.
func NewVulnerabilityExtender(r ResourceViewer) ResourceViewer {
v := VulnerabilityExtender{ResourceViewer: r}
v.AddBindKeysFn(v.bindKeys)
return &v
}
func (v *VulnerabilityExtender) bindKeys(aa *ui.KeyActions) {
if v.App().Config.K9s.ImageScans.Enable {
aa.Bulk(ui.KeyMap{
ui.KeyV: ui.NewKeyAction("Show Vulnerabilities", v.showVulCmd, true),
ui.KeyShiftV: ui.NewKeyAction("Sort Vulnerabilities", v.GetTable().SortColCmd("VS", true), false),
})
}
}
func (v *VulnerabilityExtender) showVulCmd(*tcell.EventKey) *tcell.EventKey {
isv := NewImageScan(client.ScnGVR)
isv.SetContextFn(v.selContext)
if err := v.App().inject(isv, false); err != nil {
v.App().Flash().Err(err)
}
return nil
}
func (v *VulnerabilityExtender) selContext(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, v.GetTable().GetSelectedItem())
return context.WithValue(ctx, internal.KeyGVR, v.GVR())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/helpers.go | internal/view/helpers.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"fmt"
"log/slog"
"os"
"regexp"
"strconv"
"strings"
"github.com/atotto/clipboard"
"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/model"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"github.com/sahilm/fuzzy"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
)
func isBailoutEvt(evt *tcell.EventKey) bool {
return evt.Name() == "Ctrl+C"
}
func aliases(m *v1.APIResource, aa sets.Set[string]) sets.Set[string] {
ss := sets.New(aa.UnsortedList()...)
ss.Insert(m.Name)
ss.Insert(m.ShortNames...)
if m.SingularName != "" {
ss.Insert(m.SingularName)
}
return ss
}
func clipboardWrite(text string) error {
if text != "" {
return clipboard.WriteAll(text)
}
return nil
}
var bracketRX = regexp.MustCompile(`\[(.+)\[\]`)
func sanitizeEsc(s string) string {
return bracketRX.ReplaceAllString(s, `[$1]`)
}
func cpCmd(flash *model.Flash, v *tview.TextView) func(*tcell.EventKey) *tcell.EventKey {
return func(evt *tcell.EventKey) *tcell.EventKey {
if err := clipboardWrite(sanitizeEsc(v.GetText(true))); err != nil {
flash.Err(err)
return evt
}
flash.Info("Content copied to clipboard...")
return nil
}
}
func parsePFAnn(s string) (port, lport string, ok bool) {
tokens := strings.Split(s, ":")
if len(tokens) != 2 {
return
}
return tokens[0], tokens[1], true
}
func k8sEnv(c *client.Config) Env {
ctx, err := c.CurrentContextName()
if err != nil {
ctx = render.NAValue
}
cluster, err := c.CurrentClusterName()
if err != nil {
cluster = render.NAValue
}
user, err := c.CurrentUserName()
if err != nil {
user = render.NAValue
}
groups, err := c.CurrentGroupNames()
if err != nil {
groups = []string{render.NAValue}
}
var cfg string
kcfg := c.Flags().KubeConfig
if kcfg != nil && *kcfg != "" {
cfg = *kcfg
} else {
cfg = os.Getenv("KUBECONFIG")
}
return Env{
"CONTEXT": ctx,
"CLUSTER": cluster,
"USER": user,
"GROUPS": strings.Join(groups, ","),
"KUBECONFIG": cfg,
}
}
func defaultEnv(c *client.Config, path string, header model1.Header, row *model1.Row) Env {
env := k8sEnv(c)
env["NAMESPACE"], env["NAME"] = client.Namespaced(path)
if row == nil {
return env
}
for _, col := range header.ColumnNames(true) {
idx, ok := header.IndexOf(col, true)
if ok && idx < len(row.Fields) {
env["COL-"+col] = row.Fields[idx]
}
}
return env
}
func describeResource(app *App, _ ui.Tabular, gvr *client.GVR, path string) {
v := NewLiveView(app, "Describe", model.NewDescribe(gvr, path))
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func showReplicasets(app *App, path string, labelSel labels.Selector, fieldSel string) {
v := NewReplicaSet(client.RsGVR)
v.SetContextFn(func(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, path)
return context.WithValue(ctx, internal.KeyFields, fieldSel)
})
v.SetLabelSelector(labelSel, true)
ns, _ := client.Namespaced(path)
if err := app.Config.SetActiveNamespace(ns); err != nil {
slog.Error("Unable to set active namespace during show replicasets", slogs.Error, err)
}
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func showPods(app *App, path string, labelSel labels.Selector, fieldSel string) {
v := NewPod(client.PodGVR)
v.SetContextFn(podCtx(app, path, fieldSel))
v.SetLabelSelector(labelSel, true)
ns, _ := client.Namespaced(path)
if err := app.Config.SetActiveNamespace(ns); err != nil {
slog.Error("Unable to set active namespace during show pods", slogs.Error, err)
}
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func podCtx(_ *App, path, fieldSel string) ContextFunc {
return func(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, path)
return context.WithValue(ctx, internal.KeyFields, fieldSel)
}
}
func extractApp(ctx context.Context) (*App, error) {
app, ok := ctx.Value(internal.KeyApp).(*App)
if !ok {
return nil, errors.New("no application found in context")
}
return app, nil
}
// AsKey maps a string representation of a key to a tcell key.
func asKey(key string) (tcell.Key, error) {
for k, v := range tcell.KeyNames {
if key == v {
return k, nil
}
}
return 0, fmt.Errorf("invalid key specified: %q", key)
}
// FwFQN returns a fully qualified ns/name:container id.
func fwFQN(po, co string) string {
return po + "|" + co
}
func isTCPPort(p string) bool {
return !strings.Contains(p, "UDP")
}
// ContainerID computes container ID based on ns/po/co.
func containerID(path, co string) string {
ns, n := client.Namespaced(path)
po := strings.Split(n, "-")[0]
return ns + "/" + po + ":" + co
}
// UrlFor computes fq url for a given benchmark configuration.
func urlFor(cfg *config.BenchConfig, port string) string {
host := "localhost"
if cfg.HTTP.Host != "" {
host = cfg.HTTP.Host
}
path := "/"
if cfg.HTTP.Path != "" {
path = cfg.HTTP.Path
}
return "http://" + host + ":" + port + path
}
func fqn(ns, n string) string {
if ns == "" {
return n
}
return ns + "/" + n
}
func decorateCpuMemHeaderRows(app *App, data *model1.TableData) {
for colIndex, header := range data.Header() {
var check string
if header.Name == "%CPU/L" {
check = config.CPU
}
if header.Name == "%MEM/L" {
check = config.MEM
}
if check == "" {
continue
}
data.RowsRange(func(_ int, re model1.RowEvent) bool {
if re.Row.Fields[colIndex] == render.NAValue {
return true
}
n, err := strconv.Atoi(re.Row.Fields[colIndex])
if err != nil {
return true
}
if n > 100 {
n = 100
}
severity := app.Config.K9s.Thresholds.LevelFor(check, n)
if severity == config.SeverityLow {
return true
}
color := app.Config.K9s.Thresholds.SeverityColor(check, n)
if color != "" {
re.Row.Fields[colIndex] = "[" + color + "::b]" + re.Row.Fields[colIndex]
}
return true
})
}
}
func matchTag(i int, s string) string {
return `<<<"search_` + strconv.Itoa(i) + `">>>` + s + `<<<"">>>`
}
func linesWithRegions(lines []string, matches fuzzy.Matches) []string {
ll := make([]string, len(lines))
copy(ll, lines)
offsetForLine := make(map[int]int)
for i, m := range matches {
for _, loc := range dao.ContinuousRanges(m.MatchedIndexes) {
start, end := loc[0]+offsetForLine[m.Index], loc[1]+offsetForLine[m.Index]
line := ll[m.Index]
if end > len(line) {
end = len(line)
}
regionStr := matchTag(i, line[start:end])
ll[m.Index] = line[:start] + regionStr + line[end:]
offsetForLine[m.Index] += len(regionStr) - (end - start)
}
}
return ll
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/rs.go | internal/view/rs.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
)
// ReplicaSet presents a replicaset viewer.
type ReplicaSet struct {
ResourceViewer
}
// NewReplicaSet returns a new viewer.
func NewReplicaSet(gvr *client.GVR) ResourceViewer {
r := ReplicaSet{
ResourceViewer: NewOwnerExtender(
NewVulnerabilityExtender(
NewBrowser(gvr),
),
),
}
r.AddBindKeysFn(r.bindKeys)
r.GetTable().SetEnterFn(r.showPods)
return &r
}
func (r *ReplicaSet) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyShiftD: ui.NewKeyAction("Sort Desired", r.GetTable().SortColCmd("DESIRED", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort Current", r.GetTable().SortColCmd("CURRENT", true), false),
ui.KeyShiftR: ui.NewKeyAction("Sort Ready", r.GetTable().SortColCmd(readyCol, true), false),
tcell.KeyCtrlL: ui.NewKeyAction("Rollback", r.rollbackCmd, true),
})
}
func (*ReplicaSet) showPods(app *App, _ ui.Tabular, _ *client.GVR, path string) {
var drs dao.ReplicaSet
rs, err := drs.Load(app.factory, path)
if err != nil {
app.Flash().Err(err)
return
}
showPodsFromSelector(app, path, rs.Spec.Selector)
}
func (r *ReplicaSet) rollbackCmd(evt *tcell.EventKey) *tcell.EventKey {
path := r.GetTable().GetSelectedItem()
if path == "" {
return evt
}
msg := fmt.Sprintf("Rollback %s %s?", r.GVR(), path)
d := r.App().Styles.Dialog()
dialog.ShowConfirm(&d, r.App().Content.Pages, "Rollback", msg, func() {
r.App().Flash().Infof("Rolling back %s %s", r.GVR(), path)
var drs dao.ReplicaSet
drs.Init(r.App().factory, r.GVR())
if err := drs.Rollback(path); err != nil {
r.App().Flash().Err(err)
} else {
r.App().Flash().Infof("%s successfully rolled back", path)
}
r.Refresh()
}, func() {})
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/dir.go | internal/view/dir.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"os"
"path"
"slices"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
)
const (
kustomize = "kustomization"
kustomizeNoExt = "Kustomization"
kustomizeYAML = kustomize + extYAML
kustomizeYML = kustomize + extYML
extYAML = ".yaml"
extYML = ".yml"
)
// Dir represents a command directory view.
type Dir struct {
ResourceViewer
path string
}
// NewDir returns a new instance.
func NewDir(s string) ResourceViewer {
d := Dir{
ResourceViewer: NewBrowser(client.DirGVR),
path: s,
}
d.GetTable().SetBorderFocusColor(tcell.ColorAliceBlue)
d.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorAliceBlue).Attributes(tcell.AttrNone))
d.AddBindKeysFn(d.bindKeys)
d.SetContextFn(d.dirContext)
return &d
}
// Init initializes the view.
func (d *Dir) Init(ctx context.Context) error {
if err := d.ResourceViewer.Init(ctx); err != nil {
return err
}
return nil
}
func (d *Dir) dirContext(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeyPath, d.path)
}
func (d *Dir) bindDangerousKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyA: ui.NewKeyActionWithOpts("Apply", d.applyCmd, ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyD: ui.NewKeyActionWithOpts("Delete", d.delCmd, ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyE: ui.NewKeyActionWithOpts("Edit", d.editCmd, ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
})
}
func (d *Dir) bindKeys(aa *ui.KeyActions) {
// !!BOZO!! Lame!
aa.Delete(ui.KeyShiftA, tcell.KeyCtrlS, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Delete(tcell.KeyCtrlW, tcell.KeyCtrlL, tcell.KeyCtrlD, tcell.KeyCtrlZ)
if !d.App().Config.IsReadOnly() {
d.bindDangerousKeys(aa)
}
aa.Bulk(ui.KeyMap{
ui.KeyY: ui.NewKeyAction(yamlAction, d.viewCmd, true),
tcell.KeyEnter: ui.NewKeyAction("Goto", d.gotoCmd, true),
})
}
func (d *Dir) viewCmd(evt *tcell.EventKey) *tcell.EventKey {
sel := d.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
if path.Ext(sel) == "" {
return nil
}
yaml, err := os.ReadFile(sel)
if err != nil {
d.App().Flash().Err(err)
return nil
}
details := NewDetails(d.App(), yamlAction, sel, contentYAML, true).Update(string(yaml))
if err := d.App().inject(details, false); err != nil {
d.App().Flash().Err(err)
}
return nil
}
func isManifest(s string) bool {
ext := path.Ext(s)
return ext == ".yml" || ext == ".yaml"
}
func (d *Dir) editCmd(evt *tcell.EventKey) *tcell.EventKey {
sel := d.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
if !isManifest(sel) {
d.App().Flash().Errf("you must select a manifest")
return nil
}
d.Stop()
defer d.Start()
if !edit(d.App(), &shellOpts{clear: true, args: []string{sel}}) {
d.App().Flash().Errf("Failed to launch editor")
}
return nil
}
func (d *Dir) gotoCmd(evt *tcell.EventKey) *tcell.EventKey {
if d.GetTable().CmdBuff().IsActive() {
return d.GetTable().activateCmd(evt)
}
sel := d.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
if isManifest(sel) {
d.App().Flash().Errf("you must select a directory")
return nil
}
v := NewDir(sel)
if err := d.App().inject(v, false); err != nil {
d.App().Flash().Err(err)
}
return evt
}
func isKustomized(sel string) bool {
if isManifest(sel) {
return false
}
ff, err := os.ReadDir(sel)
if err != nil {
return false
}
kk := []string{kustomizeNoExt, kustomizeYAML, kustomizeYML}
for _, f := range ff {
if slices.Contains(kk, f.Name()) {
return true
}
}
return false
}
func containsDir(sel string) bool {
if isManifest(sel) {
return false
}
ff, err := os.ReadDir(sel)
if err != nil {
return false
}
for _, f := range ff {
if f.IsDir() {
return true
}
}
return false
}
func (d *Dir) applyCmd(evt *tcell.EventKey) *tcell.EventKey {
sel := d.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
opts := []string{"-f"}
if containsDir(sel) {
opts = append(opts, "-R")
}
if isKustomized(sel) {
opts = []string{"-k"}
}
d.Stop()
defer d.Start()
{
args := make([]string, 0, 10)
args = append(args, "apply")
args = append(args, opts...)
args = append(args, sel)
res, err := runKu(context.Background(), d.App(), &shellOpts{clear: false, args: args})
if err != nil {
res = "status:\n " + err.Error() + "\nmessage:\n" + fmtResults(res)
} else {
res = "message:\n" + fmtResults(res)
}
details := NewDetails(d.App(), "Applied Manifest", sel, contentYAML, true).Update(res)
if err := d.App().inject(details, false); err != nil {
d.App().Flash().Err(err)
}
}
return nil
}
func (d *Dir) delCmd(evt *tcell.EventKey) *tcell.EventKey {
sel := d.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
opts := []string{"-f"}
msgResource := "manifest"
if containsDir(sel) {
opts = append(opts, "-R")
}
if isKustomized(sel) {
opts = []string{"-k"}
msgResource = "kustomization"
}
d.Stop()
defer d.Start()
msg := fmt.Sprintf("Delete resource(s) in %s %s", msgResource, sel)
dlg := d.App().Styles.Dialog()
dialog.ShowConfirm(&dlg, d.App().Content.Pages, "Confirm Delete", msg, func() {
args := make([]string, 0, 10)
args = append(args, "delete")
args = append(args, opts...)
args = append(args, sel)
res, err := runKu(context.Background(), d.App(), &shellOpts{clear: false, args: args})
if err != nil {
res = "status:\n " + err.Error() + "\nmessage:\n" + fmtResults(res)
} else {
res = "message:\n" + fmtResults(res)
}
details := NewDetails(d.App(), "Deleted Manifest", sel, contentYAML, true).Update(res)
if err := d.App().inject(details, false); err != nil {
d.App().Flash().Err(err)
}
}, func() {})
return nil
}
func fmtResults(res string) string {
res = strings.TrimSpace(res)
lines := strings.Split(res, "\n")
ll := make([]string, 0, len(lines))
for _, l := range lines {
ll = append(ll, " "+l)
}
return strings.Join(ll, "\n")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/owner_extender.go | internal/view/owner_extender.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"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/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
"github.com/go-errors/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
// OwnerExtender adds owner actions to a given viewer.
type OwnerExtender struct {
ResourceViewer
}
// NewOwnerExtender returns a new extender.
func NewOwnerExtender(r ResourceViewer) ResourceViewer {
v := &OwnerExtender{ResourceViewer: r}
v.AddBindKeysFn(v.bindKeys)
return v
}
func (v *OwnerExtender) bindKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyShiftJ, ui.NewKeyAction("Jump Owner", v.ownerCmd, true))
}
func (v *OwnerExtender) ownerCmd(evt *tcell.EventKey) *tcell.EventKey {
path := v.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if err := v.findOwnerFor(path); err != nil {
slog.Warn("Unable to jump to owner of resource",
slogs.FQN, path,
slogs.Error, err,
)
v.App().Flash().Warnf("Unable to jump owner: %s", err)
}
return nil
}
func (v *OwnerExtender) findOwnerFor(path string) error {
res, err := dao.AccessorFor(v.App().factory, v.GVR())
if err != nil {
return err
}
o, err := res.Get(v.defaultCtx(), path)
if err != nil {
return err
}
u, ok := v.asUnstructuredObject(o)
if !ok {
return errors.Errorf("unsupported object type: %t", o)
}
ns, _ := client.Namespaced(path)
ownerReferences := u.GetOwnerReferences()
if len(ownerReferences) == 1 {
return v.jumpOwner(ns, &ownerReferences[0])
} else if len(ownerReferences) > 1 {
owners := make([]string, 0, len(ownerReferences))
for idx, ownerRef := range ownerReferences {
owners = append(owners, fmt.Sprintf("%d: %s", idx, ownerRef.Kind))
}
d := v.App().Styles.Dialog()
dialog.ShowSelection(&d, v.App().Content.Pages, "Jump To", owners, func(index int) {
if index >= 0 {
err = v.jumpOwner(ns, &ownerReferences[index])
}
})
return err
}
return errors.Errorf("no owner found")
}
func (v *OwnerExtender) jumpOwner(ns string, owner *metav1.OwnerReference) error {
gv, err := schema.ParseGroupVersion(owner.APIVersion)
if err != nil {
return err
}
gvr, namespaced, found := dao.MetaAccess.GVK2GVR(gv, owner.Kind)
if !found {
return errors.Errorf("unsupported GVK: %s/%s", owner.APIVersion, owner.Kind)
}
var ownerFQN string
if namespaced {
ownerFQN = client.FQN(ns, owner.Name)
} else {
ownerFQN = owner.Name
}
v.App().gotoResource(gvr.String(), ownerFQN, false, true)
return nil
}
func (v *OwnerExtender) defaultCtx() context.Context {
return context.WithValue(context.Background(), internal.KeyFactory, v.App().factory)
}
func (*OwnerExtender) asUnstructuredObject(o runtime.Object) (*unstructured.Unstructured, bool) {
switch v := o.(type) {
case *unstructured.Unstructured:
return v, true
case *render.PodWithMetrics:
return v.Raw, true
default:
return nil, false
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/reference.go | internal/view/reference.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// Reference represents resource references.
type Reference struct {
ResourceViewer
}
// NewReference returns a new alias view.
func NewReference(gvr *client.GVR) ResourceViewer {
r := Reference{
ResourceViewer: NewBrowser(gvr),
}
r.GetTable().SetBorderFocusColor(tcell.ColorMediumSpringGreen)
r.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorMediumSpringGreen).Attributes(tcell.AttrNone))
r.AddBindKeysFn(r.bindKeys)
return &r
}
// Init initializes the view.
func (r *Reference) Init(ctx context.Context) error {
if err := r.ResourceViewer.Init(ctx); err != nil {
return err
}
r.GetTable().GetModel().SetNamespace(client.BlankNamespace)
return nil
}
func (r *Reference) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, tcell.KeyCtrlS, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Delete(tcell.KeyCtrlW, tcell.KeyCtrlL, tcell.KeyCtrlZ)
aa.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("Goto", r.gotoCmd, true),
ui.KeyShiftV: ui.NewKeyAction("Sort GVR", r.GetTable().SortColCmd("GVR", true), false),
})
}
func (r *Reference) gotoCmd(evt *tcell.EventKey) *tcell.EventKey {
row, _ := r.GetTable().GetSelection()
if row == 0 {
return evt
}
path := r.GetTable().GetSelectedItem()
ns, _ := client.Namespaced(path)
gvr := ui.TrimCell(r.GetTable().SelectTable, row, 2)
r.App().gotoResource(client.NewGVR(gvr).String()+" "+ns, path, false, true)
return evt
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/sts_test.go | internal/view/sts_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestStatefulSetNew(t *testing.T) {
s := view.NewStatefulSet(client.StsGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "StatefulSets", s.Name())
assert.Len(t, s.Hints(), 14)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cm_test.go | internal/view/cm_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestConfigMapNew(t *testing.T) {
s := view.NewConfigMap(client.CmGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "ConfigMaps", s.Name())
assert.Len(t, s.Hints(), 8)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cm.go | internal/view/cm.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// ConfigMap represents a configmap viewer.
type ConfigMap struct {
ResourceViewer
}
// NewConfigMap returns a new viewer.
func NewConfigMap(gvr *client.GVR) ResourceViewer {
s := ConfigMap{
ResourceViewer: NewOwnerExtender(
NewBrowser(gvr),
),
}
s.AddBindKeysFn(s.bindKeys)
return &s
}
func (s *ConfigMap) bindKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyU, ui.NewKeyAction("UsedBy", s.refCmd, true))
}
func (s *ConfigMap) refCmd(evt *tcell.EventKey) *tcell.EventKey {
return scanRefs(evt, s.App(), s.GetTable(), client.CmGVR)
}
func scanRefs(evt *tcell.EventKey, a *App, t *Table, gvr *client.GVR) *tcell.EventKey {
path := t.GetSelectedItem()
if path == "" {
return evt
}
ctx := context.Background()
refs, err := dao.ScanForRefs(refContext(gvr, path, true)(ctx), a.factory)
if err != nil {
a.Flash().Err(err)
return nil
}
if len(refs) == 0 {
a.Flash().Warnf("No references found at this time for %s::%s. Check again later!", gvr, path)
return nil
}
a.Flash().Infof("Viewing references for %s::%s", gvr, path)
view := NewReference(client.RefGVR)
view.SetContextFn(refContext(gvr, path, false))
if err := a.inject(view, false); err != nil {
a.Flash().Err(err)
}
return nil
}
func refContext(gvr *client.GVR, path string, wait bool) ContextFunc {
return func(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, path)
ctx = context.WithValue(ctx, internal.KeyGVR, gvr)
return context.WithValue(ctx, internal.KeyWait, wait)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/types.go | internal/view/cmd/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"regexp"
"k8s.io/apimachinery/pkg/util/sets"
)
const (
cowCmd = "cow"
canCmd = "can"
nsFlag = "-n"
filterFlag = "/"
labelFlagEq = "="
labelFlagEqs = "=="
labelFlagNotEq = "!="
labelFlagIn = " in "
labelFlagNotin = " notin "
labelFlagQuote = "'"
label
fuzzyFlag = "-f"
contextFlag = "@"
)
var (
labelFlags = []string{
labelFlagEq,
labelFlagEqs,
labelFlagNotEq,
labelFlagIn,
labelFlagNotin,
}
rbacRX = regexp.MustCompile(`^can\s+([ugs]):\s*([\w-:]+)\s*$`)
contextCmd = sets.New(
"ctx",
"context",
"contexts",
)
namespaceCmd = sets.New(
"ns",
"namespace",
"namespaces",
)
dirCmd = sets.New(
"dir",
"dirs",
"d",
"ls",
)
bailCmd = sets.New(
"q",
"q!",
"qa",
"Q",
"quit",
"exit",
)
helpCmd = sets.New(
"?",
"h",
"help",
)
aliasCmd = sets.New(
"a",
"alias",
"aliases",
)
xrayCmd = sets.New(
"x",
"xr",
"xray",
)
)
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/interpreter_test.go | internal/view/cmd/interpreter_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd_test
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/stretchr/testify/assert"
)
func TestRbacCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
args []string
}{
"empty": {},
"user": {
cmd: "can u:fernand",
ok: true,
args: []string{"u", "fernand"},
},
"user_spacing": {
cmd: "can u: fernand ",
ok: true,
args: []string{"u", "fernand"},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsRBACCmd())
c, s, ok := p.RBACArgs()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.args[0], c)
assert.Equal(t, u.args[1], s)
}
})
}
}
func TestNsCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
ns string
}{
"empty": {},
"happy": {
cmd: "pod fred",
ok: true,
ns: "fred",
},
"ns-arg-spaced": {
cmd: "pod fred ",
ok: true,
ns: "fred",
},
"caps-no-ns": {
cmd: "Deploy",
},
"caps-with-ns": {
cmd: "DEPLOY Fred",
ok: true,
ns: "fred",
},
"no-ns": {
cmd: "pod",
},
"full-ns": {
cmd: "pod app=blee fred @zorg",
ok: true,
ns: "fred",
},
"full-repeat-ns": {
cmd: "pod app=blee blee @zorg",
ok: true,
ns: "blee",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
ns, ok := p.NSArg()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.ns, ns)
}
})
}
}
func TestSwitchNS(t *testing.T) {
uu := map[string]struct {
cmd string
ns string
e string
}{
"empty": {},
"blank": {
cmd: "pod fred",
e: "pod",
},
"no-op": {
cmd: "pod fred",
ns: "fred",
e: "pod fred",
},
"no-ns": {
cmd: "pod",
ns: "blee",
e: "pod blee",
},
"full-ns": {
cmd: "pod app=blee fred @zorg",
ns: "blee",
e: "pod app=blee blee @zorg",
},
"full--repeat-ns": {
cmd: "pod app=zorg zorg @zorg",
ns: "blee",
e: "pod app=zorg blee @zorg",
},
"full-no-ns": {
cmd: "pod app=blee @zorg",
ns: "blee",
e: "pod app=blee @zorg blee",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
p.SwitchNS(u.ns)
assert.Equal(t, u.e, p.GetLine())
})
}
}
func TestClearNS(t *testing.T) {
uu := map[string]struct {
cmd string
e string
}{
"empty": {},
"has-ns": {
cmd: "pod fred",
e: "pod",
},
"no-ns": {
cmd: "pod",
e: "pod",
},
"full-repeat-ns": {
cmd: "pod app=blee @zorg zorg",
e: "pod app=blee @zorg",
},
"full-no-ns": {
cmd: "pod app=blee @zorg",
e: "pod app=blee @zorg",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
p.ClearNS()
assert.Equal(t, u.e, p.GetLine())
})
}
}
func TestFilterCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
filter string
}{
"empty": {},
"normal": {
cmd: "pod /fred",
ok: true,
filter: "fred",
},
"caps": {
cmd: "POD /FRED",
ok: true,
filter: "fred",
},
"filter+ns": {
cmd: "pod /fred ns1",
ok: true,
filter: "fred",
},
"ns+filter": {
cmd: "pod ns1 /fred",
ok: true,
filter: "fred",
},
"ns+filter+labels": {
cmd: "pod ns1 /fred app=blee,fred=zorg",
ok: true,
filter: "fred",
},
"filtered": {
cmd: "pod /cilium kube-system",
ok: true,
filter: "cilium",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
f, ok := p.FilterArg()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.filter, f)
}
})
}
}
func TestLabelCmd(t *testing.T) {
uu := map[string]struct {
cmd string
err error
labels string
}{
"empty": {},
"plain": {
cmd: "pod fred=blee",
labels: "fred=blee",
},
"multi": {
cmd: "pod fred=blee,zorg=duh",
labels: "fred=blee,zorg=duh",
},
"complex-lbls": {
cmd: "pod 'fred in (blee,zorg),blee notin (zorg)'",
labels: "blee notin (zorg),fred in (blee,zorg)",
},
"no-lbls": {
cmd: "pod ns-1",
},
"multi-ns": {
cmd: "pod fred=blee,zorg=duh ns1",
labels: "fred=blee,zorg=duh",
},
"l-arg-spaced": {
cmd: "pod fred=blee ",
labels: "fred=blee",
},
"l-arg-caps": {
cmd: "POD FRED=BLEE ",
labels: "fred=blee",
},
"toast-labels": {
cmd: "pod =blee",
err: errors.New("found '=', expected: !, identifier, or 'end of string'"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
ll, err := p.LabelsSelector()
assert.Equal(t, u.err, err)
if err == nil {
assert.Equal(t, u.labels, ll.String())
}
})
}
}
func TestXRayCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
res, ns string
}{
"empty": {},
"happy": {
cmd: "xray po",
ok: true,
res: "po",
},
"happy+ns": {
cmd: "xray po ns1",
ok: true,
res: "po",
ns: "ns1",
},
"toast": {
cmd: "xrayzor po",
},
"toast-1": {
cmd: "xray",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
res, ns, ok := p.XrayArgs()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.res, res)
assert.Equal(t, u.ns, ns)
}
})
}
}
func TestDirCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
dir string
}{
"empty": {},
"happy": {
cmd: "dir dir1",
ok: true,
dir: "dir1",
},
"extra-ns": {
cmd: "dir dir1 ns1",
ok: true,
dir: "dir1",
},
"toast": {
cmd: "dirdel dir1",
},
"toast-nodir": {
cmd: "dir",
},
"caps": {
cmd: "dir DirName",
ok: true,
dir: "DirName",
},
"abs": {
cmd: "dir /tmp",
ok: true,
dir: "/tmp",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
dir, ok := p.DirArg()
assert.Equal(t, u.ok, ok)
assert.Equal(t, u.dir, dir)
})
}
}
func TestRBACCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
cat, sub string
}{
"empty": {},
"toast": {
cmd: "canopy u:bozo",
},
"toast-1": {
cmd: "can u:",
},
"toast-2": {
cmd: "can bozo",
},
"user": {
cmd: "can u:bozo",
ok: true,
cat: "u",
sub: "bozo",
},
"group": {
cmd: "can g:bozo",
ok: true,
cat: "g",
sub: "bozo",
},
"sa": {
cmd: "can s:bozo",
ok: true,
cat: "s",
sub: "bozo",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
cat, sub, ok := p.RBACArgs()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.cat, cat)
assert.Equal(t, u.sub, sub)
}
})
}
}
func TestContextCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
ctx string
}{
"empty": {},
"happy-full": {
cmd: "context ctx1",
ok: true,
ctx: "ctx1",
},
"happy-alias": {
cmd: "ctx ctx1",
ok: true,
ctx: "ctx1",
},
"toast": {
cmd: "ctxto ctx1",
},
"caps": {
cmd: "ctx Dev",
ok: true,
ctx: "Dev",
},
"contains-key": {
cmd: "ctx kind-fred",
ok: true,
ctx: "kind-fred",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsContextCmd())
if u.ok {
ctx, ok := p.ContextArg()
assert.Equal(t, u.ok, ok)
assert.Equal(t, u.ctx, ctx)
}
})
}
}
func TestHelpCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
}{
"empty": {},
"plain": {
cmd: "help",
ok: true,
},
"toast": {
cmd: "helpme",
},
"toast1": {
cmd: "hozer",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsHelpCmd())
})
}
}
func TestBailCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
}{
"empty": {},
"plain": {
cmd: "quit",
ok: true,
},
"q": {
cmd: "q",
ok: true,
},
"q!": {
cmd: "q!",
ok: true,
},
"toast": {
cmd: "zorg",
},
"toast1": {
cmd: "quitter",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsBailCmd())
})
}
}
func TestAliasCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
}{
"empty": {},
"plain": {
cmd: "alias",
ok: true,
},
"a": {
cmd: "a",
ok: true,
},
"toast": {
cmd: "abba",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsAliasCmd())
})
}
}
func TestCowCmd(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
}{
"empty": {},
"plain": {
cmd: "cow",
ok: true,
},
"msg": {
cmd: "cow bumblebeetuna",
ok: true,
},
"toast": {
cmd: "cowdy",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
assert.Equal(t, u.ok, p.IsCowCmd())
})
}
}
func TestArgs(t *testing.T) {
uu := map[string]struct {
cmd string
ok bool
ctx string
}{
"empty": {},
"with-plain-context": {
cmd: "po @fred",
ok: true,
ctx: "fred",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
ctx, ok := p.ContextArg()
assert.Equal(t, u.ok, ok)
if u.ok {
assert.Equal(t, u.ctx, ctx)
}
})
}
}
func Test_grokLabels(t *testing.T) {
uu := map[string]struct {
cmd string
err error
lbls string
}{
"empty": {},
"no-labels": {
cmd: "po @fred",
},
"plain-label": {
cmd: "po a=b,b=c @fred",
lbls: "a=b,b=c",
},
"label-quotes": {
cmd: "po 'a=b,b=c' @fred",
lbls: "a=b,b=c",
},
"partial-quotes-label": {
cmd: "po 'a=b @fred",
lbls: "",
},
"complex": {
cmd: "po 'a in (b,c),b notin (c,z)' fred'",
lbls: "a in (b,c),b notin (c,z)",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
sel, err := p.LabelsSelector()
assert.Equal(t, u.err, err)
if err == nil {
assert.Equal(t, u.lbls, sel.String())
}
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/helpers_test.go | internal/view/cmd/helpers_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"log/slog"
"testing"
"github.com/stretchr/testify/assert"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func Test_toLabels(t *testing.T) {
uu := map[string]struct {
s string
ll map[string]string
}{
"empty": {},
"toast": {
s: "=",
},
"toast-1": {
s: "=,",
},
"toast-2": {
s: ",",
},
"toast-3": {
s: ",=",
},
"simple": {
s: "a=b",
ll: map[string]string{"a": "b"},
},
"multi": {
s: "a=b,c=d",
ll: map[string]string{"a": "b", "c": "d"},
},
"multi-toast1": {
s: "a=,c=d",
ll: map[string]string{"c": "d"},
},
"multi-toast2": {
s: "a=b,=d",
ll: map[string]string{"a": "b"},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.ll, ToLabels(u.s))
})
}
}
func TestSuggestSubCommand(t *testing.T) {
namespaceNames := map[string]struct{}{
"kube-system": {},
"kube-public": {},
"default": {},
"nginx-ingress": {},
}
contextNames := []string{"develop", "test", "pre", "prod"}
tests := []struct {
Command string
Suggestions []string
}{
{Command: "q", Suggestions: nil},
{Command: "xray dp", Suggestions: nil},
{Command: "help k", Suggestions: nil},
{Command: "ctx p", Suggestions: []string{"re", "rod"}},
{Command: "ctx p", Suggestions: []string{"re", "rod"}},
{Command: "ctx pr", Suggestions: []string{"e", "od"}},
{Command: "ctx", Suggestions: []string{" develop", " pre", " prod", " test"}},
{Command: "ctx ", Suggestions: []string{"develop", "pre", "prod", "test"}},
{Command: "context d", Suggestions: []string{"evelop"}},
{Command: "contexts t", Suggestions: []string{"est"}},
{Command: "po ", Suggestions: nil},
{Command: "po x", Suggestions: nil},
{Command: "po k", Suggestions: []string{"ube-public", "ube-system"}},
{Command: "po kube-", Suggestions: []string{"public", "system"}},
}
for _, tt := range tests {
got := SuggestSubCommand(tt.Command, namespaceNames, contextNames)
assert.Equal(t, tt.Suggestions, got)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/args_test.go | internal/view/cmd/args_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestFlagsNew(t *testing.T) {
uu := map[string]struct {
i *Interpreter
aa []string
ll args
}{
"empty": {
i: NewInterpreter("po"),
ll: make(args),
},
"ns": {
i: NewInterpreter("po"),
aa: []string{"ns1"},
ll: args{nsKey: "ns1"},
},
"ns+spaces": {
i: NewInterpreter("po"),
aa: []string{" ns1 "},
ll: args{nsKey: "ns1"},
},
"filter": {
i: NewInterpreter("po"),
aa: []string{"/fred"},
ll: args{filterKey: "fred"},
},
"inverse-filter": {
i: NewInterpreter("po"),
aa: []string{"/!fred"},
ll: args{filterKey: "!fred"},
},
"fuzzy-filter": {
i: NewInterpreter("po"),
aa: []string{"-f", "fred"},
ll: args{fuzzyKey: "fred"},
},
"fuzzy-filter-nospace": {
i: NewInterpreter("po"),
aa: []string{"-ffred"},
ll: args{fuzzyKey: "fred"},
},
"filter+ns": {
i: NewInterpreter("po"),
aa: []string{"/fred", " ns1 "},
ll: args{nsKey: "ns1", filterKey: "fred"},
},
"label": {
i: NewInterpreter("po"),
aa: []string{"app=fred"},
ll: args{labelKey: "app=fred"},
},
"label-toast": {
i: NewInterpreter("po"),
aa: []string{"="},
ll: args{labelKey: "="},
},
"multi-labels": {
i: NewInterpreter("po"),
aa: []string{"app=fred,blee=duh"},
ll: args{labelKey: "app=fred,blee=duh"},
},
"label+ns": {
i: NewInterpreter("po"),
aa: []string{"a=b,c=d", " ns1 "},
ll: args{labelKey: "a=b,c=d", nsKey: "ns1"},
},
"full-monty": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "ns1", "-f", "blee", "/zorg"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
},
},
"full-monty+ctx": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "ns1", "-f", "blee", "/zorg", "@ctx1"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
contextKey: "ctx1",
},
},
"full-monty+ctx-with-space": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "ns1", "-f", "blee", "/zorg", "@zorg fred"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
contextKey: "zorg fred",
},
},
"full-monty+ctx-first": {
i: NewInterpreter("po"),
aa: []string{"@ctx1", "app=fred", "ns1", "-f", "blee", "/zorg"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
contextKey: "ctx1",
},
},
"full-monty+ctx-with-space-middle": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "@ctx1", "ns1", "-f", "blee", "/zorg"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
contextKey: "ctx1",
},
},
"caps": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "ns1", "-f", "blee", "/zorg", "@Dev"},
ll: args{
filterKey: "zorg",
fuzzyKey: "blee",
labelKey: "app=fred",
nsKey: "ns1",
contextKey: "Dev",
},
},
"ctx": {
i: NewInterpreter("ctx"),
aa: []string{"Dev"},
ll: args{contextKey: "Dev"},
},
"toast": {
i: NewInterpreter("apply -f"),
ll: args{},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
l := newArgs(u.i, u.aa)
assert.Equal(t, u.ll, l)
})
}
}
func TestFlagsHasFilters(t *testing.T) {
uu := map[string]struct {
i *Interpreter
aa []string
ok bool
}{
"empty": {},
"ns": {
i: NewInterpreter("po"),
aa: []string{"ns1"},
},
"filter": {
i: NewInterpreter("po"),
aa: []string{"/fred"},
ok: true,
},
"inverse-filter": {
i: NewInterpreter("po"),
aa: []string{"/!fred"},
ok: true,
},
"fuzzy-filter": {
i: NewInterpreter("po"),
aa: []string{"-f", "fred"},
ok: true,
},
"filter+ns": {
i: NewInterpreter("po"),
aa: []string{"/fred", "ns1"},
ok: true,
},
"label": {
i: NewInterpreter("po"),
aa: []string{"app=fred"},
ok: true,
},
"multi-labels": {
i: NewInterpreter("po"),
aa: []string{"app=fred,blee=duh"},
ok: true,
},
"label+ns": {
i: NewInterpreter("po"),
aa: []string{"app=fred", "ns1"},
ok: true,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
l := newArgs(u.i, u.aa)
assert.Equal(t, u.ok, l.hasFilters())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/args.go | internal/view/cmd/args.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"maps"
"slices"
"strings"
)
const (
nsKey = "ns"
topicKey = "topic"
filterKey = "filter"
fuzzyKey = "fuzzy"
labelKey = "labels"
contextKey = "context"
)
type args map[string]string
func newArgs(p *Interpreter, aa []string) args {
arguments := make(args, len(aa))
if len(aa) == 0 {
return arguments
}
for i := 0; i < len(aa); i++ {
a := strings.TrimSpace(aa[i])
switch {
case strings.Index(a, fuzzyFlag) == 0:
if a == fuzzyFlag {
i++
if i < len(aa) {
arguments[fuzzyKey] = strings.ToLower(strings.TrimSpace(aa[i]))
}
} else {
arguments[fuzzyKey] = strings.ToLower(a[2:])
}
case strings.Index(a, filterFlag) == 0:
if p.IsDirCmd() {
if _, ok := arguments[topicKey]; !ok {
arguments[topicKey] = a
}
} else {
arguments[filterKey] = strings.ToLower(a[1:])
}
case strings.Index(a, contextFlag) == 0:
arguments[contextKey] = a[1:]
case isLabelArg(a):
arguments[labelKey] = strings.ToLower(a)
default:
switch {
case p.IsContextCmd():
arguments[contextKey] = a
case p.IsDirCmd():
if _, ok := arguments[topicKey]; !ok {
arguments[topicKey] = a
}
case p.IsXrayCmd():
if _, ok := arguments[topicKey]; ok {
arguments[nsKey] = strings.ToLower(a)
} else {
arguments[topicKey] = strings.ToLower(a)
}
default:
arguments[nsKey] = strings.ToLower(a)
}
}
}
return arguments
}
func (a args) String() string {
ss := make([]string, 0, len(a))
kk := maps.Keys(a)
for _, k := range slices.Sorted(kk) {
v := a[k]
switch k {
case labelKey:
v = "'" + v + "'"
case filterKey:
v = filterFlag + v
case contextKey:
v = contextFlag + v
}
ss = append(ss, v)
}
return strings.Join(ss, " ")
}
func (a args) hasFilters() bool {
_, fok := a[filterKey]
_, zok := a[fuzzyKey]
_, lok := a[labelKey]
return fok || zok || lok
}
func isLabelArg(arg string) bool {
for _, flag := range labelFlags {
if strings.Contains(arg, flag) {
return true
}
}
return false
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/interpreter.go | internal/view/cmd/interpreter.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"log/slog"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/slogs"
"k8s.io/apimachinery/pkg/labels"
)
// Interpreter tracks user prompt input.
type Interpreter struct {
line string
cmd string
aliases []string
args args
}
// NewInterpreter returns a new instance.
func NewInterpreter(s string, aliases ...string) *Interpreter {
c := Interpreter{
line: s,
args: make(args),
aliases: aliases,
}
c.grok()
return &c
}
// ClearNS clears the current namespace if any.
func (c *Interpreter) ClearNS() {
c.SwitchNS(client.BlankNamespace)
}
// SwitchNS replaces the current namespace with the provided one.
func (c *Interpreter) SwitchNS(ns string) {
if ons, ok := c.NSArg(); ok && ons != client.BlankNamespace {
c.Reset(strings.TrimSpace(strings.Replace(c.line, " "+ons, " "+ns, 1)), "")
return
}
if ns != client.BlankNamespace {
c.Reset(strings.TrimSpace(c.line)+" "+ns, "")
}
}
func (c *Interpreter) Merge(p *Interpreter) {
if p == nil {
return
}
c.cmd = p.cmd
for k, v := range p.args {
c.args[k] = v
}
c.line = c.cmd + " " + c.args.String()
}
func (c *Interpreter) grok() {
ff := strings.Fields(c.line)
if len(ff) == 0 {
return
}
c.cmd = strings.ToLower(ff[0])
var lbls string
line := strings.TrimSpace(strings.Replace(c.line, ff[0], "", 1))
if strings.Contains(line, "'") {
start, end, ok := quoteIndicies(line)
if ok {
lbls = line[start+1 : end]
line = strings.TrimSpace(strings.Replace(line, "'"+lbls+"'", "", 1))
} else {
slog.Error("Unmatched single quote in command line", slogs.Line, c.line)
line = ""
}
}
ff = strings.Fields(line)
if lbls != "" {
ff = append(ff, lbls)
}
c.args = newArgs(c, ff)
}
func quoteIndicies(s string) (start, end int, ok bool) {
start, end = -1, -1
for i, r := range s {
if r == '\'' {
if start == -1 {
start = i
} else if end == -1 {
end = i
break
}
}
}
ok = start != -1 && end != -1
return
}
// HasNS returns true if ns is present in prompt.
func (c *Interpreter) HasNS() bool {
ns, ok := c.args[nsKey]
return ok && ns != ""
}
// Cmd returns the command.
func (c *Interpreter) Cmd() string {
return c.cmd
}
func (c *Interpreter) Aliases() []string {
return c.aliases
}
func (c *Interpreter) Args() string {
return strings.TrimSpace(strings.Replace(c.line, c.cmd, "", 1))
}
// IsBlank returns true if prompt is empty.
func (c *Interpreter) IsBlank() bool {
return c.line == ""
}
// Amend merges prompts.
func (c *Interpreter) Amend(c1 *Interpreter) {
c.cmd = c1.cmd
if c.args == nil {
c.args = make(args, len(c1.args))
}
for k, v := range c1.args {
if v != "" {
c.args[k] = v
}
}
}
// Reset resets with new command.
func (c *Interpreter) Reset(line, alias string) *Interpreter {
c.line = line
c.grok()
if alias != "" && alias != c.cmd {
c.addAlias(alias)
}
return c
}
func (c *Interpreter) addAlias(a string) {
for _, v := range c.aliases {
if v == a {
return
}
}
c.aliases = append(c.aliases, a)
}
// GetLine returns the prompt.
func (c *Interpreter) GetLine() string {
return strings.TrimSpace(c.line)
}
// IsCowCmd returns true if cow cmd is detected.
func (c *Interpreter) IsCowCmd() bool {
return c.cmd == cowCmd
}
// IsHelpCmd returns true if help cmd is detected.
func (c *Interpreter) IsHelpCmd() bool {
return helpCmd.Has(c.cmd)
}
// IsBailCmd returns true if quit cmd is detected.
func (c *Interpreter) IsBailCmd() bool {
return bailCmd.Has(c.cmd)
}
// IsAliasCmd returns true if alias cmd is detected.
func (c *Interpreter) IsAliasCmd() bool {
return aliasCmd.Has(c.cmd)
}
// IsXrayCmd returns true if xray cmd is detected.
func (c *Interpreter) IsXrayCmd() bool {
return xrayCmd.Has(c.cmd)
}
// IsContextCmd returns true if context cmd is detected.
func (c *Interpreter) IsContextCmd() bool {
return contextCmd.Has(c.cmd)
}
// IsNamespaceCmd returns true if ns cmd is detected.
func (c *Interpreter) IsNamespaceCmd() bool {
return namespaceCmd.Has(c.cmd)
}
// IsDirCmd returns true if dir cmd is detected.
func (c *Interpreter) IsDirCmd() bool {
return dirCmd.Has(c.cmd)
}
// IsRBACCmd returns true if rbac cmd is detected.
func (c *Interpreter) IsRBACCmd() bool {
return c.cmd == canCmd
}
// ContextArg returns context cmd arg.
func (c *Interpreter) ContextArg() (string, bool) {
if c.IsContextCmd() || strings.Contains(c.line, contextFlag) {
return c.args[contextKey], true
}
return "", false
}
// ResetContextArg deletes context arg.
func (c *Interpreter) ResetContextArg() {
delete(c.args, contextFlag)
}
// DirArg returns the directory is present.
func (c *Interpreter) DirArg() (string, bool) {
if !c.IsDirCmd() {
return "", false
}
d, ok := c.args[topicKey]
return d, ok && d != ""
}
// CowArg returns the cow message.
func (c *Interpreter) CowArg() (string, bool) {
if !c.IsCowCmd() {
return "", false
}
m, ok := c.args[nsKey]
return m, ok && m != ""
}
// RBACArgs returns the subject and topic is any.
func (c *Interpreter) RBACArgs() (subject, verb string, ok bool) {
if !c.IsRBACCmd() {
return
}
tt := rbacRX.FindStringSubmatch(c.line)
if len(tt) < 3 {
return
}
subject, verb, ok = tt[1], tt[2], true
return
}
// XrayArgs return the gvr and ns if any.
func (c *Interpreter) XrayArgs() (cmd, namespace string, ok bool) {
if !c.IsXrayCmd() {
return
}
gvr, ok1 := c.args[topicKey]
if !ok1 {
return
}
ns, ok2 := c.args[nsKey]
switch {
case ok1 && ok2:
cmd, namespace, ok = gvr, ns, true
case ok1 && !ok2:
cmd, namespace, ok = gvr, "", true
default:
return
}
return
}
// FilterArg returns the current filter if any.
func (c *Interpreter) FilterArg() (string, bool) {
f, ok := c.args[filterKey]
return f, ok && f != ""
}
// FuzzyArg returns the fuzzy filter if any.
func (c *Interpreter) FuzzyArg() (string, bool) {
f, ok := c.args[fuzzyKey]
return f, ok && f != ""
}
// NSArg returns the current ns if any.
func (c *Interpreter) NSArg() (string, bool) {
ns, ok := c.args[nsKey]
return ns, ok && ns != client.BlankNamespace
}
// HasContext returns the current context if any.
func (c *Interpreter) HasContext() (string, bool) {
ctx, ok := c.args[contextKey]
return ctx, ok && ctx != ""
}
// LabelsSelector returns the label selector if any.
func (c *Interpreter) LabelsSelector() (labels.Selector, error) {
return labels.Parse(c.args[labelKey])
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/cmd/helpers.go | internal/view/cmd/helpers.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package cmd
import (
"slices"
"strings"
"github.com/derailed/k9s/internal/client"
)
// ToLabels converts a string into a map of labels.
func ToLabels(s string) map[string]string {
var (
ll = strings.Split(s, ",")
lbls = make(map[string]string, len(ll))
)
for _, l := range ll {
if k, v, ok := splitKv(l); ok {
lbls[k] = v
} else {
continue
}
}
if len(lbls) == 0 {
return nil
}
return lbls
}
func splitKv(s string) (k, v string, ok bool) {
switch {
case strings.Contains(s, labelFlagNotEq):
kv := strings.SplitN(s, labelFlagNotEq, 2)
if len(kv) == 2 && kv[0] != "" && kv[1] != "" {
return strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1]), true
}
case strings.Contains(s, labelFlagEqs):
kv := strings.SplitN(s, labelFlagEqs, 2)
if len(kv) == 2 && kv[0] != "" && kv[1] != "" {
return strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1]), true
}
case strings.Contains(s, labelFlagEq):
kv := strings.SplitN(s, labelFlagEq, 2)
if len(kv) == 2 && kv[0] != "" && kv[1] != "" {
return strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1]), true
}
}
return "", "", false
}
// ShouldAddSuggest checks if a suggestion match the given command.
func ShouldAddSuggest(command, suggest string) (string, bool) {
if command != suggest && strings.HasPrefix(suggest, command) {
return strings.TrimPrefix(suggest, command), true
}
return "", false
}
// SuggestSubCommand suggests namespaces or contexts based on current command.
func SuggestSubCommand(command string, namespaces client.NamespaceNames, contexts []string) []string {
p := NewInterpreter(command)
var suggests []string
switch {
case p.IsCowCmd(), p.IsHelpCmd(), p.IsAliasCmd(), p.IsBailCmd(), p.IsDirCmd():
return nil
case p.IsXrayCmd():
_, ns, ok := p.XrayArgs()
if !ok || ns == "" {
return nil
}
suggests = completeNS(ns, namespaces)
case p.IsContextCmd():
n, ok := p.ContextArg()
if !ok {
return nil
}
suggests = completeCtx(command, n, contexts)
case p.HasNS():
if n, ok := p.HasContext(); ok {
suggests = completeCtx(command, n, contexts)
}
if len(suggests) > 0 {
break
}
ns, ok := p.NSArg()
if !ok {
return nil
}
suggests = completeNS(ns, namespaces)
default:
if n, ok := p.HasContext(); ok {
suggests = completeCtx(command, n, contexts)
}
}
slices.Sort(suggests)
return suggests
}
func completeNS(s string, nn client.NamespaceNames) []string {
s = strings.ToLower(s)
var suggests []string
if suggest, ok := ShouldAddSuggest(s, client.NamespaceAll); ok {
suggests = append(suggests, suggest)
}
for ns := range nn {
if suggest, ok := ShouldAddSuggest(s, ns); ok {
suggests = append(suggests, suggest)
}
}
return suggests
}
func completeCtx(command, s string, contexts []string) []string {
var suggests []string
for _, ctxName := range contexts {
if suggest, ok := ShouldAddSuggest(s, ctxName); ok {
if s == "" && !strings.HasSuffix(command, " ") {
suggests = append(suggests, " "+suggest)
continue
}
suggests = append(suggests, suggest)
}
}
return suggests
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/gauge_int_test.go | internal/tchart/gauge_int_test.go | package tchart
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestComputeDeltas(t *testing.T) {
uu := map[string]struct {
d1, d2 int
e delta
}{
"same": {
e: DeltaSame,
},
"more": {
d1: 10,
d2: 20,
e: DeltaMore,
},
"less": {
d1: 20,
d2: 10,
e: DeltaLess,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, computeDelta(u.d1, u.d2))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/series.go | internal/tchart/series.go | package tchart
import (
"fmt"
"log/slog"
"sort"
"time"
)
type MetricSeries map[time.Time]float64
type Times []time.Time
func (tt Times) Len() int {
return len(tt)
}
func (tt Times) Swap(i, j int) {
tt[i], tt[j] = tt[j], tt[i]
}
func (tt Times) Less(i, j int) bool {
return tt[i].Sub(tt[j]) <= 0
}
func (tt Times) Includes(ti time.Time) bool {
for _, t := range tt {
if t.Equal(ti) {
return true
}
}
return false
}
func (mm MetricSeries) Empty() bool {
return len(mm) == 0
}
func (mm MetricSeries) Merge(metrics MetricSeries) {
for k, v := range metrics {
mm[k] = v
}
}
func (mm MetricSeries) Dump() {
slog.Debug("METRICS")
for _, k := range mm.Keys() {
slog.Debug(fmt.Sprintf("%v: %f", k, mm[k]))
}
}
func (mm MetricSeries) Add(t time.Time, f float64) {
if _, ok := mm[t]; !ok {
mm[t] = f
}
}
func (mm MetricSeries) Keys() Times {
kk := make(Times, 0, len(mm))
for k := range mm {
kk = append(kk, k)
}
sort.Sort(kk)
return kk
}
func (mm MetricSeries) Truncate(size int) {
kk := mm.Keys()
kk = kk[0 : len(kk)-size]
for t := range mm {
if kk.Includes(t) {
continue
}
delete(mm, kk[0])
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/component.go | internal/tchart/component.go | package tchart
import (
"image"
"sync"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
// Component represents a graphic component.
type Component struct {
*tview.Box
bgColor, noColor tcell.Color
focusFgColor, focusBgColor string
seriesColors []tcell.Color
dimmed tcell.Style
id, legend string
blur func(tcell.Key)
mx sync.RWMutex
}
// NewComponent returns a new component.
func NewComponent(id string) *Component {
return &Component{
Box: tview.NewBox(),
id: id,
noColor: tcell.ColorDefault,
seriesColors: []tcell.Color{
tcell.ColorGreen,
tcell.ColorOrange,
tcell.ColorOrangeRed,
},
dimmed: tcell.StyleDefault.Background(tview.Styles.PrimitiveBackgroundColor).Foreground(tcell.ColorGray).Dim(true),
}
}
// SetFocusColorNames sets the focus color names.
func (c *Component) SetFocusColorNames(fg, bg string) {
c.focusFgColor, c.focusBgColor = fg, bg
}
// SetBackgroundColor sets the graph bg color.
func (c *Component) SetBackgroundColor(color tcell.Color) {
c.mx.Lock()
defer c.mx.Unlock()
c.Box.SetBackgroundColor(color)
c.bgColor = color
c.dimmed = c.dimmed.Background(color)
}
// ID returns the component ID.
func (c *Component) ID() string {
return c.id
}
// SetLegend sets the component legend.
func (c *Component) SetLegend(l string) {
c.mx.Lock()
defer c.mx.Unlock()
c.legend = l
}
// InputHandler returns the handler for this primitive.
func (c *Component) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
return c.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
switch key := event.Key(); key {
case tcell.KeyEnter:
case tcell.KeyBacktab, tcell.KeyTab:
if c.blur != nil {
c.blur(key)
}
setFocus(c)
}
})
}
// IsDial returns true if chart is a dial
func (*Component) IsDial() bool {
return false
}
// SetBlurFunc sets a callback fn when component gets out of focus.
func (c *Component) SetBlurFunc(handler func(key tcell.Key)) *Component {
c.blur = handler
return c
}
// SetSeriesColors sets the component series colors.
func (c *Component) SetSeriesColors(cc ...tcell.Color) {
c.mx.Lock()
defer c.mx.Unlock()
c.seriesColors = cc
}
// GetSeriesColorNames returns series colors by name.
func (c *Component) GetSeriesColorNames() []string {
c.mx.RLock()
defer c.mx.RUnlock()
if len(c.seriesColors) < 3 {
return []string{"green", "orange", "red"}
}
nn := make([]string, 0, len(c.seriesColors))
for _, color := range c.seriesColors {
for name, co := range tcell.ColorNames {
if co == color {
nn = append(nn, name)
}
}
}
return nn
}
func (c *Component) colorForSeries() []tcell.Color {
c.mx.RLock()
defer c.mx.RUnlock()
return c.seriesColors
}
func (c *Component) asRect() image.Rectangle {
x, y, width, height := c.GetInnerRect()
return image.Rectangle{
Min: image.Point{X: x, Y: y},
Max: image.Point{X: x + width, Y: y + height},
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/component_int_test.go | internal/tchart/component_int_test.go | package tchart
import (
"image"
"testing"
"github.com/derailed/tcell/v2"
"github.com/stretchr/testify/assert"
)
func TestComponentAsRect(t *testing.T) {
c := NewComponent("fred")
r := image.Rectangle{Min: image.Point{X: 0, Y: 0}, Max: image.Point{X: 15, Y: 10}}
assert.Equal(t, r, c.asRect())
}
func TestComponentColorForSeries(t *testing.T) {
c := NewComponent("fred")
cc := c.colorForSeries()
assert.Len(t, cc, 3)
assert.Equal(t, tcell.ColorGreen, cc[0])
assert.Equal(t, tcell.ColorOrange, cc[1])
assert.Equal(t, tcell.ColorOrangeRed, cc[2])
assert.Equal(t, []string{"green", "orange", "orangered"}, c.GetSeriesColorNames())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/gauge_test.go | internal/tchart/gauge_test.go | package tchart_test
// import (
// "testing"
// "github.com/imhotepio/tchart"
// "github.com/stretchr/testify/assert"
// )
// func TestMetricsMaxDigits(t *testing.T) {
// uu := map[string]struct {
// m tchart.State
// e int
// }{
// "empty": {
// e: 1,
// },
// "oks": {
// m: tchart.State{OK: 100, Fault: 10},
// e: 3,
// },
// "errs": {
// m: tchart.State{OK: 10, Fault: 1000},
// e: 4,
// },
// }
// for k := range uu {
// u := uu[k]
// t.Run(k, func(t *testing.T) {
// assert.Equal(t, u.e, u.m.MaxDigits())
// })
// }
// }
// func TestMetricsMax(t *testing.T) {
// uu := map[string]struct {
// m tchart.Metric
// e int64
// }{
// "empty": {
// e: 0,
// },
// "max_ok": {
// m: tchart.Metric{S1: 100, S2: 10},
// e: 100,
// },
// }
// for k := range uu {
// u := uu[k]
// t.Run(k, func(t *testing.T) {
// assert.Equal(t, u.e, u.m.Max())
// })
// }
// }
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/sparkline.go | internal/tchart/sparkline.go | package tchart
import (
"fmt"
"image"
"math"
"time"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
var sparks = []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'}
const axisColor = "#ff0066"
type block struct {
full int
partial rune
}
// SparkLine represents a sparkline component.
type SparkLine struct {
*Component
series MetricSeries
max float64
unit string
colorIndex int
}
// NewSparkLine returns a new graph.
func NewSparkLine(id, unit string) *SparkLine {
return &SparkLine{
Component: NewComponent(id),
series: make(MetricSeries),
unit: unit,
}
}
// GetSeriesColorNames returns series colors by name.
func (s *SparkLine) GetSeriesColorNames() []string {
s.mx.RLock()
defer s.mx.RUnlock()
nn := make([]string, 0, len(s.seriesColors))
for _, color := range s.seriesColors {
for name, co := range tcell.ColorNames {
if co == color {
nn = append(nn, name)
}
}
}
if len(nn) < 3 {
nn = append(nn, "green", "orange", "orangered")
}
return nn
}
func (s *SparkLine) SetColorIndex(n int) {
s.colorIndex = n
}
func (s *SparkLine) SetMax(m float64) {
if m > s.max {
s.max = m
}
}
func (s *SparkLine) GetMax() float64 {
return s.max
}
func (*SparkLine) Add(int, int) {}
// Add adds a metric.
func (s *SparkLine) AddMetric(t time.Time, f float64) {
s.mx.Lock()
defer s.mx.Unlock()
s.series.Add(t, f)
}
func (s *SparkLine) printYAxis(screen tcell.Screen, rect image.Rectangle) {
style := tcell.StyleDefault.Foreground(tcell.GetColor(axisColor)).Background(s.bgColor)
for y := range rect.Dy() - 3 {
screen.SetContent(rect.Min.X, rect.Min.Y+y, tview.BoxDrawingsLightVertical, nil, style)
}
screen.SetContent(rect.Min.X, rect.Min.Y+rect.Dy()-3, tview.BoxDrawingsLightUpAndRight, nil, style)
}
func (s *SparkLine) printXAxis(screen tcell.Screen, rect image.Rectangle) time.Time {
dx, t := rect.Dx()-1, time.Now()
vals := make([]string, 0, dx)
for i := dx; i > 0; i -= 10 {
label := fmt.Sprintf("%02d:%02d", t.Hour(), t.Minute())
vals = append(vals, label)
t = t.Add(-(10 * time.Minute))
}
y := rect.Max.Y - 2
for _, v := range vals {
if dx <= 2 {
break
}
tview.Print(screen, v, rect.Min.X+dx-5, y, 6, tview.AlignCenter, tcell.ColorOrange)
dx -= 10
}
style := tcell.StyleDefault.Foreground(tcell.GetColor(axisColor)).Background(s.bgColor)
for x := 1; x < rect.Dx()-1; x++ {
screen.SetContent(rect.Min.X+x, rect.Max.Y-3, tview.BoxDrawingsLightHorizontal, nil, style)
}
return t
}
// Draw draws the graph.
func (s *SparkLine) Draw(screen tcell.Screen) {
s.Component.Draw(screen)
s.mx.RLock()
defer s.mx.RUnlock()
rect := s.asRect()
s.printXAxis(screen, rect)
padX := 1
s.cutSet(rect.Dx() - padX)
var cX int
if len(s.series) < rect.Dx() {
cX = rect.Max.X - len(s.series) - 1
} else {
cX = rect.Min.X + padX
}
pad := 2
if s.legend != "" {
pad++
}
scale := float64(len(sparks)*(rect.Dy()-pad)) / float64(s.max)
colors := s.colorForSeries()
cY := rect.Max.Y - pad - 1
for _, t := range s.series.Keys() {
b := s.makeBlock(s.series[t], scale)
s.drawBlock(rect, screen, cX, cY, b, colors[s.colorIndex%len(colors)])
cX++
}
s.printYAxis(screen, rect)
if rect.Dx() > 0 && rect.Dy() > 0 && s.legend != "" {
legend := s.legend
if s.HasFocus() {
legend = fmt.Sprintf("[%s:%s:]", s.focusFgColor, s.focusBgColor) + s.legend + "[::]"
}
tview.Print(screen, legend, rect.Min.X, rect.Max.Y-1, rect.Dx(), tview.AlignCenter, tcell.ColorWhite)
}
}
func (s *SparkLine) drawBlock(r image.Rectangle, screen tcell.Screen, x, y int, b block, c tcell.Color) {
style := tcell.StyleDefault.Foreground(c).Background(s.bgColor)
zeroY, full := r.Min.Y, sparks[len(sparks)-1]
for range b.full {
screen.SetContent(x, y, full, nil, style)
y--
if y < zeroY {
break
}
}
if b.partial != 0 {
screen.SetContent(x, y, b.partial, nil, style)
}
}
func (s *SparkLine) cutSet(width int) {
if width <= 0 || s.series.Empty() {
return
}
if len(s.series) > width {
s.series.Truncate(width)
}
}
func (*SparkLine) makeBlock(v, scale float64) block {
sc := (v * scale)
scaled := math.Round(sc)
p, b := int(scaled)%len(sparks), block{full: int(scaled / float64(len(sparks)))}
if v < 0 {
return b
}
if p > 0 && p < len(sparks) {
b.partial = sparks[p]
}
return b
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/component_test.go | internal/tchart/component_test.go | package tchart_test
import (
"testing"
"github.com/derailed/k9s/internal/tchart"
"github.com/derailed/tcell/v2"
"github.com/stretchr/testify/assert"
)
func TestCoSeriesColorNames(t *testing.T) {
c := tchart.NewComponent("fred")
c.SetSeriesColors(tcell.ColorGreen, tcell.ColorBlue, tcell.ColorRed)
assert.Equal(t, []string{"green", "blue", "red"}, c.GetSeriesColorNames())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/dot_matrix_test.go | internal/tchart/dot_matrix_test.go | package tchart_test
import (
"strconv"
"testing"
"github.com/derailed/k9s/internal/tchart"
"github.com/stretchr/testify/assert"
)
func TestDial3x3(t *testing.T) {
d := tchart.NewDotMatrix()
for n := range 2 {
i := n
t.Run(strconv.Itoa(n), func(t *testing.T) {
assert.Equal(t, tchart.To3x3Char(i), d.Print(i))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/gauge.go | internal/tchart/gauge.go | package tchart
import (
"fmt"
"image"
"time"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
const (
// DeltaSame represents no difference.
DeltaSame delta = iota
// DeltaMore represents a higher value.
DeltaMore
// DeltaLess represents a lower value.
DeltaLess
)
type State struct {
OK, Fault int
}
type delta int
// Gauge represents a gauge component.
type Gauge struct {
*Component
state State
resolution int
deltaOK, deltaFault delta
}
// NewGauge returns a new gauge.
func NewGauge(id string) *Gauge {
return &Gauge{
Component: NewComponent(id),
}
}
// SetResolution overrides the default number of digits to display.
func (g *Gauge) SetResolution(n int) {
g.resolution = n
}
// IsDial returns true if chart is a dial
func (*Gauge) IsDial() bool {
return true
}
func (*Gauge) SetColorIndex(int) {}
func (*Gauge) SetMax(float64) {}
func (*Gauge) GetMax() float64 { return 0 }
// Add adds a metric.
func (*Gauge) AddMetric(time.Time, float64) {}
// Add adds a new metric.
func (g *Gauge) Add(ok, fault int) {
g.mx.Lock()
defer g.mx.Unlock()
g.deltaOK, g.deltaFault = computeDelta(g.state.OK, ok), computeDelta(g.state.Fault, fault)
g.state = State{OK: ok, Fault: fault}
}
type number struct {
ok bool
val int
str string
delta delta
}
// Draw draws the primitive.
func (g *Gauge) Draw(sc tcell.Screen) {
g.Component.Draw(sc)
g.mx.RLock()
defer g.mx.RUnlock()
rect := g.asRect()
mid := image.Point{X: rect.Min.X + rect.Dx()/2, Y: rect.Min.Y + rect.Dy()/2 - 1}
var (
fmat = "%d"
)
d1, d2 := fmt.Sprintf(fmat, g.state.OK), fmt.Sprintf(fmat, g.state.Fault)
style := tcell.StyleDefault.Background(g.bgColor)
total := len(d1)*3 + len(d2)*3 + 1
colors := g.colorForSeries()
o := image.Point{X: mid.X, Y: mid.Y - 1}
o.X -= total / 2
g.drawNum(sc, o, number{ok: true, val: g.state.OK, delta: g.deltaOK, str: d1}, style.Foreground(colors[0]).Dim(false))
o.X, o.Y = o.X+len(d1)*3, mid.Y
sc.SetContent(o.X, o.Y, '⠔', nil, style)
o.X, o.Y = o.X+1, mid.Y-1
g.drawNum(sc, o, number{ok: false, val: g.state.Fault, delta: g.deltaFault, str: d2}, style.Foreground(colors[1]).Dim(false))
if rect.Dx() > 0 && rect.Dy() > 0 && g.legend != "" {
legend := g.legend
if g.HasFocus() {
legend = fmt.Sprintf("[%s:%s:]", g.focusFgColor, g.focusBgColor) + g.legend + "[::]"
}
tview.Print(sc, legend, rect.Min.X, o.Y+3, rect.Dx(), tview.AlignCenter, tcell.ColorWhite)
}
}
func (g *Gauge) drawNum(sc tcell.Screen, o image.Point, n number, style tcell.Style) {
colors := g.colorForSeries()
if n.ok {
style = style.Foreground(colors[0])
printDelta(sc, n.delta, o, style)
}
dm, significant := NewDotMatrix(), n.val == 0
if significant {
style = g.dimmed
}
for i := range len(n.str) {
if n.str[i] == '0' && !significant {
g.drawDial(sc, dm.Print(int(n.str[i]-48)), o, g.dimmed)
} else {
significant = true
g.drawDial(sc, dm.Print(int(n.str[i]-48)), o, style)
}
o.X += 3
}
if !n.ok {
o.X++
printDelta(sc, n.delta, o, style)
}
}
func (*Gauge) drawDial(sc tcell.Screen, m Matrix, o image.Point, style tcell.Style) {
for r := range m {
var c int
for c < len(m[r]) {
dot := m[r][c]
if dot != dots[0] {
sc.SetContent(o.X+c, o.Y+r, dot, nil, style)
}
c++
}
}
}
// ----------------------------------------------------------------------------
// Helpers...
func computeDelta(d1, d2 int) delta {
if d2 == 0 {
return DeltaSame
}
d := d2 - d1
switch {
case d > 0:
return DeltaMore
case d < 0:
return DeltaLess
default:
return DeltaSame
}
}
func printDelta(sc tcell.Screen, d delta, o image.Point, s tcell.Style) {
s = s.Dim(false)
switch d {
case DeltaLess:
sc.SetContent(o.X-1, o.Y+1, '↓', nil, s)
case DeltaMore:
sc.SetContent(o.X-1, o.Y+1, '↑', nil, s)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/dot_matrix.go | internal/tchart/dot_matrix.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package tchart
import (
"github.com/derailed/tview"
)
var dots = []rune{' ', '⠂', '▤', '▥'}
const (
b = ' '
h = tview.BoxDrawingsHeavyHorizontal
v = tview.BoxDrawingsHeavyVertical
tl = tview.BoxDrawingsHeavyDownAndRight
tr = tview.BoxDrawingsHeavyDownAndLeft
bl = tview.BoxDrawingsHeavyUpAndRight
br = tview.BoxDrawingsHeavyUpAndLeft
teeL = tview.BoxDrawingsHeavyVerticalAndLeft
teeR = tview.BoxDrawingsHeavyVerticalAndRight
lh = '\u2578'
rh = '\u257a'
hv = '\u2579'
lv = '\u257b'
)
// Matrix represents a number dial.
type Matrix [][]rune
// Orientation tracks char orientations.
type Orientation int
// DotMatrix tracks a char matrix.
type DotMatrix struct {
row, col int
}
// NewDotMatrix returns a new matrix.
func NewDotMatrix() DotMatrix {
return DotMatrix{
row: 3,
col: 3,
}
}
// Print prints the matrix.
func (DotMatrix) Print(n int) Matrix {
return To3x3Char(n)
}
// To3x3Char returns 3x3 number matrix.
func To3x3Char(numb int) Matrix {
switch numb {
case 1:
return Matrix{
[]rune{b, lv, b},
[]rune{b, v, b},
[]rune{b, hv, b},
}
case 2:
return Matrix{
[]rune{rh, h, tr},
[]rune{tl, h, br},
[]rune{bl, h, lh},
}
case 3:
return Matrix{
[]rune{h, h, tr},
[]rune{rh, h, teeL},
[]rune{h, h, br},
}
case 4:
return Matrix{
[]rune{lv, b, lv},
[]rune{bl, h, teeL},
[]rune{b, b, hv},
}
case 5:
return Matrix{
[]rune{tl, h, lh},
[]rune{bl, h, tr},
[]rune{rh, h, br},
}
case 6:
return Matrix{
[]rune{tl, h, lh},
[]rune{teeR, h, tr},
[]rune{bl, h, br},
}
case 7:
return Matrix{
[]rune{h, h, tr},
[]rune{b, b, v},
[]rune{b, b, hv},
}
case 8:
return Matrix{
[]rune{tl, h, tr},
[]rune{teeR, h, teeL},
[]rune{bl, h, br},
}
case 9:
return Matrix{
[]rune{tl, h, tr},
[]rune{bl, h, teeL},
[]rune{rh, h, br},
}
default:
return Matrix{
[]rune{tl, h, tr},
[]rune{v, b, v},
[]rune{bl, h, br},
}
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/tchart/series_test.go | internal/tchart/series_test.go | package tchart_test
import (
"testing"
"time"
"github.com/derailed/k9s/internal/tchart"
"github.com/stretchr/testify/assert"
)
func TestSeriesAdd(t *testing.T) {
type tuple struct {
time.Time
float64
}
uu := map[string]struct {
tt []tuple
e int
}{
"one": {
tt: []tuple{
{time.Now(), 1000},
},
e: 6,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
ss := makeSeries()
for _, tu := range u.tt {
ss.Add(tu.Time, tu.float64)
}
assert.Len(t, ss, u.e)
})
}
}
func TestSeriesTruncate(t *testing.T) {
uu := map[string]struct {
n, e int
}{
"one": {
n: 1,
e: 4,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
ss := makeSeries()
ss.Truncate(u.n)
assert.Len(t, ss, u.e)
})
}
}
// Helpers...
func makeSeries() tchart.MetricSeries {
return tchart.MetricSeries{
time.Now(): -100,
time.Now(): 0,
time.Now(): 100,
time.Now(): 50,
time.Now(): 10,
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/policy.go | internal/render/policy.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"log/slog"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/tcell/v2"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
func rbacVerbHeader() model1.Header {
return model1.Header{
model1.HeaderColumn{Name: "GET "},
model1.HeaderColumn{Name: "LIST "},
model1.HeaderColumn{Name: "WATCH "},
model1.HeaderColumn{Name: "CREATE"},
model1.HeaderColumn{Name: "PATCH "},
model1.HeaderColumn{Name: "UPDATE"},
model1.HeaderColumn{Name: "DELETE"},
model1.HeaderColumn{Name: "DEL-LIST "},
model1.HeaderColumn{Name: "EXTRAS", Attrs: model1.Attrs{Wide: true}},
}
}
// Policy renders a rbac policy to screen.
type Policy struct {
Base
}
// ColorerFunc colors a resource row.
func (Policy) ColorerFunc() model1.ColorerFunc {
return func(string, model1.Header, *model1.RowEvent) tcell.Color {
return tcell.ColorMediumSpringGreen
}
}
// Header returns a header row.
func (Policy) Header(string) model1.Header {
h := model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "API-GROUP"},
model1.HeaderColumn{Name: "BINDING"},
}
h = append(h, rbacVerbHeader()...)
h = append(h, model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}})
return h
}
// Render renders a K8s resource to screen.
func (Policy) Render(o any, _ string, r *model1.Row) error {
p, ok := o.(*PolicyRes)
if !ok {
return fmt.Errorf("expecting PolicyRes but got %T", o)
}
r.ID = client.FQN(p.Namespace, p.Resource)
r.Fields = append(r.Fields,
p.Namespace,
cleanseResource(p.Resource),
p.Group,
p.Binding,
)
r.Fields = append(r.Fields, asVerbs(p.Verbs)...)
r.Fields = append(r.Fields, "")
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func cleanseResource(r string) string {
if r == "" || r[0] == '/' {
return r
}
tt := strings.Split(r, "/")
switch len(tt) {
case 2, 3:
return strings.TrimPrefix(r, tt[0]+"/")
default:
return r
}
}
// PolicyRes represents a rbac policy rule.
type PolicyRes struct {
Namespace, Binding string
Resource, Group string
ResourceName string
NonResourceURL string
Verbs []string
}
// NewPolicyRes returns a new policy.
func NewPolicyRes(ns, binding, res, grp string, vv []string) *PolicyRes {
return &PolicyRes{
Namespace: ns,
Binding: binding,
Resource: res,
Group: grp,
Verbs: vv,
}
}
// GR returns the group/resource path.
func (p *PolicyRes) GR() string {
return p.Group + "/" + p.Resource
}
// Merge merges two policies.
func (p *PolicyRes) Merge(p1 *PolicyRes) (*PolicyRes, error) {
if p.GR() != p1.GR() {
return nil, fmt.Errorf("policy mismatch %s vs %s", p.GR(), p1.GR())
}
for _, v := range p1.Verbs {
if !p.hasVerb(v) {
p.Verbs = append(p.Verbs, v)
}
}
return p, nil
}
func (p *PolicyRes) hasVerb(v1 string) bool {
for _, v := range p.Verbs {
if v == v1 {
return true
}
}
return false
}
// GetObjectKind returns a schema object.
func (*PolicyRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (p *PolicyRes) DeepCopyObject() runtime.Object {
return p
}
// Policies represents a collection of RBAC policies.
type Policies []*PolicyRes
// Upsert adds a new policy.
func (pp Policies) Upsert(p *PolicyRes) Policies {
idx, ok := pp.find(p.GR())
if !ok {
return append(pp, p)
}
p, err := pp[idx].Merge(p)
if err != nil {
slog.Error("Policy upsert failed", slogs.Error, err)
return pp
}
pp[idx] = p
return pp
}
// Find locates a row by id. Returns false is not found.
func (pp Policies) find(gr string) (int, bool) {
for i, p := range pp {
if p.GR() == gr {
return i, true
}
}
return 0, false
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/pvc.go | internal/render/pvc.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
var defaultPVCHeader = model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "STATUS"},
model1.HeaderColumn{Name: "VOLUME"},
model1.HeaderColumn{Name: "CAPACITY", Attrs: model1.Attrs{Capacity: true}},
model1.HeaderColumn{Name: "ACCESS MODES"},
model1.HeaderColumn{Name: "STORAGECLASS"},
model1.HeaderColumn{Name: "LABELS", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// PersistentVolumeClaim renders a K8s PersistentVolumeClaim to screen.
type PersistentVolumeClaim struct {
Base
}
// Header returns a header row.
func (p PersistentVolumeClaim) Header(_ string) model1.Header {
return p.doHeader(defaultPVCHeader)
}
// Render renders a K8s resource to screen.
func (p PersistentVolumeClaim) Render(o any, _ string, row *model1.Row) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
if err := p.defaultRow(raw, row); err != nil {
return err
}
if p.specs.isEmpty() {
return nil
}
cols, err := p.specs.realize(raw, defaultPVCHeader, row)
if err != nil {
return err
}
cols.hydrateRow(row)
return nil
}
func (p PersistentVolumeClaim) defaultRow(raw *unstructured.Unstructured, r *model1.Row) error {
var pvc v1.PersistentVolumeClaim
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &pvc)
if err != nil {
return err
}
phase := pvc.Status.Phase
if pvc.DeletionTimestamp != nil {
phase = "Terminating"
}
storage := pvc.Spec.Resources.Requests[v1.ResourceStorage]
var capacity, accessModes string
if pvc.Spec.VolumeName != "" {
accessModes = accessMode(pvc.Status.AccessModes)
storage = pvc.Status.Capacity[v1.ResourceStorage]
capacity = storage.String()
}
class, found := pvc.Annotations[v1.BetaStorageClassAnnotation]
if !found {
if pvc.Spec.StorageClassName != nil {
class = *pvc.Spec.StorageClassName
}
}
r.ID = client.MetaFQN(&pvc.ObjectMeta)
r.Fields = model1.Fields{
pvc.Namespace,
pvc.Name,
string(phase),
pvc.Spec.VolumeName,
capacity,
accessModes,
class,
mapToStr(pvc.Labels),
AsStatus(p.diagnose(string(phase))),
ToAge(pvc.GetCreationTimestamp()),
}
return nil
}
func (PersistentVolumeClaim) diagnose(r string) error {
if r != "Bound" && r != "Available" {
return fmt.Errorf("unexpected status %s", r)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/cust_col.go | internal/render/cust_col.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"log/slog"
"regexp"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/tview"
"k8s.io/kubectl/pkg/cmd/get"
)
var fullRX = regexp.MustCompile(`^([\w\s%/-]+):?([\w\W]*?)\|?([NTWSLRH]{0,3})$`)
type colAttr byte
const (
number colAttr = 'N'
age colAttr = 'T'
wide colAttr = 'W'
show colAttr = 'S'
alignLeft colAttr = 'L'
alignRight colAttr = 'R'
hide colAttr = 'H'
)
type colAttrs struct {
align int
mx bool
mxc bool
mxm bool
time bool
wide bool
show bool
hide bool
capacity bool
}
func newColFlags(flags string) colAttrs {
c := colAttrs{
align: tview.AlignLeft,
wide: false,
}
for _, b := range []byte(flags) {
switch colAttr(b) {
case hide:
c.hide = true
case wide:
c.wide, c.show = true, false
case show:
c.show, c.wide = true, false
case alignLeft:
c.align = tview.AlignLeft
case alignRight:
c.align = tview.AlignRight
case age:
c.time = true
case number:
c.capacity, c.align = true, tview.AlignRight
default:
slog.Warn("Unknown column attribute", slogs.Attr, b)
}
}
return c
}
type colDef struct {
colAttrs
name string
idx int
spec string
}
func parse(s string) (colDef, error) {
mm := fullRX.FindStringSubmatch(s)
if len(mm) == 4 {
spec, err := get.RelaxedJSONPathExpression(mm[2])
if err != nil {
return colDef{idx: -1}, err
}
return colDef{
name: mm[1],
idx: -1,
spec: spec,
colAttrs: newColFlags(mm[3]),
}, nil
}
return colDef{idx: -1}, fmt.Errorf("invalid column definition %q", s)
}
func (c colDef) toHeaderCol() model1.HeaderColumn {
return model1.HeaderColumn{
Name: c.name,
Attrs: model1.Attrs{
Align: c.align,
Wide: c.wide,
Show: c.show,
Time: c.time,
MX: c.mx,
MXC: c.mxc,
MXM: c.mxm,
Hide: c.hide,
Capacity: c.capacity,
},
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/generic.go | internal/render/generic.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)
var defaultGENHeader = model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// Generic renders a K8s generic resource to screen.
type Generic struct {
Base
}
// Header returns a header row.
func (m Generic) Header(_ string) model1.Header {
return m.doHeader(defaultGENHeader)
}
// Render renders a K8s resource to screen.
func (m Generic) Render(o any, _ string, row *model1.Row) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
if err := m.defaultRow(raw, row); err != nil {
return err
}
if m.specs.isEmpty() {
return nil
}
cols, err := m.specs.realize(o.(*unstructured.Unstructured), defaultGENHeader, row)
if err != nil {
return err
}
cols.hydrateRow(row)
return nil
}
// Render renders a K8s resource to screen.
func (Generic) defaultRow(raw *unstructured.Unstructured, r *model1.Row) error {
r.ID = client.FQN(raw.GetNamespace(), raw.GetName())
r.Fields = model1.Fields{
raw.GetNamespace(),
raw.GetName(),
"",
ToAge(raw.GetCreationTimestamp()),
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/render_test.go | internal/render/render_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"encoding/json"
"fmt"
"os"
"testing"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)
// Helpers...
func load(t testing.TB, 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/render/job_test.go | internal/render/job_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestJobRender(t *testing.T) {
c := render.Job{}
r := model1.NewRow(4)
require.NoError(t, c.Render(load(t, "job"), "", &r))
assert.Equal(t, "default/hello-1567179180", r.ID)
assert.Equal(t, model1.Fields{"default", "hello-1567179180", "n/a", "1/1", "8s", "controller-uid=7473e6d0-cb3b-11e9-990f-42010a800218", "c1", "blang/busybox-bash"}, r.Fields[:8])
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/base.go | internal/render/base.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"context"
"log/slog"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
)
// DecoratorFunc decorates a string.
type DecoratorFunc func(string) string
// AgeDecorator represents a timestamped as human column.
var AgeDecorator = toAgeHuman
type Base struct {
vs *config.ViewSetting
specs ColumnSpecs
includeObj bool
}
func (b *Base) SetIncludeObject(f bool) {
b.includeObj = f
}
// IsGeneric identifies a generic handler.
func (*Base) IsGeneric() bool {
return false
}
func (b *Base) doHeader(dh model1.Header) model1.Header {
if b.specs.isEmpty() {
return dh
}
return b.specs.Header(dh)
}
// SetViewSetting sets custom view settings if any.
func (b *Base) SetViewSetting(vs *config.ViewSetting) {
var cols []string
b.vs = vs
if vs != nil {
cols = vs.Columns
}
specs, err := NewColsSpecs(cols...).parseSpecs()
if err != nil {
slog.Error("Unable to grok custom columns", slogs.Error, err)
return
}
b.specs = specs
}
// ColorerFunc colors a resource row.
func (*Base) ColorerFunc() model1.ColorerFunc {
return model1.DefaultColorer
}
// Happy returns true if resource is happy, false otherwise.
func (*Base) Happy(string, *model1.Row) bool {
return true
}
// Healthy checks if the resource is healthy.
func (*Base) Healthy(context.Context, any) 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/render/job.go | internal/render/job.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"strconv"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
batchv1 "k8s.io/api/batch/v1"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/duration"
)
var defaultJOBHeader = model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "VS", Attrs: model1.Attrs{VS: true}},
model1.HeaderColumn{Name: "COMPLETIONS"},
model1.HeaderColumn{Name: "DURATION"},
model1.HeaderColumn{Name: "SELECTOR", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "CONTAINERS", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "IMAGES", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// Job renders a K8s Job to screen.
type Job struct {
Base
}
// Header returns a header row.
func (j Job) Header(_ string) model1.Header {
return j.doHeader(defaultJOBHeader)
}
// Render renders a K8s resource to screen.
func (j Job) Render(o any, _ string, row *model1.Row) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
if err := j.defaultRow(raw, row); err != nil {
return err
}
if j.specs.isEmpty() {
return nil
}
cols, err := j.specs.realize(raw, defaultJOBHeader, row)
if err != nil {
return err
}
cols.hydrateRow(row)
return nil
}
func (j Job) defaultRow(raw *unstructured.Unstructured, r *model1.Row) error {
var job batchv1.Job
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &job)
if err != nil {
return err
}
ready := toCompletion(&job.Spec, &job.Status)
cc, ii := toContainers(&job.Spec.Template.Spec)
r.ID = client.MetaFQN(&job.ObjectMeta)
r.Fields = model1.Fields{
job.Namespace,
job.Name,
computeVulScore(job.Namespace, job.Labels, &job.Spec.Template.Spec),
ready,
toDuration(&job.Status),
jobSelector(&job.Spec),
cc,
ii,
AsStatus(j.diagnose(ready, &job.Status)),
ToAge(job.GetCreationTimestamp()),
}
return nil
}
func (Job) diagnose(ready string, status *batchv1.JobStatus) error {
tokens := strings.Split(ready, "/")
if tokens[0] != tokens[1] && status.Failed > 0 {
return fmt.Errorf("%d pods failed", status.Failed)
}
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
const maxShow = 2
func toContainers(p *v1.PodSpec) (containers, images string) {
cc, ii := parseContainers(p.InitContainers)
cn, ci := parseContainers(p.Containers)
cc, ii = append(cc, cn...), append(ii, ci...)
// Limit to 2 of each...
if len(cc) > maxShow {
cc = append(cc[:2], "(+"+strconv.Itoa(len(cc)-maxShow)+")...")
}
if len(ii) > maxShow {
ii = append(ii[:2], "(+"+strconv.Itoa(len(ii)-maxShow)+")...")
}
return strings.Join(cc, ","), strings.Join(ii, ",")
}
func parseContainers(cos []v1.Container) (nn, ii []string) {
nn, ii = make([]string, 0, len(cos)), make([]string, 0, len(cos))
for i := range cos {
nn, ii = append(nn, cos[i].Name), append(ii, cos[i].Image)
}
return nn, ii
}
func toCompletion(spec *batchv1.JobSpec, status *batchv1.JobStatus) (s string) {
if spec.Completions != nil {
return strconv.Itoa(int(status.Succeeded)) + "/" + strconv.Itoa(int(*spec.Completions))
}
if spec.Parallelism == nil {
return strconv.Itoa(int(status.Succeeded)) + "/1"
}
p := *spec.Parallelism
if p > 1 {
return strconv.Itoa(int(status.Succeeded)) + "/1 of " + strconv.Itoa(int(p))
}
return strconv.Itoa(int(status.Succeeded)) + "/1"
}
func toDuration(status *batchv1.JobStatus) string {
if status.StartTime == nil || status.CompletionTime == nil {
return MissingValue
}
return duration.HumanDuration(status.CompletionTime.Sub(status.StartTime.Time))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/cust_col_test.go | internal/render/cust_col_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"errors"
"testing"
"github.com/derailed/tview"
"github.com/stretchr/testify/assert"
)
func TestCustCol_parse(t *testing.T) {
uu := map[string]struct {
s string
err error
e colDef
}{
"empty": {
err: errors.New(`invalid column definition ""`),
},
"plain": {
s: "fred",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
},
},
},
"plain-wide": {
s: "fred|W",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
wide: true,
},
},
},
"plain-hide": {
s: "fred|WH",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
wide: true,
hide: true,
},
},
},
"plain-show": {
s: "fred|S",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
show: true,
},
},
},
"age": {
s: "AGE|TR",
e: colDef{
name: "AGE",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignRight,
time: true,
},
},
},
"plain-wide-right": {
s: "fred|WR",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignRight,
wide: true,
},
},
},
"complex": {
s: "BLEE:.spec.addresses[?(@.type == 'CiliumInternalIP')].ip",
e: colDef{
name: "BLEE",
idx: -1,
spec: "{.spec.addresses[?(@.type == 'CiliumInternalIP')].ip}",
colAttrs: colAttrs{
align: tview.AlignLeft,
},
},
},
"complex-wide": {
s: "BLEE:.spec.addresses[?(@.type == 'CiliumInternalIP')].ip|WR",
e: colDef{
name: "BLEE",
idx: -1,
spec: "{.spec.addresses[?(@.type == 'CiliumInternalIP')].ip}",
colAttrs: colAttrs{
align: tview.AlignRight,
wide: true,
},
},
},
"full-complex-wide": {
s: "BLEE:.spec.addresses[?(@.type == 'CiliumInternalIP')].ip|WR",
e: colDef{
name: "BLEE",
idx: -1,
spec: "{.spec.addresses[?(@.type == 'CiliumInternalIP')].ip}",
colAttrs: colAttrs{
align: tview.AlignRight,
wide: true,
},
},
},
"full-number-wide": {
s: "fred:.metadata.name|NW",
e: colDef{
name: "fred",
idx: -1,
spec: "{.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignRight,
capacity: true,
wide: true,
},
},
},
"full-wide": {
s: "fred:.metadata.name|RW",
e: colDef{
name: "fred",
idx: -1,
spec: "{.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignRight,
wide: true,
},
},
},
"partial-time-no-wide": {
s: "fred:.metadata.name|T",
e: colDef{
name: "fred",
idx: -1,
spec: "{.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignLeft,
time: true,
},
},
},
"partial-no-type-no-wide": {
s: "fred:.metadata.name",
e: colDef{
name: "fred",
idx: -1,
spec: "{.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignLeft,
},
},
},
"partial-no-type-wide": {
s: "fred:.metadata.name|W",
e: colDef{
name: "fred",
idx: -1,
spec: "{.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignLeft,
wide: true,
},
},
},
"toast": {
s: "fred||.metadata.name|W",
e: colDef{
name: "fred",
idx: -1,
spec: "{.||.metadata.name}",
colAttrs: colAttrs{
align: tview.AlignLeft,
wide: true,
},
},
},
"toast-no-name": {
s: ":.metadata.name.fred|TW",
err: errors.New(`invalid column definition ":.metadata.name.fred|TW"`),
},
"spec-column-typed": {
s: `fred:.metadata.name.k8s:fred\.blee|TW`,
e: colDef{
name: "fred",
spec: `{.metadata.name.k8s:fred\.blee}`,
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
time: true,
wide: true,
},
},
},
"partial-no-spec-no-wide": {
s: "fred|T",
e: colDef{
name: "fred",
idx: -1,
colAttrs: colAttrs{
align: tview.AlignLeft,
time: true,
},
},
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
c, err := parse(u.s)
if err != nil {
assert.Equal(t, u.err, err)
} else {
assert.Equal(t, u.e, c)
}
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/portforward.go | internal/render/portforward.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"strings"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/tcell/v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
// Forwarder represents a port forwarder.
type Forwarder interface {
// ID returns the PF FQN.
ID() string
// Container returns a container name.
Container() string
// Port returns container exposed port.
Port() string
// Address returns the host address.
Address() string
// Active returns forwarder current state.
Active() bool
// Age returns forwarder age.
Age() time.Time
}
// PortForward renders a portforwards to screen.
type PortForward struct {
Base
}
// ColorerFunc colors a resource row.
func (PortForward) ColorerFunc() model1.ColorerFunc {
return func(string, model1.Header, *model1.RowEvent) tcell.Color {
return tcell.ColorSkyblue
}
}
// Header returns a header row.
func (PortForward) Header(string) model1.Header {
return model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "CONTAINER"},
model1.HeaderColumn{Name: "PORTS"},
model1.HeaderColumn{Name: "URL"},
model1.HeaderColumn{Name: "C"},
model1.HeaderColumn{Name: "N"},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
}
// Render renders a K8s resource to screen.
func (PortForward) Render(o any, _ string, r *model1.Row) error {
pf, ok := o.(ForwardRes)
if !ok {
return fmt.Errorf("expecting a ForwardRes but got %T", o)
}
ports := strings.Split(pf.Port(), ":")
r.ID = pf.ID()
ns, n := client.Namespaced(r.ID)
r.Fields = model1.Fields{
ns,
trimContainer(n),
pf.Container(),
pf.Port(),
UrlFor(pf.Config.Host, pf.Config.Path, ports[0], pf.Address()),
AsThousands(int64(pf.Config.C)),
AsThousands(int64(pf.Config.N)),
"",
ToAge(metav1.Time{Time: pf.Age()}),
}
return nil
}
// Helpers...
func trimContainer(n string) string {
tokens := strings.Split(n, "|")
if len(tokens) == 0 {
return n
}
_, name := client.Namespaced(tokens[0])
return name
}
// UrlFor computes fq url for a given benchmark configuration.
func UrlFor(host, path, port, address string) string {
if host == "" {
host = address
}
if path == "" {
path = "/"
}
return "http://" + host + ":" + port + path
}
// BenchCfg represents a benchmark configuration.
type BenchCfg struct {
C, N int
Host, Path string
}
// ForwardRes represents a benchmark resource.
type ForwardRes struct {
Forwarder
Config BenchCfg
}
// GetObjectKind returns a schema object.
func (ForwardRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (f ForwardRes) DeepCopyObject() runtime.Object {
return f
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/screen_dump_test.go | internal/render/screen_dump_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"os"
"testing"
"time"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestScreenDumpRender(t *testing.T) {
var s render.ScreenDump
var r model1.Row
o := render.FileRes{
File: fileInfo{},
Dir: "fred/blee",
}
require.NoError(t, s.Render(o, "fred", &r))
assert.Equal(t, "fred/blee/bob", r.ID)
assert.Equal(t, model1.Fields{
"bob",
"fred/blee",
"",
}, r.Fields[:len(r.Fields)-1])
}
// Helpers...
type fileInfo struct{}
var _ os.FileInfo = fileInfo{}
func (fileInfo) Name() string { return "bob" }
func (fileInfo) Size() int64 { return 100 }
func (fileInfo) ModTime() time.Time { return testTime() }
func (fileInfo) IsDir() bool { return false }
func (fileInfo) Sys() any { return nil }
func (fileInfo) Mode() os.FileMode {
return os.FileMode(0644)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/cust_cols.go | internal/render/cust_cols.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"errors"
"fmt"
"log/slog"
"reflect"
"strings"
"time"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
"github.com/itchyny/gojq"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/util/jsonpath"
)
// ColsSpecs represents a collection of column specification ie NAME:spec|flags.
type ColsSpecs []string
// NewColsSpecs returns a new instance.
func NewColsSpecs(cols ...string) ColsSpecs {
return ColsSpecs(cols)
}
func (cc ColsSpecs) parseSpecs() (ColumnSpecs, error) {
specs := make(ColumnSpecs, 0, len(cc))
for _, c := range cc {
def, err := parse(c)
if err != nil {
return nil, err
}
specs = append(specs, ColumnSpec{
Header: def.toHeaderCol(),
Spec: def.spec,
})
}
return specs, nil
}
// RenderedCols tracks a collection of column header and cust column parse expression.
type RenderedCols []RenderedCol
func (rr RenderedCols) hydrateRow(row *model1.Row) {
ff := make(model1.Fields, 0, len(row.Fields))
for _, c := range rr {
ff = append(ff, c.Value)
}
row.Fields = ff
}
// HasHeader checks if a given header is present in the collection.
func (rr RenderedCols) HasHeader(n string) bool {
for _, r := range rr {
if r.has(n) {
return true
}
}
return false
}
// RenderedCol represents a column header and a column spec.
type RenderedCol struct {
Header model1.HeaderColumn
Value string
}
// Has checks if the header column match the given name.
func (r RenderedCol) has(n string) bool {
return r.Header.Name == n
}
// ColumnSpec tracks a header column and an options cust column spec.
type ColumnSpec struct {
Header model1.HeaderColumn
Spec string
}
// ColumnSpecs tracks a collection of column specs.
type ColumnSpecs []ColumnSpec
func (c ColumnSpecs) isEmpty() bool {
return len(c) == 0
}
// Header builds a new header that is a super set of custom and/or default header.
func (cc ColumnSpecs) Header(rh model1.Header) model1.Header {
hh := make(model1.Header, 0, len(cc))
for _, h := range cc {
hh = append(hh, h.Header)
}
for _, h := range rh {
if idx, ok := hh.IndexOf(h.Name, true); ok {
hh[idx].Attrs = hh[idx].Merge(h.Attrs)
continue
}
hh = append(hh, h)
}
return hh
}
func (cc ColumnSpecs) realize(o runtime.Object, rh model1.Header, row *model1.Row) (RenderedCols, error) {
parsers := make([]*jsonpath.JSONPath, len(cc))
for ix := range cc {
if cc[ix].Spec == "" {
parsers[ix] = nil
continue
}
parsers[ix] = jsonpath.New(
fmt.Sprintf("column%d", ix),
).AllowMissingKeys(true)
if err := parsers[ix].Parse(cc[ix].Spec); err != nil && !isJQSpec(cc[ix].Spec) {
slog.Warn("Unable to parse custom column",
slogs.Name, cc[ix].Header.Name,
slogs.Error, err,
)
}
}
vv, err := hydrate(o, cc, parsers, rh, row)
if err != nil {
return nil, err
}
for _, hc := range rh {
if vv.HasHeader(hc.Name) {
continue
}
if idx, ok := rh.IndexOf(hc.Name, true); ok {
rc := RenderedCol{Header: hc, Value: row.Fields[idx]}
rc.Header.Wide = true
vv = append(vv, rc)
}
}
return vv, nil
}
func hydrate(o runtime.Object, cc ColumnSpecs, parsers []*jsonpath.JSONPath, rh model1.Header, row *model1.Row) (RenderedCols, error) {
cols := make(RenderedCols, len(parsers))
for idx := range parsers {
parser := parsers[idx]
if parser == nil {
ix, ok := rh.IndexOf(cc[idx].Header.Name, true)
if !ok {
cols[idx] = RenderedCol{
Header: cc[idx].Header,
Value: NAValue,
}
slog.Warn("Unable to find custom column", slogs.Name, cc[idx].Header.Name)
continue
}
var v string
if ix >= len(row.Fields) {
v = NAValue
} else {
v = row.Fields[ix]
}
cols[idx] = RenderedCol{
Header: rh[ix],
Value: v,
}
continue
}
if o == nil {
cols[idx] = RenderedCol{
Header: cc[idx].Header,
Value: NAValue,
}
continue
}
var (
vals [][]reflect.Value
err error
)
if unstructured, ok := o.(runtime.Unstructured); ok {
if vals, ok := jqParse(cc[idx].Spec, unstructured.UnstructuredContent()); ok {
cols[idx] = RenderedCol{
Header: cc[idx].Header,
Value: vals,
}
continue
}
vals, err = parser.FindResults(unstructured.UnstructuredContent())
} else {
rv := reflect.ValueOf(o)
if !rv.IsValid() || (rv.Kind() == reflect.Ptr && rv.IsNil()) {
cols[idx] = RenderedCol{
Header: cc[idx].Header,
Value: NAValue,
}
continue
}
vals, err = parser.FindResults(rv.Elem().Interface())
}
if err != nil {
return nil, err
}
values := make([]string, 0, len(vals))
if len(vals) == 0 || len(vals[0]) == 0 {
values = append(values, MissingValue)
}
for i := range vals {
for j := range vals[i] {
var (
strVal string
v = vals[i][j].Interface()
)
switch {
case cc[idx].Header.MXC:
switch k := v.(type) {
case resource.Quantity:
strVal = toMc(k.MilliValue())
case string:
if q, err := resource.ParseQuantity(k); err == nil {
strVal = toMc(q.MilliValue())
}
}
case cc[idx].Header.MXM:
switch k := v.(type) {
case resource.Quantity:
strVal = toMi(k.MilliValue())
case string:
if q, err := resource.ParseQuantity(k); err == nil {
strVal = toMi(q.MilliValue())
}
}
case cc[idx].Header.Time:
switch k := v.(type) {
case string:
if t, err := time.Parse(time.RFC3339, k); err == nil {
strVal = ToAge(metav1.Time{Time: t})
}
case metav1.Time:
strVal = ToAge(k)
}
}
if strVal == "" {
strVal = fmt.Sprintf("%v", v)
}
values = append(values, strVal)
}
}
cols[idx] = RenderedCol{
Header: cc[idx].Header,
Value: strings.Join(values, ","),
}
}
return cols, nil
}
func isJQSpec(spec string) bool {
return len(strings.Split(spec, "|")) > 2
}
func jqParse(spec string, o map[string]any) (string, bool) {
if !isJQSpec(spec) {
return "", false
}
exp := spec[1 : len(spec)-1]
jq, err := gojq.Parse(exp)
if err != nil {
slog.Warn("Fail to parse JQ expression", slogs.JQExp, exp, slogs.Error, err)
return "", false
}
rr := make([]string, 0, 10)
iter := jq.Run(o)
for v, ok := iter.Next(); ok; v, ok = iter.Next() {
if e, cool := v.(error); cool && e != nil {
if errors.Is(e, new(gojq.HaltError)) {
break
}
slog.Error("JQ expression evaluation failed. Check your query", slogs.Error, e)
continue
}
rr = append(rr, fmt.Sprintf("%v", v))
}
if len(rr) == 0 {
return "", false
}
return strings.Join(rr, ","), true
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/ro_test.go | internal/render/ro_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRoleRender(t *testing.T) {
c := render.Role{}
r := model1.NewRow(3)
require.NoError(t, c.Render(load(t, "ro"), "", &r))
assert.Equal(t, "default/blee", r.ID)
assert.Equal(t, model1.Fields{"default", "blee"}, r.Fields[:2])
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/ds_test.go | internal/render/ds_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDaemonSetRender(t *testing.T) {
c := render.DaemonSet{}
r := model1.NewRow(9)
require.NoError(t, c.Render(load(t, "ds"), "", &r))
assert.Equal(t, "kube-system/fluentd-gcp-v3.2.0", r.ID)
assert.Equal(t, model1.Fields{"kube-system", "fluentd-gcp-v3.2.0", "n/a", "2", "2", "2", "2", "2"}, r.Fields[:8])
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/ev.go | internal/render/ev.go | // Copyright Authors of K9s
package render
import (
"context"
"fmt"
"log/slog"
"github.com/derailed/k9s/internal/slogs"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// Event renders a event resource to screen.
type Event struct {
Table
}
// Healthy checks component health.
func (*Event) Healthy(_ context.Context, o any) error {
r, ok := o.(metav1.TableRow)
if !ok {
slog.Error("Expected TableRow", slogs.Type, fmt.Sprintf("%T", o))
return nil
}
idx := 2
if idx < len(r.Cells) && r.Cells[idx] != "Normal" {
return fmt.Errorf("event is not normal: %s", r.Cells[idx])
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/workload.go | internal/render/workload.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"strings"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/tcell/v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
var defaultWKHeader = model1.Header{
model1.HeaderColumn{Name: "KIND"},
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "STATUS"},
model1.HeaderColumn{Name: "READY"},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// Workload renders a workload to screen.
type Workload struct {
Base
}
// ColorerFunc colors a resource row.
func (Workload) ColorerFunc() model1.ColorerFunc {
return func(ns string, h model1.Header, re *model1.RowEvent) tcell.Color {
c := model1.DefaultColorer(ns, h, re)
idx, ok := h.IndexOf("STATUS", true)
if !ok {
return c
}
status := strings.TrimSpace(re.Row.Fields[idx])
if status == "DEGRADED" {
c = model1.PendingColor
}
return c
}
}
// Header returns a header rbw.
func (Workload) Header(string) model1.Header {
return defaultWKHeader
}
// Render renders a K8s resource to screen.
func (Workload) Render(o any, _ string, r *model1.Row) error {
res, ok := o.(*WorkloadRes)
if !ok {
return fmt.Errorf("expected WorkloadRes but got %T", o)
}
r.ID = fmt.Sprintf("%s|%s|%s", res.Row.Cells[0].(string), res.Row.Cells[1].(string), res.Row.Cells[2].(string))
r.Fields = model1.Fields{
res.Row.Cells[0].(string),
res.Row.Cells[1].(string),
res.Row.Cells[2].(string),
res.Row.Cells[3].(string),
res.Row.Cells[4].(string),
res.Row.Cells[5].(string),
ToAge(res.Row.Cells[6].(metav1.Time)),
}
return nil
}
type WorkloadRes struct {
Row metav1.TableRow
}
// GetObjectKind returns a schema object.
func (*WorkloadRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (a *WorkloadRes) DeepCopyObject() runtime.Object {
return a
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/sa_test.go | internal/render/sa_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestServiceAccountRender(t *testing.T) {
c := render.ServiceAccount{}
r := model1.NewRow(4)
require.NoError(t, c.Render(load(t, "sa"), "", &r))
assert.Equal(t, "default/blee", r.ID)
assert.Equal(t, model1.Fields{"default", "blee", "2"}, r.Fields[:3])
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/rbac.go | internal/render/rbac.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"strings"
"github.com/derailed/k9s/internal/model1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
const allVerbs = "*"
var (
k8sVerbs = []string{
"get",
"list",
"watch",
"create",
"patch",
"update",
"delete",
"deletecollection",
}
httpTok8sVerbs = map[string]string{
"post": "create",
"put": "update",
}
)
// Rbac renders a rbac to screen.
type Rbac struct {
Base
}
// ColorerFunc colors a resource row.
func (Rbac) ColorerFunc() model1.ColorerFunc {
return model1.DefaultColorer
}
// Header returns a header row.
func (Rbac) Header(string) model1.Header {
h := make(model1.Header, 0, 10)
h = append(h,
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "API-GROUP"},
)
h = append(h, rbacVerbHeader()...)
return append(h, model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}})
}
// Render renders a K8s resource to screen.
func (r Rbac) Render(o any, ns string, ro *model1.Row) error {
p, ok := o.(*PolicyRes)
if !ok {
return fmt.Errorf("expecting PolicyRes but got %T", o)
}
ro.ID = p.Resource
ro.Fields = make(model1.Fields, 0, len(r.Header(ns)))
ro.Fields = append(ro.Fields,
cleanseResource(p.Resource),
p.Group,
)
ro.Fields = append(ro.Fields, asVerbs(p.Verbs)...)
ro.Fields = append(ro.Fields, "")
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func asVerbs(verbs []string) []string {
const (
verbLen = 4
unknownLen = 30
)
r := make([]string, 0, len(k8sVerbs)+1)
for _, v := range k8sVerbs {
r = append(r, toVerbIcon(hasVerb(verbs, v)))
}
var unknowns []string
for _, v := range verbs {
if hv, ok := httpTok8sVerbs[v]; ok {
v = hv
}
if !hasVerb(k8sVerbs, v) && v != allVerbs {
unknowns = append(unknowns, v)
}
}
return append(r, Truncate(strings.Join(unknowns, ","), unknownLen))
}
func toVerbIcon(ok bool) string {
if ok {
return "[green::b] ✓ [::]"
}
return "[orangered::b] × [::]"
}
func hasVerb(verbs []string, verb string) bool {
if len(verbs) == 1 && verbs[0] == allVerbs {
return true
}
for _, v := range verbs {
if hv, ok := httpTok8sVerbs[v]; ok {
if hv == verb {
return true
}
}
if v == verb {
return true
}
}
return false
}
// RuleRes represents an rbac rule.
type RuleRes struct {
Resource, Group string
ResourceName string
NonResourceURL string
Verbs []string
}
// NewRuleRes returns a new rule.
func NewRuleRes(res, grp string, vv []string) *RuleRes {
return &RuleRes{
Resource: res,
Group: grp,
Verbs: vv,
}
}
// GetObjectKind returns a schema object.
func (*RuleRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (r *RuleRes) DeepCopyObject() runtime.Object {
return r
}
// Rules represents a collection of rules.
type Rules []*RuleRes
// Upsert adds a new rule.
func (rr Rules) Upsert(r *RuleRes) Rules {
idx, ok := rr.find(r.Resource)
if !ok {
return append(rr, r)
}
rr[idx] = r
return rr
}
// Find locates a row by id. Returns false is not found.
func (rr Rules) find(res string) (int, bool) {
for i, r := range rr {
if r.Resource == res {
return i, true
}
}
return 0, false
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/table_test.go | internal/render/table_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/client"
cfg "github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"
"k8s.io/apimachinery/pkg/runtime"
)
func TestGenericRender(t *testing.T) {
uu := map[string]struct {
ns string
table *metav1beta1.Table
eID string
eFields model1.Fields
eHeader model1.Header
}{
"withNS": {
ns: "ns1",
table: makeNSGeneric(),
eID: "ns1/fred",
eFields: model1.Fields{"ns1", "c1", "c2", "c3"},
eHeader: model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "A"},
model1.HeaderColumn{Name: "B"},
model1.HeaderColumn{Name: "C"},
},
},
"all": {
ns: client.NamespaceAll,
table: makeNSGeneric(),
eID: "ns1/fred",
eFields: model1.Fields{"ns1", "c1", "c2", "c3"},
eHeader: model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "A"},
model1.HeaderColumn{Name: "B"},
model1.HeaderColumn{Name: "C"},
},
},
"clusterWide": {
ns: client.ClusterScope,
table: makeNoNSGeneric(),
eID: "-/fred",
eFields: model1.Fields{"c1", "c2", "c3"},
eHeader: model1.Header{
model1.HeaderColumn{Name: "A"},
model1.HeaderColumn{Name: "B"},
model1.HeaderColumn{Name: "C"},
},
},
"age": {
ns: client.ClusterScope,
table: makeAgeGeneric(),
eID: "-/fred",
eFields: model1.Fields{"c1", "c2", "2d"},
eHeader: model1.Header{
model1.HeaderColumn{Name: "A"},
model1.HeaderColumn{Name: "C"},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
},
},
}
for k := range uu {
var re render.Table
u := uu[k]
t.Run(k, func(t *testing.T) {
var r model1.Row
re.SetTable(u.ns, u.table)
assert.Equal(t, u.eHeader, re.Header(u.ns))
require.NoError(t, re.Render(u.table.Rows[0], u.ns, &r))
assert.Equal(t, u.eID, r.ID)
assert.Equal(t, u.eFields, r.Fields)
})
}
}
func TestGenericCustRender(t *testing.T) {
uu := map[string]struct {
ns string
table *metav1beta1.Table
vs cfg.ViewSetting
eID string
eFields model1.Fields
eHeader model1.Header
}{
"spec": {
ns: "ns1",
table: makeNSGeneric(),
vs: cfg.ViewSetting{
Columns: []string{
"NAMESPACE",
"BLEE:.metadata.name",
"ZORG:.metadata.namespace",
},
},
eID: "ns1/fred",
eFields: model1.Fields{"ns1", "fred", "ns1", "c1", "c2", "c3"},
eHeader: model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "BLEE"},
model1.HeaderColumn{Name: "ZORG"},
model1.HeaderColumn{Name: "A"},
model1.HeaderColumn{Name: "B"},
model1.HeaderColumn{Name: "C"},
},
},
}
for k, u := range uu {
var re render.Table
re.SetViewSetting(&u.vs)
t.Run(k, func(t *testing.T) {
var r model1.Row
re.SetTable(u.ns, u.table)
assert.Equal(t, u.eHeader, re.Header(u.ns))
require.NoError(t, re.Render(u.table.Rows[0], u.ns, &r))
assert.Equal(t, u.eID, r.ID)
assert.Equal(t, u.eFields, r.Fields)
})
}
}
// ----------------------------------------------------------------------------
// Helpers...
func makeNSGeneric() *metav1beta1.Table {
return &metav1beta1.Table{
ColumnDefinitions: []metav1beta1.TableColumnDefinition{
{Name: "NAMESPACE"},
{Name: "a"},
{Name: "b"},
{Name: "c"},
},
Rows: []metav1beta1.TableRow{
{
Object: runtime.RawExtension{
Object: &unstructured.Unstructured{
Object: map[string]any{
"kind": "fred",
"apiVersion": "v1",
"metadata": map[string]any{
"namespace": "ns1",
"name": "fred",
},
},
},
},
Cells: []any{
"ns1",
"c1",
"c2",
"c3",
},
},
},
}
}
func makeNoNSGeneric() *metav1beta1.Table {
return &metav1beta1.Table{
ColumnDefinitions: []metav1beta1.TableColumnDefinition{
{Name: "a"},
{Name: "b"},
{Name: "c"},
},
Rows: []metav1beta1.TableRow{
{
Object: runtime.RawExtension{
Object: &unstructured.Unstructured{
Object: map[string]any{
"kind": "fred",
"apiVersion": "v1",
"metadata": map[string]any{
"name": "fred",
},
},
},
},
Cells: []any{
"c1",
"c2",
"c3",
},
},
},
}
}
func makeAgeGeneric() *metav1beta1.Table {
return &metav1beta1.Table{
ColumnDefinitions: []metav1beta1.TableColumnDefinition{
{Name: "a"},
{Name: "Age"},
{Name: "c"},
},
Rows: []metav1beta1.TableRow{
{
Object: runtime.RawExtension{
Object: &unstructured.Unstructured{
Object: map[string]any{
"kind": "fred",
"apiVersion": "v1",
"metadata": map[string]any{
"name": "fred",
},
},
},
},
Cells: []any{
"c1",
"2d",
"c2",
},
},
},
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/policy_test.go | internal/render/policy_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestPolicyResMerge(t *testing.T) {
uu := map[string]struct {
p1, p2, e *render.PolicyRes
err error
}{
"simple": {
p1: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get"}),
p2: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"patch"}),
e: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get", "patch"}),
},
"dups": {
p1: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get"}),
p2: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get", "delete"}),
e: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get", "delete"}),
},
"mismatch": {
p1: render.NewPolicyRes("fred", "blee", "deployments", "apps/v1", []string{"get"}),
p2: render.NewPolicyRes("fred", "blee", "statefulsets", "apps/v1", []string{"get", "delete"}),
err: errors.New("policy mismatch apps/v1/deployments vs apps/v1/statefulsets"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
e, err := u.p1.Merge(u.p2)
assert.Equal(t, u.err, err)
assert.Equal(t, u.e, e)
})
}
}
func TestPolicyRender(t *testing.T) {
var p render.Policy
var r model1.Row
o := render.PolicyRes{
Namespace: "blee",
Binding: "fred",
Resource: "res",
Group: "grp",
ResourceName: "bob",
NonResourceURL: "/blee",
Verbs: []string{"get", "list", "watch"},
}
require.NoError(t, p.Render(&o, "fred", &r))
assert.Equal(t, "blee/res", r.ID)
assert.Equal(t, model1.Fields{
"blee",
"res",
"grp",
"fred",
"[green::b] ✓ [::]",
"[green::b] ✓ [::]",
"[green::b] ✓ [::]",
"[orangered::b] × [::]",
"[orangered::b] × [::]",
"[orangered::b] × [::]",
"[orangered::b] × [::]",
"[orangered::b] × [::]",
"",
"",
}, r.Fields)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/crb.go | internal/render/crb.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
rbacv1 "k8s.io/api/rbac/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
var defaultCRBHeader = model1.Header{
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "CLUSTERROLE"},
model1.HeaderColumn{Name: "SUBJECT-KIND"},
model1.HeaderColumn{Name: "SUBJECTS"},
model1.HeaderColumn{Name: "LABELS", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// ClusterRoleBinding renders a K8s ClusterRoleBinding to screen.
type ClusterRoleBinding struct {
Base
}
// Header returns a header row.
func (c ClusterRoleBinding) Header(_ string) model1.Header {
return c.doHeader(defaultCRBHeader)
}
// Render renders a K8s resource to screen.
func (c ClusterRoleBinding) Render(o any, _ string, row *model1.Row) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
if err := c.defaultRow(raw, row); err != nil {
return err
}
if c.specs.isEmpty() {
return nil
}
cols, err := c.specs.realize(raw, defaultCRBHeader, row)
if err != nil {
return err
}
cols.hydrateRow(row)
return nil
}
func (ClusterRoleBinding) defaultRow(raw *unstructured.Unstructured, r *model1.Row) error {
var crb rbacv1.ClusterRoleBinding
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &crb)
if err != nil {
return err
}
kind, ss := renderSubjects(crb.Subjects)
r.ID = client.FQN("-", crb.Name)
r.Fields = model1.Fields{
crb.Name,
crb.RoleRef.Name,
kind,
ss,
mapToStr(crb.Labels),
ToAge(crb.GetCreationTimestamp()),
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/table.go | internal/render/table.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"encoding/json"
"fmt"
"log/slog"
"strings"
"sync"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/sets"
)
const ageTableCol = "Age"
var ageCols = sets.New("Last Seen", "First Seen", "Age")
// Table renders a tabular resource to screen.
type Table struct {
Base
table *metav1.Table
header model1.Header
ageIndex int
mx sync.RWMutex
}
func (*Table) IsGeneric() bool {
return true
}
func (t *Table) setAgeIndex(idx int) {
t.mx.Lock()
defer t.mx.Unlock()
t.ageIndex = idx
}
func (t *Table) getAgeIndex() int {
t.mx.RLock()
defer t.mx.RUnlock()
return t.ageIndex
}
// SetTable sets the tabular resource.
func (t *Table) SetTable(ns string, table *metav1.Table) {
t.table = table
t.header = t.Header(ns)
}
// ColorerFunc colors a resource row.
func (*Table) ColorerFunc() model1.ColorerFunc {
return model1.DefaultColorer
}
// Header returns a header row.
func (t *Table) Header(string) model1.Header {
return t.doHeader(t.defaultHeader())
}
// Header returns a header row.
func (t *Table) defaultHeader() model1.Header {
if t.table == nil {
return model1.Header{}
}
h := make(model1.Header, 0, len(t.table.ColumnDefinitions))
for i, c := range t.table.ColumnDefinitions {
if c.Name == ageTableCol {
t.setAgeIndex(i)
continue
}
timeCol := ageCols.Has(c.Name)
h = append(h, model1.HeaderColumn{Name: strings.ToUpper(c.Name), Attrs: model1.Attrs{Time: timeCol}})
}
if t.getAgeIndex() > 0 {
h = append(h, model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}})
}
return h
}
// Render renders a K8s resource to screen.
func (t *Table) Render(o any, ns string, r *model1.Row) error {
row, ok := o.(metav1.TableRow)
if !ok {
return fmt.Errorf("expected TableRow, but got %T", o)
}
if err := t.defaultRow(&row, ns, r); err != nil {
return err
}
if t.specs.isEmpty() {
return nil
}
obj := row.Object.Object
if obj != nil {
obj = obj.DeepCopyObject()
}
cols, err := t.specs.realize(obj, t.defaultHeader(), r)
if err != nil {
return err
}
cols.hydrateRow(r)
return nil
}
func (t *Table) defaultRow(row *metav1.TableRow, ns string, r *model1.Row) error {
th := t.header
ons, name := ns, UnknownValue
switch {
case row.Object.Object != nil:
if m, _ := meta.Accessor(row.Object.Object); m != nil {
ons, name = m.GetNamespace(), m.GetName()
}
case row.Object.Raw != nil:
var pm metav1.PartialObjectMetadata
if err := json.Unmarshal(row.Object.Raw, &pm); err != nil {
return err
}
ons, name = pm.Namespace, pm.Name
default:
if idx, ok := th.IndexOf("NAME", true); ok && idx >= 0 && idx < len(row.Cells) {
name = row.Cells[idx].(string)
}
if idx, ok := th.IndexOf("NAMESPACE", true); ok && idx >= 0 && idx < len(row.Cells) {
ons = row.Cells[idx].(string)
}
}
if client.IsClusterWide(ons) {
ons = client.ClusterScope
}
r.ID = client.FQN(ons, name)
r.Fields = make(model1.Fields, 0, len(th))
var (
age any
ageIdx = t.getAgeIndex()
)
for i, c := range row.Cells {
if ageIdx > 0 && i == ageIdx {
age = c
continue
}
if c == nil {
r.Fields = append(r.Fields, Blank)
continue
}
r.Fields = append(r.Fields, fmt.Sprintf("%v", c))
}
if d, ok := age.(string); ok {
r.Fields = append(r.Fields, d)
} else if ageIdx > 0 {
slog.Warn("No Duration detected on age field")
r.Fields = append(r.Fields, NAValue)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/pod_test.go | internal/render/pod_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/tcell/v2"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
res "k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
func init() {
model1.AddColor = tcell.ColorBlue
model1.HighlightColor = tcell.ColorYellow
model1.CompletedColor = tcell.ColorGray
model1.StdColor = tcell.ColorWhite
model1.ErrColor = tcell.ColorRed
model1.KillColor = tcell.ColorGray
}
func TestPodColorer(t *testing.T) {
stdHeader := model1.Header{
model1.HeaderColumn{Name: "NAMESPACE"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "READY"},
model1.HeaderColumn{Name: "RESTARTS"},
model1.HeaderColumn{Name: "STATUS"},
model1.HeaderColumn{Name: "VALID"},
}
uu := map[string]struct {
re model1.RowEvent
h model1.Header
e tcell.Color
}{
"valid": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.Running, ""},
},
},
e: model1.StdColor,
},
"init": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.PodInitializing, ""},
},
},
e: model1.AddColor,
},
"init-err": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.PodInitializing, "blah"},
},
},
e: model1.AddColor,
},
"initialized": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.Initialized, "blah"},
},
},
e: model1.HighlightColor,
},
"completed": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.Completed, "blah"},
},
},
e: model1.CompletedColor,
},
"terminating": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", render.Terminating, "blah"},
},
},
e: model1.KillColor,
},
"invalid": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", "Running", "blah"},
},
},
e: model1.ErrColor,
},
"unknown-cool": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", "blee", ""},
},
},
e: model1.AddColor,
},
"unknown-err": {
h: stdHeader,
re: model1.RowEvent{
Kind: model1.EventAdd,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", "blee", "doh"},
},
},
e: model1.ErrColor,
},
"status": {
h: stdHeader[0:3],
re: model1.RowEvent{
Kind: model1.EventDelete,
Row: model1.Row{
Fields: model1.Fields{"blee", "fred", "1/1", "0", "blee", ""},
},
},
e: model1.KillColor,
},
}
var r render.Pod
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, r.ColorerFunc()("", u.h, &u.re))
})
}
}
func TestPodRender(t *testing.T) {
pom := render.PodWithMetrics{
Raw: load(t, "po"),
MX: makePodMX("nginx", "100m", "50Mi"),
}
po := render.NewPod()
r := model1.NewRow(14)
err := po.Render(&pom, "", &r)
require.NoError(t, err)
assert.Equal(t, "default/nginx", r.ID)
e := model1.Fields{"default", "nginx", "n/a", "●", "1/1", "Running", "0", "<unknown>", "100", "100:0", "100", "n/a", "50", "70:170", "71", "29", "0:0", "172.17.0.6", "minikube", "default", "<none>"}
assert.Equal(t, e, r.Fields[:21])
}
func BenchmarkPodRender(b *testing.B) {
pom := render.PodWithMetrics{
Raw: load(b, "po"),
MX: makePodMX("nginx", "10m", "10Mi"),
}
po := render.NewPod()
r := model1.NewRow(12)
b.ReportAllocs()
b.ResetTimer()
for range b.N {
_ = po.Render(&pom, "", &r)
}
}
func TestPodInitRender(t *testing.T) {
pom := render.PodWithMetrics{
Raw: load(t, "po_init"),
MX: makePodMX("nginx", "10m", "10Mi"),
}
po := render.NewPod()
r := model1.NewRow(14)
err := po.Render(&pom, "", &r)
require.NoError(t, err)
assert.Equal(t, "default/nginx", r.ID)
e := model1.Fields{"default", "nginx", "n/a", "●", "1/1", "Init:0/1", "0", "<unknown>", "10", "100:0", "10", "n/a", "10", "70:170", "14", "5", "0:0", "172.17.0.6", "minikube", "default", "<none>"}
assert.Equal(t, e, r.Fields[:21])
}
func TestPodSidecarRender(t *testing.T) {
pom := render.PodWithMetrics{
Raw: load(t, "po_sidecar"),
MX: makePodMX("sleep", "100m", "40Mi"),
}
po := render.NewPod()
r := model1.NewRow(14)
err := po.Render(&pom, "", &r)
require.NoError(t, err)
assert.Equal(t, "default/sleep", r.ID)
e := model1.Fields{"default", "sleep", "n/a", "●", "2/2", "Running", "0", "<unknown>", "100", "50:250", "200", "40", "40", "50:80", "80", "50", "0:0", "10.244.0.8", "kind-control-plane", "default", "<none>"}
assert.Equal(t, e, r.Fields[:21])
}
func TestCheckPodStatus(t *testing.T) {
uu := map[string]struct {
pod v1.Pod
e string
}{
"unknown": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
},
},
e: render.PhaseUnknown,
},
"running": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
},
},
e: render.PhaseRunning,
},
"gated": {
pod: v1.Pod{
Status: v1.PodStatus{
Conditions: []v1.PodCondition{
{Type: v1.PodScheduled, Reason: v1.PodReasonSchedulingGated},
},
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
},
},
e: v1.PodReasonSchedulingGated,
},
"backoff": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: render.PhaseImagePullBackOff,
},
"backoff-init": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: "Init:ImagePullBackOff",
},
"init-terminated-cool": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: "Init:0/0",
},
"init-terminated-reason": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
ExitCode: 1,
Reason: "blah",
},
},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: "Init:blah",
},
"init-terminated-sig": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
ExitCode: 2,
Signal: 9,
},
},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: "Init:Signal:9",
},
"init-terminated-code": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
ExitCode: 2,
},
},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: render.PhaseImagePullBackOff,
},
},
},
},
},
},
e: "Init:ExitCode:2",
},
"co-reason": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
Reason: "blah",
},
},
},
},
},
},
e: "blah",
},
"co-reason-ready": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
Ready: true,
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
},
},
e: "Running",
},
"co-reason-completed": {
pod: v1.Pod{
Status: v1.PodStatus{
Conditions: []v1.PodCondition{
{Type: v1.PodReady, Status: v1.ConditionTrue},
},
Phase: render.PhaseCompleted,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
Ready: true,
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
},
},
e: "Running",
},
"co-sig": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
ExitCode: 2,
Signal: 9,
},
},
},
},
},
},
e: "Signal:9",
},
"co-code": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Terminated: &v1.ContainerStateTerminated{
ExitCode: 2,
},
},
},
},
},
},
e: "ExitCode:2",
},
"co-ready": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: v1.PodRunning,
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
},
},
e: "Running",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, render.PodStatus(&u.pod))
})
}
}
func TestCheckPhase(t *testing.T) {
always := v1.ContainerRestartPolicyAlways
uu := map[string]struct {
pod v1.Pod
e string
}{
"unknown": {
pod: v1.Pod{
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
},
},
e: render.PhaseUnknown,
},
"terminating": {
pod: v1.Pod{
ObjectMeta: metav1.ObjectMeta{
DeletionTimestamp: &metav1.Time{Time: testTime()},
},
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
Reason: "bla",
},
},
e: render.PhaseTerminating,
},
"terminating-toast-node": {
pod: v1.Pod{
ObjectMeta: metav1.ObjectMeta{
DeletionTimestamp: &metav1.Time{Time: testTime()},
},
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
Reason: render.NodeUnreachablePodReason,
},
},
e: render.PhaseUnknown,
},
"restartable": {
pod: v1.Pod{
ObjectMeta: metav1.ObjectMeta{
DeletionTimestamp: &metav1.Time{Time: testTime()},
},
Spec: v1.PodSpec{
InitContainers: []v1.Container{
{
Name: "ic1",
RestartPolicy: &always,
},
},
},
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
Reason: "bla",
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
},
},
},
},
e: "Init:0/1",
},
"waiting": {
pod: v1.Pod{
ObjectMeta: metav1.ObjectMeta{
DeletionTimestamp: &metav1.Time{Time: testTime()},
},
Spec: v1.PodSpec{
InitContainers: []v1.Container{
{
Name: "ic1",
RestartPolicy: &always,
},
},
Containers: []v1.Container{
{
Name: "c1",
},
},
},
Status: v1.PodStatus{
Phase: render.PhaseUnknown,
Reason: "bla",
InitContainerStatuses: []v1.ContainerStatus{
{
Name: "ic1",
State: v1.ContainerState{
Running: &v1.ContainerStateRunning{},
},
},
},
ContainerStatuses: []v1.ContainerStatus{
{
Name: "c1",
State: v1.ContainerState{
Waiting: &v1.ContainerStateWaiting{
Reason: "bla",
},
},
},
},
},
},
e: "Init:0/1",
},
}
var p render.Pod
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, p.Phase(u.pod.DeletionTimestamp, &u.pod.Spec, &u.pod.Status))
})
}
}
// ----------------------------------------------------------------------------
// Helpers...
func makePodMX(name, cpu, mem string) *mv1beta1.PodMetrics {
return &mv1beta1.PodMetrics{
ObjectMeta: metav1.ObjectMeta{
Name: name,
Namespace: "default",
},
Containers: []mv1beta1.ContainerMetrics{
{Usage: makeRes(cpu, mem)},
},
}
}
func makeRes(c, m string) v1.ResourceList {
cpu, _ := res.ParseQuantity(c)
mem, _ := res.ParseQuantity(m)
return v1.ResourceList{
v1.ResourceCPU: cpu,
v1.ResourceMemory: mem,
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/container.go | internal/render/container.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"errors"
"fmt"
"strconv"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
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"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
const falseStr = "false"
// ContainerWithMetrics represents a container and it's metrics.
type ContainerWithMetrics interface {
// Container returns the container
Container() *v1.Container
// ContainerStatus returns the current container status.
ContainerStatus() *v1.ContainerStatus
// Metrics returns the container metrics.
Metrics() *mv1beta1.ContainerMetrics
// Age returns the pod age.
Age() metav1.Time
// IsInit indicates a init container.
IsInit() bool
}
// Container renders a K8s Container to screen.
type Container struct {
Base
}
// ColorerFunc colors a resource row.
func (Container) ColorerFunc() model1.ColorerFunc {
return func(ns string, h model1.Header, re *model1.RowEvent) tcell.Color {
c := model1.DefaultColorer(ns, h, re)
idx, ok := h.IndexOf("STATE", true)
if !ok {
return c
}
switch strings.TrimSpace(re.Row.Fields[idx]) {
case Pending:
return model1.PendingColor
case ContainerCreating, PodInitializing:
return model1.AddColor
case Terminating, Initialized:
return model1.HighlightColor
case Completed:
return model1.CompletedColor
case Running:
return c
default:
return model1.ErrColor
}
}
}
// Header returns a header row.
func (Container) Header(_ string) model1.Header {
return defaultCOHeader
}
// Header returns a header row.
var defaultCOHeader = model1.Header{
model1.HeaderColumn{Name: "IDX"},
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "PF"},
model1.HeaderColumn{Name: "IMAGE"},
model1.HeaderColumn{Name: "READY"},
model1.HeaderColumn{Name: "STATE"},
model1.HeaderColumn{Name: "RESTARTS", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "PROBES(L:R:S)"},
model1.HeaderColumn{Name: "CPU", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "CPU/RL", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "%CPU/R", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "%CPU/L", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "MEM", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "MEM/RL", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "%MEM/R", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "%MEM/L", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "GPU/RL", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "PORTS"},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// Render renders a K8s resource to screen.
func (c Container) Render(o any, _ string, row *model1.Row) error {
cr, ok := o.(ContainerRes)
if !ok {
return fmt.Errorf("expected ContainerRes, but got %T", o)
}
return c.defaultRow(cr, row)
}
func (c Container) defaultRow(cr ContainerRes, r *model1.Row) error {
cur, res := gatherContainerMX(cr.Container, cr.MX)
ready, state, restarts := falseStr, MissingValue, "0"
if cr.Status != nil {
ready, state, restarts = boolToStr(cr.Status.Ready), ToContainerState(cr.Status.State), strconv.Itoa(int(cr.Status.RestartCount))
}
r.ID = cr.Container.Name
r.Fields = model1.Fields{
cr.Idx,
cr.Container.Name,
"●",
cr.Container.Image,
ready,
state,
restarts,
probe(cr.Container.LivenessProbe) + ":" + probe(cr.Container.ReadinessProbe) + ":" + probe(cr.Container.StartupProbe),
toMc(cur.cpu),
toMc(res.cpu) + ":" + toMc(res.lcpu),
client.ToPercentageStr(cur.cpu, res.cpu),
client.ToPercentageStr(cur.cpu, res.lcpu),
toMi(cur.mem),
toMi(res.mem) + ":" + toMi(res.lmem),
client.ToPercentageStr(cur.mem, res.mem),
client.ToPercentageStr(cur.mem, res.lmem),
toMc(res.gpu) + ":" + toMc(res.lgpu),
ToContainerPorts(cr.Container.Ports),
AsStatus(c.diagnose(state, ready)),
ToAge(cr.Age),
}
return nil
}
// Happy returns true if resource is happy, false otherwise.
func (Container) diagnose(state, ready string) error {
if state == "Completed" {
return nil
}
if ready == falseStr {
return errors.New("container is not ready")
}
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func containerRequests(co *v1.Container) v1.ResourceList {
req := co.Resources.Requests
if len(req) != 0 {
return req
}
lim := co.Resources.Limits
if len(lim) != 0 {
return lim
}
return nil
}
func gatherContainerMX(co *v1.Container, mx *mv1beta1.ContainerMetrics) (c, r metric) {
rList, lList := containerRequests(co), co.Resources.Limits
if q := rList.Cpu(); q != nil {
r.cpu = q.MilliValue()
}
if q := lList.Cpu(); q != nil {
r.lcpu = q.MilliValue()
}
if q := rList.Memory(); q != nil {
r.mem = q.Value()
}
if q := lList.Memory(); q != nil {
r.lmem = q.Value()
}
if q := extractGPU(rList); q != nil {
r.gpu = q.Value()
}
if q := extractGPU(lList); q != nil {
r.lgpu = q.Value()
}
if mx != nil {
if q := mx.Usage.Cpu(); q != nil {
c.cpu = q.MilliValue()
}
if q := mx.Usage.Memory(); q != nil {
c.mem = q.Value()
}
}
return
}
// ToContainerPorts returns container ports as a string.
func ToContainerPorts(pp []v1.ContainerPort) string {
ports := make([]string, len(pp))
for i, p := range pp {
if p.Name != "" {
ports[i] = p.Name + ":"
}
ports[i] += strconv.Itoa(int(p.ContainerPort))
if p.Protocol != "TCP" {
ports[i] += "╱" + string(p.Protocol)
}
}
return strings.Join(ports, ",")
}
// ToContainerState returns container state as a string.
func ToContainerState(s v1.ContainerState) string {
switch {
case s.Waiting != nil:
if s.Waiting.Reason != "" {
return s.Waiting.Reason
}
return "Waiting"
case s.Terminated != nil:
if s.Terminated.Reason != "" {
return s.Terminated.Reason
}
return "Terminating"
case s.Running != nil:
return "Running"
default:
return MissingValue
}
}
const (
on = "on"
off = "off"
)
func probe(p *v1.Probe) string {
if p == nil {
return off
}
return on
}
// ContainerRes represents a container and its metrics.
type ContainerRes struct {
Container *v1.Container
Status *v1.ContainerStatus
MX *mv1beta1.ContainerMetrics
Idx string
Age metav1.Time
}
// GetObjectKind returns a schema object.
func (ContainerRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (c ContainerRes) 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/render/node.go | internal/render/node.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"context"
"errors"
"fmt"
"log/slog"
"sort"
"strconv"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/tview"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
const (
labelNodeRolePrefix = "node-role.kubernetes.io/"
labelNodeRoleSuffix = "kubernetes.io/role"
)
var defaultNOHeader = model1.Header{
model1.HeaderColumn{Name: "NAME"},
model1.HeaderColumn{Name: "STATUS"},
model1.HeaderColumn{Name: "ROLE"},
model1.HeaderColumn{Name: "ARCH", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "TAINTS"},
model1.HeaderColumn{Name: "VERSION"},
model1.HeaderColumn{Name: "OS-IMAGE", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "KERNEL", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "INTERNAL-IP", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "EXTERNAL-IP", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "PODS", Attrs: model1.Attrs{Align: tview.AlignRight}},
model1.HeaderColumn{Name: "CPU", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "CPU/A", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "%CPU", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "MEM", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "MEM/A", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "%MEM", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "GPU/A", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "GPU/C", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "SH-GPU/A", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "SH-GPU/C", Attrs: model1.Attrs{Align: tview.AlignRight, MX: true}},
model1.HeaderColumn{Name: "LABELS", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "VALID", Attrs: model1.Attrs{Wide: true}},
model1.HeaderColumn{Name: "AGE", Attrs: model1.Attrs{Time: true}},
}
// Node renders a K8s Node to screen.
type Node struct {
Base
}
// Header returns a header row.
func (n Node) Header(_ string) model1.Header {
return n.doHeader(defaultNOHeader)
}
// Render renders a K8s resource to screen.
func (n Node) Render(o any, _ string, row *model1.Row) error {
nwm, ok := o.(*NodeWithMetrics)
if !ok {
return fmt.Errorf("expected NodeWithMetrics, but got %T", o)
}
if err := n.defaultRow(nwm, row); err != nil {
return err
}
if n.specs.isEmpty() {
return nil
}
cols, err := n.specs.realize(nwm.Raw, defaultNOHeader, row)
if err != nil {
return err
}
cols.hydrateRow(row)
return nil
}
// Render renders a K8s resource to screen.
func (n Node) defaultRow(nwm *NodeWithMetrics, r *model1.Row) error {
var no v1.Node
err := runtime.DefaultUnstructuredConverter.FromUnstructured(nwm.Raw.Object, &no)
if err != nil {
return err
}
iIP, eIP := getIPs(no.Status.Addresses)
iIP, eIP = missing(iIP), missing(eIP)
c, a := gatherNodeMX(&no, nwm.MX)
statuses := make(sort.StringSlice, 10)
status(no.Status.Conditions, no.Spec.Unschedulable, statuses)
sort.Sort(statuses)
roles := make(sort.StringSlice, 10)
nodeRoles(&no, roles)
sort.Sort(roles)
podCount := strconv.Itoa(nwm.PodCount)
if pc := nwm.PodCount; pc == -1 {
podCount = NAValue
}
r.ID = client.FQN("", no.Name)
r.Fields = model1.Fields{
no.Name,
join(statuses, ","),
join(roles, ","),
no.Status.NodeInfo.Architecture,
strconv.Itoa(len(no.Spec.Taints)),
no.Status.NodeInfo.KubeletVersion,
no.Status.NodeInfo.OSImage,
no.Status.NodeInfo.KernelVersion,
iIP,
eIP,
podCount,
toMc(c.cpu),
toMc(a.cpu),
client.ToPercentageStr(c.cpu, a.cpu),
toMi(c.mem),
toMi(a.mem),
client.ToPercentageStr(c.mem, a.mem),
toMu(a.gpu),
toMu(c.gpu),
toMu(a.gpuShared),
toMu(c.gpuShared),
mapToStr(no.Labels),
AsStatus(n.diagnose(statuses)),
ToAge(no.GetCreationTimestamp()),
}
return nil
}
// Healthy checks component health.
func (n Node) Healthy(_ context.Context, o any) error {
nwm, ok := o.(*NodeWithMetrics)
if !ok {
slog.Error("Expected *NodeWithMetrics", slogs.Type, fmt.Sprintf("%T", o))
return nil
}
var no v1.Node
err := runtime.DefaultUnstructuredConverter.FromUnstructured(nwm.Raw.Object, &no)
if err != nil {
slog.Error("Failed to convert unstructured to Node", slogs.Error, err)
return nil
}
ss := make([]string, 10)
status(no.Status.Conditions, no.Spec.Unschedulable, ss)
return n.diagnose(ss)
}
func (Node) diagnose(ss []string) error {
if len(ss) == 0 {
return nil
}
var ready bool
for _, s := range ss {
if s == "" {
continue
}
if s == "SchedulingDisabled" {
return errors.New("node is cordoned")
}
if s == "Ready" {
ready = true
}
}
if !ready {
return errors.New("node is not ready")
}
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
// NodeWithMetrics represents a node with its associated metrics.
type NodeWithMetrics struct {
Raw *unstructured.Unstructured
MX *mv1beta1.NodeMetrics
PodCount int
}
// GetObjectKind returns a schema object.
func (*NodeWithMetrics) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (n *NodeWithMetrics) DeepCopyObject() runtime.Object {
return n
}
type metric struct {
cpu, mem int64
lcpu, lmem int64
gpu, gpuShared int64
lgpu int64
}
func gatherNodeMX(no *v1.Node, mx *mv1beta1.NodeMetrics) (c, a metric) {
a.cpu = no.Status.Allocatable.Cpu().MilliValue()
a.mem = no.Status.Allocatable.Memory().Value()
if mx != nil {
c.cpu = mx.Usage.Cpu().MilliValue()
c.mem = mx.Usage.Memory().Value()
}
gpu, gpuShared := extractNodeGPU(no.Status.Allocatable)
if gpu != nil {
a.gpu = gpu.Value()
}
if gpuShared != nil {
a.gpuShared = gpuShared.Value()
}
gpu, gpuShared = extractNodeGPU(no.Status.Capacity)
if gpu != nil {
c.gpu = gpu.Value()
}
if gpuShared != nil {
c.gpuShared = gpuShared.Value()
}
return
}
func extractNodeGPU(rl v1.ResourceList) (main, shared *resource.Quantity) {
mm := make(map[string]*resource.Quantity, len(config.KnownGPUVendors))
for _, v := range config.KnownGPUVendors {
if q, ok := rl[v1.ResourceName(v)]; ok {
mm[v] = &q
}
}
for k, v := range mm {
if strings.HasSuffix(k, "shared") {
shared = v
} else {
main = v
}
}
return
}
func nodeRoles(node *v1.Node, res []string) {
index := 0
for k, v := range node.Labels {
switch {
case strings.HasPrefix(k, labelNodeRolePrefix):
if role := strings.TrimPrefix(k, labelNodeRolePrefix); role != "" {
res[index] = role
index++
}
case strings.HasSuffix(k, labelNodeRoleSuffix) && v != "":
res[index] = v
index++
}
if index >= len(res) {
break
}
}
if blank(res) {
res[index] = MissingValue
}
}
func getIPs(addrs []v1.NodeAddress) (iIP, eIP string) {
for _, a := range addrs {
//nolint:exhaustive
switch a.Type {
case v1.NodeExternalIP:
eIP = a.Address
case v1.NodeInternalIP:
iIP = a.Address
}
}
return
}
func status(conds []v1.NodeCondition, exempt bool, res []string) {
var index int
conditions := make(map[v1.NodeConditionType]*v1.NodeCondition, len(conds))
for n := range conds {
cond := conds[n]
conditions[cond.Type] = &cond
}
validConditions := []v1.NodeConditionType{v1.NodeReady}
for _, validCondition := range validConditions {
condition, ok := conditions[validCondition]
if !ok {
continue
}
neg := ""
if condition.Status != v1.ConditionTrue {
neg = "Not"
}
res[index] = neg + string(condition.Type)
index++
}
if len(res) == 0 {
res[index] = "Unknown"
index++
}
if exempt {
res[index] = "SchedulingDisabled"
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/alias.go | internal/render/alias.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
import (
"fmt"
"slices"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/model1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
)
var defaultAliasHeader = model1.Header{
model1.HeaderColumn{Name: "RESOURCE"},
model1.HeaderColumn{Name: "GROUP"},
model1.HeaderColumn{Name: "VERSION"},
model1.HeaderColumn{Name: "COMMAND"},
}
// Alias renders an aliases to screen.
type Alias struct {
Base
}
// Header returns a header row.
func (Alias) Header(string) model1.Header {
return defaultAliasHeader
}
// Render renders a K8s resource to screen.
// BOZO!! Pass in a row with pre-alloc fields??
func (Alias) Render(o any, _ string, r *model1.Row) error {
a, ok := o.(AliasRes)
if !ok {
return fmt.Errorf("expected AliasRes, but got %T", o)
}
slices.Sort(a.Aliases)
r.ID = a.GVR.String()
r.Fields = append(r.Fields,
a.GVR.R(),
a.GVR.G(),
a.GVR.V(),
strings.Join(a.Aliases, " "),
)
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
// AliasRes represents an alias resource.
type AliasRes struct {
GVR *client.GVR
Aliases []string
}
// GetObjectKind returns a schema object.
func (AliasRes) GetObjectKind() schema.ObjectKind {
return nil
}
// DeepCopyObject returns a container copy.
func (a AliasRes) DeepCopyObject() runtime.Object {
return a
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/types.go | internal/render/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render
const (
// NonResource represents a custom resource.
NonResource = "*"
)
const (
// Terminating represents a pod terminating status.
Terminating = "Terminating"
// Running represents a pod running status.
Running = "Running"
// Initialized represents a pod initialized status.
Initialized = "Initialized"
// Completed represents a pod completed status.
Completed = "Completed"
// ContainerCreating represents a pod container status.
ContainerCreating = "ContainerCreating"
// PodInitializing represents a pod initializing status.
PodInitializing = "PodInitializing"
// Pending represents a pod pending status.
Pending = "Pending"
// Blank represents no value.
Blank = ""
)
const (
// MissingValue indicates an unset value.
MissingValue = "<none>"
// NAValue indicates a value that does not pertain.
NAValue = "n/a"
// UnknownValue represents an unknown.
UnknownValue = "<unknown>"
// UnsetValue represent an unset value.
UnsetValue = "<unset>"
// ZeroValue represents a zero value.
ZeroValue = "0"
)
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/render/rs_test.go | internal/render/rs_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package render_test
import (
"testing"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestReplicaSetRender(t *testing.T) {
c := render.ReplicaSet{}
r := model1.NewRow(4)
require.NoError(t, c.Render(load(t, "rs"), "", &r))
assert.Equal(t, "icx/icx-db-7d4b578979", r.ID)
assert.Equal(t, model1.Fields{"icx", "icx-db-7d4b578979", "n/a", "1", "1", "1"}, r.Fields[:6])
}
| 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.