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/model/table_test.go | internal/model/table_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"context"
"encoding/json"
"fmt"
"os"
"testing"
"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/model1"
"github.com/derailed/k9s/internal/watch"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
)
func TestTableRefresh(t *testing.T) {
ta := model.NewTable(client.PodGVR)
ta.SetNamespace(client.NamespaceAll)
l := tableListener{}
ta.AddListener(&l)
f := makeTableFactory()
f.rows = []runtime.Object{mustLoad("p1")}
ctx := context.WithValue(context.Background(), internal.KeyFactory, f)
ctx = context.WithValue(ctx, internal.KeyFields, "")
ctx = context.WithValue(ctx, internal.KeyWithMetrics, false)
require.NoError(t, ta.Refresh(ctx))
data := ta.Peek()
assert.Equal(t, 26, data.HeaderCount())
assert.Equal(t, 1, data.RowCount())
assert.Equal(t, client.NamespaceAll, data.GetNamespace())
assert.Equal(t, 1, l.count)
assert.Equal(t, 0, l.errs)
}
func TestTableNS(t *testing.T) {
ta := model.NewTable(client.PodGVR)
ta.SetNamespace("blee")
assert.Equal(t, "blee", ta.GetNamespace())
assert.False(t, ta.ClusterWide())
assert.False(t, ta.InNamespace("zorg"))
}
func TestTableAddListener(t *testing.T) {
ta := model.NewTable(client.PodGVR)
ta.SetNamespace("blee")
assert.True(t, ta.Empty())
l := tableListener{}
ta.AddListener(&l)
}
func TestTableRmListener(*testing.T) {
ta := model.NewTable(client.PodGVR)
ta.SetNamespace("blee")
l := tableListener{}
ta.RemoveListener(&l)
}
// Helpers...
type tableListener struct {
count, errs int
}
func (*tableListener) TableNoData(*model1.TableData) {}
func (l *tableListener) TableDataChanged(*model1.TableData) {
l.count++
}
func (l *tableListener) TableLoadFailed(error) {
l.errs++
}
type tableFactory struct {
rows []runtime.Object
}
var _ dao.Factory = tableFactory{}
func (tableFactory) Client() client.Connection {
return client.NewTestAPIClient()
}
func (f tableFactory) Get(*client.GVR, string, bool, labels.Selector) (runtime.Object, error) {
if len(f.rows) > 0 {
return f.rows[0], nil
}
return nil, nil
}
func (f tableFactory) List(*client.GVR, string, bool, labels.Selector) ([]runtime.Object, error) {
if len(f.rows) > 0 {
return f.rows, nil
}
return nil, nil
}
func (tableFactory) ForResource(string, *client.GVR) (informers.GenericInformer, error) {
return nil, nil
}
func (tableFactory) CanForResource(string, *client.GVR, []string) (informers.GenericInformer, error) {
return nil, nil
}
func (tableFactory) WaitForCacheSync() {}
func (tableFactory) Forwarders() watch.Forwarders {
return nil
}
func (tableFactory) DeleteForwarder(string) {}
func makeTableFactory() tableFactory {
return tableFactory{}
}
func mustLoad(n string) *unstructured.Unstructured {
raw, err := os.ReadFile(fmt.Sprintf("testdata/%s.json", n))
if err != nil {
panic(err)
}
var o unstructured.Unstructured
if err = json.Unmarshal(raw, &o); err != nil {
panic(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/model/table.go | internal/model/table.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"sync"
"sync/atomic"
"time"
backoff "github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/slogs"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
const initRefreshRate = 300 * time.Millisecond
// TableListener represents a table model listener.
type TableListener interface {
// TableNoData notifies listener no data was found.
TableNoData(*model1.TableData)
// TableDataChanged notifies the model data changed.
TableDataChanged(*model1.TableData)
// TableLoadFailed notifies the load failed.
TableLoadFailed(error)
}
// Table represents a table model.
type Table struct {
gvr *client.GVR
data *model1.TableData
listeners []TableListener
inUpdate int32
refreshRate time.Duration
instance string
labelSelector labels.Selector
mx sync.RWMutex
vs *config.ViewSetting
}
// NewTable returns a new table model.
func NewTable(gvr *client.GVR) *Table {
return &Table{
gvr: gvr,
data: model1.NewTableData(gvr),
refreshRate: 2 * time.Second,
}
}
func (t *Table) SetViewSetting(ctx context.Context, vs *config.ViewSetting) {
t.mx.Lock()
t.vs = vs
t.mx.Unlock()
if ctx != context.Background() {
if err := t.reconcile(ctx); err != nil {
slog.Error("Refresh failed", slogs.GVR, t.gvr)
}
}
}
// SetLabelSelector sets the labels selector.
func (t *Table) SetLabelSelector(sel labels.Selector) {
t.mx.Lock()
defer t.mx.Unlock()
t.labelSelector = sel
}
// GetLabelSelector sets the labels selector.
func (t *Table) GetLabelSelector() labels.Selector {
t.mx.Lock()
defer t.mx.Unlock()
return t.labelSelector
}
// SetInstance sets a single entry table.
func (t *Table) SetInstance(path string) {
t.instance = path
}
// AddListener adds a new model listener.
func (t *Table) AddListener(l TableListener) {
t.mx.Lock()
defer t.mx.Unlock()
t.listeners = append(t.listeners, l)
}
// RemoveListener delete a listener from the list.
func (t *Table) RemoveListener(l TableListener) {
victim := -1
for i, lis := range t.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
t.mx.Lock()
t.listeners = append(t.listeners[:victim], t.listeners[victim+1:]...)
t.mx.Unlock()
}
}
// Watch initiates model updates.
func (t *Table) Watch(ctx context.Context) error {
if err := t.refresh(ctx); err != nil {
return err
}
go t.updater(ctx)
return nil
}
// Refresh updates the table content.
func (t *Table) Refresh(ctx context.Context) error {
return t.refresh(ctx)
}
// Get returns a resource instance if found, else an error.
func (t *Table) Get(ctx context.Context, path string) (runtime.Object, error) {
meta, err := getMeta(ctx, t.gvr)
if err != nil {
return nil, err
}
return meta.DAO.Get(ctx, path)
}
// Delete deletes a resource.
func (t *Table) Delete(ctx context.Context, path string, propagation *metav1.DeletionPropagation, grace dao.Grace) error {
meta, err := getMeta(ctx, t.gvr)
if err != nil {
return err
}
nuker, ok := meta.DAO.(dao.Nuker)
if !ok {
return fmt.Errorf("no nuker for %q", meta.DAO.GVR())
}
return nuker.Delete(ctx, path, propagation, grace)
}
// GetNamespace returns the model namespace.
func (t *Table) GetNamespace() string {
return t.data.GetNamespace()
}
// SetNamespace sets up model namespace.
func (t *Table) SetNamespace(ns string) {
t.data.Reset(ns)
}
// InNamespace checks if current namespace matches desired namespace.
func (t *Table) InNamespace(ns string) bool {
return t.data.GetNamespace() == ns && !t.data.Empty()
}
// SetRefreshRate sets model refresh duration.
func (t *Table) SetRefreshRate(d time.Duration) {
t.refreshRate = d
}
// ClusterWide checks if resource is scope for all namespaces.
func (t *Table) ClusterWide() bool {
return client.IsClusterWide(t.data.GetNamespace())
}
// Empty returns true if no model data.
func (t *Table) Empty() bool {
return t.data.Empty()
}
// RowCount returns the row count.
func (t *Table) RowCount() int {
return t.data.RowCount()
}
// Peek returns model data.
func (t *Table) Peek() *model1.TableData {
t.mx.RLock()
defer t.mx.RUnlock()
return t.data.Clone()
}
func (t *Table) updater(ctx context.Context) {
bf := backoff.NewExponentialBackOff()
bf.InitialInterval, bf.MaxElapsedTime = initRefreshRate, maxReaderRetryInterval
rate := initRefreshRate
for {
select {
case <-ctx.Done():
return
case <-time.After(rate):
rate = t.refreshRate
err := backoff.Retry(func() error {
if err := t.refresh(ctx); err != nil {
slog.Error("Refresh failed", slogs.GVR, t.gvr)
return err
}
return nil
}, backoff.WithContext(bf, ctx))
if err != nil {
slog.Warn("Reconciler exited", slogs.Error, err)
t.fireTableLoadFailed(err)
return
}
}
}
}
func (t *Table) refresh(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&t.inUpdate, 0, 1) {
slog.Debug("Dropping update...")
return nil
}
defer atomic.StoreInt32(&t.inUpdate, 0)
if err := t.reconcile(ctx); err != nil {
return err
}
data := t.Peek()
if data.RowCount() == 0 {
t.fireNoData(data)
} else {
t.fireTableChanged(data)
}
return nil
}
func (t *Table) list(ctx context.Context, a dao.Accessor) ([]runtime.Object, error) {
factory, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return nil, fmt.Errorf("expected Factory in context but got %T", ctx.Value(internal.KeyFactory))
}
a.Init(factory, t.gvr)
t.mx.RLock()
ctx = context.WithValue(ctx, internal.KeyLabels, t.labelSelector)
t.mx.RUnlock()
ns := client.CleanseNamespace(t.data.GetNamespace())
if client.IsClusterScoped(ns) {
ns = client.BlankNamespace
}
return a.List(ctx, ns)
}
func (t *Table) reconcile(ctx context.Context) error {
var (
oo []runtime.Object
err error
)
meta := resourceMeta(t.gvr)
if t.vs != nil {
meta.DAO.SetIncludeObject(true)
}
ctx = context.WithValue(ctx, internal.KeyLabels, t.labelSelector)
if t.instance == "" {
oo, err = t.list(ctx, meta.DAO)
} else {
o, e := t.Get(ctx, t.instance)
oo, err = []runtime.Object{o}, e
}
if err != nil {
return err
}
r := meta.Renderer
r.SetViewSetting(t.vs)
return t.data.Render(ctx, meta.Renderer, oo)
}
func (t *Table) fireTableChanged(data *model1.TableData) {
var ll []TableListener
t.mx.RLock()
ll = t.listeners
t.mx.RUnlock()
for _, l := range ll {
l.TableDataChanged(data)
}
}
func (t *Table) fireNoData(data *model1.TableData) {
var ll []TableListener
t.mx.RLock()
ll = t.listeners
t.mx.RUnlock()
for _, l := range ll {
l.TableNoData(data)
}
}
func (t *Table) fireTableLoadFailed(err error) {
var ll []TableListener
t.mx.RLock()
ll = t.listeners
t.mx.RUnlock()
for _, l := range ll {
l.TableLoadFailed(err)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/log_test.go | internal/model/log_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"context"
"fmt"
"log/slog"
"strconv"
"testing"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/watch"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestLogFullBuffer(t *testing.T) {
size := 4
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(size), 10*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
data := dao.NewLogItems()
for i := range 2 * size {
data.Add(dao.NewLogItemFromString("line" + strconv.Itoa(i)))
m.Append(data.Items()[i])
}
m.Notify()
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 0, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
}
func TestLogFilter(t *testing.T) {
uu := map[string]struct {
q string
e int
}{
"plain": {
q: "line-1",
e: 2,
},
"regexp": {
q: `pod-line-[1-3]{1}`,
e: 4,
},
"invert": {
q: `!pod-line-1`,
e: 8,
},
"fuzzy": {
q: `-f po-l1`,
e: 2,
},
}
size := 10
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(size), 10*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
m.Filter(u.q)
data := dao.NewLogItems()
for i := range size {
data.Add(dao.NewLogItemFromString(fmt.Sprintf("pod-line-%d", i+1)))
m.Append(data.Items()[i])
}
m.Notify()
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 1, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
assert.Len(t, v.data, u.e)
m.ClearFilter()
assert.Equal(t, 2, v.dataCalled)
assert.Equal(t, 2, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
assert.Len(t, v.data, size)
})
}
}
func TestLogStartStop(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(4), 10*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m.Start(ctx)
data := dao.NewLogItems()
data.Add(dao.NewLogItemFromString("line1"), dao.NewLogItemFromString("line2"))
for _, d := range data.Items() {
m.Append(d)
}
m.Notify()
m.Stop()
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 0, v.clearCalled)
assert.Equal(t, 1, v.errCalled)
assert.Len(t, v.data, 2)
}
func TestLogClear(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(4), 10*time.Millisecond)
m.Init(makeFactory())
assert.Equal(t, "fred", m.GetPath())
assert.Equal(t, "blee", m.GetContainer())
v := newTestView()
m.AddListener(v)
data := dao.NewLogItems()
data.Add(dao.NewLogItemFromString("line1"), dao.NewLogItemFromString("line2"))
for _, d := range data.Items() {
m.Append(d)
}
m.Notify()
m.Clear()
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 1, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
assert.Empty(t, v.data)
}
func TestLogBasic(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(2), 10*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
data := dao.NewLogItems()
data.Add(dao.NewLogItemFromString("line1"), dao.NewLogItemFromString("line2"))
m.Set(data)
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 1, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
ll := make([][]byte, data.Len())
data.Lines(0, false, ll)
assert.Equal(t, ll, v.data)
}
func TestLogAppend(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(4), 5*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
items := dao.NewLogItems()
items.Add(dao.NewLogItemFromString("blah blah"))
m.Set(items)
ll := make([][]byte, items.Len())
items.Lines(0, false, ll)
assert.Equal(t, ll, v.data)
data := dao.NewLogItems()
data.Add(
dao.NewLogItemFromString("line1"),
dao.NewLogItemFromString("line2"),
)
for _, d := range data.Items() {
m.Append(d)
}
assert.Equal(t, 1, v.dataCalled)
ll = make([][]byte, items.Len())
items.Lines(0, false, ll)
assert.Equal(t, ll, v.data)
m.Notify()
assert.Equal(t, 2, v.dataCalled)
assert.Equal(t, 1, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
}
func TestLogTimedout(t *testing.T) {
m := model.NewLog(client.NewGVR("fred"), makeLogOpts(4), 10*time.Millisecond)
m.Init(makeFactory())
v := newTestView()
m.AddListener(v)
m.Filter("line1")
data := dao.NewLogItems()
data.Add(
dao.NewLogItemFromString("line1"),
dao.NewLogItemFromString("line2"),
dao.NewLogItemFromString("line3"),
dao.NewLogItemFromString("line4"),
)
for _, d := range data.Items() {
m.Append(d)
}
m.Notify()
assert.Equal(t, 1, v.dataCalled)
assert.Equal(t, 1, v.clearCalled)
assert.Equal(t, 0, v.errCalled)
const e = "\x1b[38;5;209ml\x1b[0m\x1b[38;5;209mi\x1b[0m\x1b[38;5;209mn\x1b[0m\x1b[38;5;209me\x1b[0m\x1b[38;5;209m1\x1b[0m"
assert.Equal(t, e, string(v.data[0]))
}
func TestToggleAllContainers(t *testing.T) {
opts := makeLogOpts(1)
opts.DefaultContainer = "duh"
m := model.NewLog(client.NewGVR(""), opts, 10*time.Millisecond)
m.Init(makeFactory())
assert.Equal(t, "blee", m.GetContainer())
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
m.ToggleAllContainers(ctx)
assert.Empty(t, m.GetContainer())
m.ToggleAllContainers(ctx)
assert.Equal(t, "blee", m.GetContainer())
}
// ----------------------------------------------------------------------------
// Helpers...
func makeLogOpts(count int) *dao.LogOptions {
return &dao.LogOptions{
Path: "fred",
Container: "blee",
Lines: int64(count),
}
}
// ----------------------------------------------------------------------------
type testView struct {
data [][]byte
dataCalled int
clearCalled int
errCalled int
}
func newTestView() *testView {
return &testView{}
}
func (*testView) LogCanceled() {}
func (*testView) LogStop() {}
func (*testView) LogResume() {}
func (t *testView) LogChanged(ll [][]byte) {
t.data = ll
t.dataCalled++
}
func (t *testView) LogCleared() {
t.clearCalled++
t.data = nil
}
func (t *testView) LogFailed(error) {
t.errCalled++
}
// ----------------------------------------------------------------------------
type testFactory struct{}
var _ dao.Factory = testFactory{}
func (testFactory) Client() client.Connection {
return nil
}
func (testFactory) Get(*client.GVR, string, bool, labels.Selector) (runtime.Object, error) {
return nil, nil
}
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) WaitForCacheSync() {}
func (testFactory) Forwarders() watch.Forwarders {
return nil
}
func (testFactory) DeleteForwarder(string) {}
func makeFactory() dao.Factory {
return testFactory{}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/log_int_test.go | internal/model/log_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"strconv"
"testing"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/stretchr/testify/assert"
)
func TestUpdateLogs(t *testing.T) {
size := 100
m := NewLog(client.NewGVR("fred"), makeLogOpts(size), 10*time.Millisecond)
m.Init(makeFactory())
v := newMockLogView()
m.AddListener(v)
c := make(dao.LogChan, 2)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go m.updateLogs(ctx, c)
for i := range 2 * size {
c <- dao.NewLogItemFromString("line" + strconv.Itoa(i))
}
time.Sleep(2 * time.Second)
assert.Equal(t, size, v.count)
}
func BenchmarkUpdateLogs(b *testing.B) {
size := 100
m := NewLog(client.NewGVR("fred"), makeLogOpts(size), 10*time.Millisecond)
m.Init(makeFactory())
v := newMockLogView()
m.AddListener(v)
c := make(dao.LogChan)
go func() {
m.updateLogs(context.Background(), c)
}()
item := dao.NewLogItem([]byte("\033[0;38m2018-12-14T10:36:43.326972-07:00 \033[0;32mblee line"))
b.ReportAllocs()
b.ResetTimer()
for range b.N {
c <- item
}
close(c)
}
// Helpers...
func makeLogOpts(count int) *dao.LogOptions {
return &dao.LogOptions{
Path: "fred",
Container: "blee",
Lines: int64(count),
}
}
type mockLogView struct {
count int
}
func newMockLogView() *mockLogView {
return &mockLogView{}
}
func (t *mockLogView) LogChanged(ll [][]byte) {
t.count += len(ll)
}
func (*mockLogView) LogStop() {}
func (*mockLogView) LogCanceled() {}
func (*mockLogView) LogResume() {}
func (*mockLogView) LogCleared() {}
func (*mockLogView) LogFailed(error) {}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/fish_buff.go | internal/model/fish_buff.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import "sort"
// SuggestionListener listens for suggestions.
type SuggestionListener interface {
BuffWatcher
// SuggestionChanged notifies suggestion changes.
SuggestionChanged(text, sugg string)
}
// SuggestionFunc produces suggestions.
type SuggestionFunc func(text string) sort.StringSlice
// FishBuff represents a suggestion buffer.
type FishBuff struct {
*CmdBuff
suggestionFn SuggestionFunc
suggestions []string
suggestionIndex int
}
// NewFishBuff returns a new command buffer.
func NewFishBuff(key rune, kind BufferKind) *FishBuff {
return &FishBuff{
CmdBuff: NewCmdBuff(key, kind),
suggestionIndex: -1,
}
}
// PrevSuggestion returns the prev suggestion.
func (f *FishBuff) PrevSuggestion() (string, bool) {
if len(f.suggestions) == 0 {
return "", false
}
if f.suggestionIndex < 0 {
f.suggestionIndex = 0
} else {
f.suggestionIndex--
}
if f.suggestionIndex < 0 {
f.suggestionIndex = len(f.suggestions) - 1
}
return f.suggestions[f.suggestionIndex], true
}
// NextSuggestion returns the next suggestion.
func (f *FishBuff) NextSuggestion() (string, bool) {
if len(f.suggestions) == 0 {
return "", false
}
if f.suggestionIndex < 0 {
f.suggestionIndex = 0
} else {
f.suggestionIndex++
}
if f.suggestionIndex >= len(f.suggestions) {
f.suggestionIndex = 0
}
return f.suggestions[f.suggestionIndex], true
}
// ClearSuggestions clear out all suggestions.
func (f *FishBuff) ClearSuggestions() {
if len(f.suggestions) > 0 {
f.suggestions = f.suggestions[:0]
}
f.suggestionIndex = -1
}
// CurrentSuggestion returns the current suggestion.
func (f *FishBuff) CurrentSuggestion() (string, bool) {
if len(f.suggestions) == 0 || f.suggestionIndex < 0 || f.suggestionIndex >= len(f.suggestions) {
return "", false
}
return f.suggestions[f.suggestionIndex], true
}
// AutoSuggests returns true if model implements auto suggestions.
func (*FishBuff) AutoSuggests() bool {
return true
}
// Suggestions returns suggestions.
func (f *FishBuff) Suggestions() []string {
if f.suggestionFn != nil {
return f.suggestionFn(string(f.buff))
}
return nil
}
// SetSuggestionFn sets up suggestions.
func (f *FishBuff) SetSuggestionFn(fn SuggestionFunc) {
f.suggestionFn = fn
}
// Notify publish suggestions to all listeners.
func (f *FishBuff) Notify(_ bool) {
if f.suggestionFn == nil {
return
}
f.fireSuggestionChanged(f.suggestionFn(string(f.buff)))
}
// Add adds a new character to the buffer.
func (f *FishBuff) Add(r rune) {
f.CmdBuff.Add(r)
f.Notify(false)
}
// Delete removes the last character from the buffer.
func (f *FishBuff) Delete() {
f.CmdBuff.Delete()
f.Notify(true)
}
func (f *FishBuff) fireSuggestionChanged(ss []string) {
f.suggestions, f.suggestionIndex = ss, 0
var suggest string
if len(ss) == 0 {
f.suggestionIndex = -1
} else {
suggest = ss[f.suggestionIndex]
}
f.SetText(f.GetText(), suggest, true)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/types.go | internal/model/types.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tview"
"github.com/sahilm/fuzzy"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
const (
maxReaderRetryInterval = 2 * time.Minute
defaultReaderRefreshRate = 5 * time.Second
)
// ResourceViewerListener listens to viewing resource events.
type ResourceViewerListener interface {
ResourceChanged(lines []string, matches fuzzy.Matches)
ResourceFailed(error)
}
// ViewerToggleOpts represents a collection of viewing options.
type ViewerToggleOpts map[string]bool
// ResourceViewer represents a viewed resource.
type ResourceViewer interface {
GetPath() string
Filter(string)
GVR() *client.GVR
ClearFilter()
Peek() []string
SetOptions(context.Context, ViewerToggleOpts)
Watch(context.Context) error
Refresh(context.Context) error
AddListener(ResourceViewerListener)
RemoveListener(ResourceViewerListener)
}
// EncDecResourceViewer interface extends the ResourceViewer interface and
// adds a `Toggle` that allows the user to switch between encoded or decoded
// state of the view.
type EncDecResourceViewer interface {
ResourceViewer
Toggle()
}
// Igniter represents a runnable view.
type Igniter interface {
// Start starts a component.
Init(ctx context.Context) error
// Start starts a component.
Start()
// Stop terminates a component.
Stop()
}
// Hinter represent a menu mnemonic provider.
type Hinter interface {
// Hints returns a collection of menu hints.
Hints() MenuHints
// ExtraHints returns additional hints.
ExtraHints() map[string]string
}
// Primitive represents a UI primitive.
type Primitive interface {
tview.Primitive
// Name returns the view name.
Name() string
}
// Commander tracks prompt status.
type Commander interface {
// InCmdMode checks if prompt is active.
InCmdMode() bool
}
// Component represents a ui component.
type Component interface {
Primitive
Igniter
Hinter
Commander
Filterer
Viewer
}
// Viewer represents a resource viewer.
type Viewer interface {
// SetCommand sets the current command.
SetCommand(*cmd.Interpreter)
}
// Filterer represents a filterable component.
type Filterer interface {
// SetFilter sets the filter text.
SetFilter(string, bool)
// SetLabelSelector sets the label selector.
SetLabelSelector(labels.Selector, bool)
}
// Cruder performs crud operations.
type Cruder interface {
// List returns a collection of resources.
List(ctx context.Context, ns string) ([]runtime.Object, error)
// Get returns a resource instance.
Get(ctx context.Context, path string) (runtime.Object, error)
}
// Lister represents a resource lister.
type Lister interface {
Cruder
// Init initializes a resource.
Init(ns, gvr string, f dao.Factory)
}
// Describer represents a resource describer.
type Describer interface {
// ToYAML return resource yaml.
ToYAML(ctx context.Context, path string) (string, error)
// Describe returns a resource description.
Describe(client client.Connection, gvr, path string) (string, error)
}
// TreeRenderer represents an xray node.
type TreeRenderer interface {
Render(ctx context.Context, ns string, o any) error
}
// ResourceMeta represents model info about a resource.
type ResourceMeta struct {
DAO dao.Accessor
Renderer model1.Renderer
TreeRenderer TreeRenderer
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/cluster.go | internal/model/cluster.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"errors"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/cache"
mv1beta1 "k8s.io/metrics/pkg/apis/metrics/v1beta1"
)
const (
clusterCacheSize = 100
clusterCacheExpiry = 1 * time.Minute
clusterNodesKey = "nodes"
)
type (
// MetricsServer gather metrics information from pods and nodes.
MetricsServer interface {
MetricsService
ClusterLoad(*v1.NodeList, *mv1beta1.NodeMetricsList, *client.ClusterMetrics) error
NodesMetrics(*v1.NodeList, *mv1beta1.NodeMetricsList, client.NodesMetrics)
PodsMetrics(*mv1beta1.PodMetricsList, client.PodsMetrics)
}
// MetricsService calls the metrics server for metrics info.
MetricsService interface {
HasMetrics() bool
FetchNodesMetrics(ctx context.Context) (*mv1beta1.NodeMetricsList, error)
FetchPodsMetrics(ctx context.Context, ns string) (*mv1beta1.PodMetricsList, error)
}
// Cluster represents a kubernetes resource.
Cluster struct {
factory dao.Factory
mx MetricsServer
cache *cache.LRUExpireCache
}
)
// NewCluster returns a new cluster info resource.
func NewCluster(f dao.Factory) *Cluster {
return &Cluster{
factory: f,
mx: client.DialMetrics(f.Client()),
cache: cache.NewLRUExpireCache(clusterCacheSize),
}
}
// Version returns the current K8s cluster version.
func (c *Cluster) Version() string {
info, err := c.factory.Client().ServerVersion()
if err != nil || info == nil {
return client.NA
}
return info.GitVersion
}
// ContextName returns the context name.
func (c *Cluster) ContextName() string {
n, err := c.factory.Client().Config().CurrentContextName()
if err != nil {
return client.NA
}
return n
}
// ClusterName returns the context name.
func (c *Cluster) ClusterName() string {
n, err := c.factory.Client().Config().CurrentClusterName()
if err != nil {
return client.NA
}
return n
}
// UserName returns the user name.
func (c *Cluster) UserName() string {
n, err := c.factory.Client().Config().CurrentUserName()
if err != nil {
return client.NA
}
return n
}
// Metrics gathers node level metrics and compute utilization percentages.
func (c *Cluster) Metrics(ctx context.Context, mx *client.ClusterMetrics) error {
var (
nn *v1.NodeList
err error
)
if v, ok := c.cache.Get(clusterNodesKey); ok {
if nl, ok := v.(*v1.NodeList); ok {
nn = nl
}
} else {
if nn, err = dao.FetchNodes(ctx, c.factory, ""); err != nil {
return err
}
}
if nn == nil {
return errors.New("unable to fetch nodes list")
}
if len(nn.Items) > 0 {
c.cache.Add(clusterNodesKey, nn, clusterCacheExpiry)
}
var nmx *mv1beta1.NodeMetricsList
if nmx, err = c.mx.FetchNodesMetrics(ctx); err != nil {
return err
}
return c.mx.ClusterLoad(nn, nmx, mx)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/flash.go | internal/model/flash.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"time"
"github.com/derailed/k9s/internal/slogs"
)
const (
// DefaultFlashDelay sets the flash clear delay.
DefaultFlashDelay = 6 * time.Second
// FlashInfo represents an info message.
FlashInfo FlashLevel = iota
// FlashWarn represents an warning message.
FlashWarn
// FlashErr represents an error message.
FlashErr
)
// LevelMessage tracks a message and severity.
type LevelMessage struct {
Level FlashLevel
Text string
}
func newClearMessage() LevelMessage {
return LevelMessage{}
}
// IsClear returns true if message is empty.
func (l LevelMessage) IsClear() bool {
return l.Text == ""
}
// FlashLevel represents flash message severity.
type FlashLevel int
// FlashChan represents a flash event channel.
type FlashChan chan LevelMessage
// FlashListener represents a text model listener.
type FlashListener interface {
// FlashChanged notifies the model changed.
FlashChanged(FlashLevel, string)
// FlashCleared notifies when the filter changed.
FlashCleared()
}
// Flash represents a flash message model.
type Flash struct {
msg LevelMessage
cancel context.CancelFunc
delay time.Duration
msgChan chan LevelMessage
}
// NewFlash returns a new instance.
func NewFlash(dur time.Duration) *Flash {
return &Flash{
delay: dur,
msgChan: make(FlashChan, 3),
}
}
// Channel returns the flash channel.
func (f *Flash) Channel() FlashChan {
return f.msgChan
}
// Info displays an info flash message.
func (f *Flash) Info(msg string) {
f.SetMessage(FlashInfo, msg)
}
// Infof displays a formatted info flash message.
func (f *Flash) Infof(fmat string, args ...any) {
f.Info(fmt.Sprintf(fmat, args...))
}
// Warn displays a warning flash message.
func (f *Flash) Warn(msg string) {
slog.Warn(msg)
f.SetMessage(FlashWarn, msg)
}
// Warnf displays a formatted warning flash message.
func (f *Flash) Warnf(fmat string, args ...any) {
f.Warn(fmt.Sprintf(fmat, args...))
}
// Err displays an error flash message.
func (f *Flash) Err(err error) {
slog.Error("Flash error", slogs.Error, err)
f.SetMessage(FlashErr, err.Error())
}
// Errf displays a formatted error flash message.
func (f *Flash) Errf(fmat string, args ...any) {
var err error
for _, a := range args {
if e, ok := a.(error); ok {
err = e
}
}
slog.Error("Flash error",
slogs.Error, err,
slogs.Message, fmt.Sprintf(fmat, args...),
)
f.SetMessage(FlashErr, fmt.Sprintf(fmat, args...))
}
// Clear clears the flash message.
func (f *Flash) Clear() {
f.fireCleared()
}
// SetMessage sets the flash level message.
func (f *Flash) SetMessage(level FlashLevel, msg string) {
if f.cancel != nil {
f.cancel()
f.cancel = nil
}
f.setLevelMessage(LevelMessage{Level: level, Text: msg})
f.fireFlashChanged()
ctx := context.Background()
ctx, f.cancel = context.WithCancel(ctx)
go f.refresh(ctx)
}
func (f *Flash) refresh(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case <-time.After(f.delay):
f.fireCleared()
return
}
}
}
func (f *Flash) setLevelMessage(msg LevelMessage) {
f.msg = msg
}
func (f *Flash) fireFlashChanged() {
f.msgChan <- f.msg
}
func (f *Flash) fireCleared() {
f.msgChan <- newClearMessage()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/menu_hint.go | internal/model/menu_hint.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"strconv"
)
// MenuHint represents keyboard mnemonic.
type MenuHint struct {
Mnemonic string
Description string
Visible bool
}
// IsBlank checks if menu hint is a place holder.
func (m MenuHint) IsBlank() bool {
return m.Mnemonic == "" && m.Description == "" && !m.Visible
}
// String returns a string representation.
func (m MenuHint) String() string {
return m.Mnemonic
}
// MenuHints represents a collection of hints.
type MenuHints []MenuHint
// Len returns the hints length.
func (h MenuHints) Len() int {
return len(h)
}
// Swap swaps to elements.
func (h MenuHints) Swap(i, j int) {
h[i], h[j] = h[j], h[i]
}
// Less returns true if first hint is less than second.
func (h MenuHints) Less(i, j int) bool {
n, err1 := strconv.Atoi(h[i].Mnemonic)
m, err2 := strconv.Atoi(h[j].Mnemonic)
if err1 == nil && err2 == nil {
return n < m
}
if err1 == nil && err2 != nil {
return true
}
if err1 != nil && err2 == nil {
return false
}
return h[i].Description < h[j].Description
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/yaml.go | internal/model/yaml.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"reflect"
"strings"
"sync/atomic"
"time"
backoff "github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/sahilm/fuzzy"
)
// ManagedFieldsOpts tracks managed fields.
const ManagedFieldsOpts = "ManagedFields"
// YAML tracks yaml resource representations.
type YAML struct {
gvr *client.GVR
inUpdate int32
path string
query string
lines []string
listeners []ResourceViewerListener
options ViewerToggleOpts
decode bool
}
// NewYAML return a new yaml resource model.
func NewYAML(gvr *client.GVR, path string) *YAML {
return &YAML{
gvr: gvr,
path: path,
}
}
// GVR returns the resource gvr.
func (y *YAML) GVR() *client.GVR {
return y.gvr
}
// GetPath returns the active resource path.
func (y *YAML) GetPath() string {
return y.path
}
// SetOptions toggle model options.
func (y *YAML) SetOptions(ctx context.Context, opts ViewerToggleOpts) {
y.options = opts
if err := y.refresh(ctx); err != nil {
y.fireResourceFailed(err)
}
}
// Filter filters the model.
func (y *YAML) Filter(q string) {
y.query = q
y.filterChanged(y.lines)
}
func (y *YAML) filterChanged(lines []string) {
y.fireResourceChanged(lines, y.filter(y.query, lines))
}
func (y *YAML) filter(q string, lines []string) fuzzy.Matches {
if q == "" {
return nil
}
if f, ok := internal.IsFuzzySelector(q); ok {
return y.fuzzyFilter(strings.TrimSpace(f), lines)
}
return rxFilter(q, lines)
}
func (*YAML) fuzzyFilter(q string, lines []string) fuzzy.Matches {
return fuzzy.Find(q, lines)
}
func (y *YAML) fireResourceChanged(lines []string, matches fuzzy.Matches) {
for _, l := range y.listeners {
l.ResourceChanged(lines, matches)
}
}
func (y *YAML) fireResourceFailed(err error) {
for _, l := range y.listeners {
l.ResourceFailed(err)
}
}
// ClearFilter clear out the filter.
func (y *YAML) ClearFilter() {
y.query = ""
}
// Peek returns the current model data.
func (y *YAML) Peek() []string {
return y.lines
}
// Refresh updates model data.
func (y *YAML) Refresh(ctx context.Context) error {
return y.refresh(ctx)
}
// Watch watches for YAML changes.
func (y *YAML) Watch(ctx context.Context) error {
if err := y.refresh(ctx); err != nil {
return err
}
go y.updater(ctx)
return nil
}
func (y *YAML) updater(ctx context.Context) {
defer slog.Debug("YAML canceled", slogs.GVR, y.gvr)
backOff := NewExpBackOff(ctx, defaultReaderRefreshRate, maxReaderRetryInterval)
delay := defaultReaderRefreshRate
for {
select {
case <-ctx.Done():
return
case <-time.After(delay):
if err := y.refresh(ctx); err != nil {
y.fireResourceFailed(err)
if delay = backOff.NextBackOff(); delay == backoff.Stop {
slog.Error("YAML gave up!", slogs.Error, err)
return
}
} else {
backOff.Reset()
delay = defaultReaderRefreshRate
}
}
}
}
func (y *YAML) refresh(ctx context.Context) error {
if !atomic.CompareAndSwapInt32(&y.inUpdate, 0, 1) {
slog.Debug("Dropping update...", slogs.GVR, y.gvr)
return nil
}
defer atomic.StoreInt32(&y.inUpdate, 0)
if err := y.reconcile(ctx); err != nil {
return err
}
return nil
}
func (y *YAML) reconcile(ctx context.Context) error {
s, err := y.ToYAML(ctx, y.gvr, y.path, y.options[ManagedFieldsOpts])
if err != nil {
return err
}
lines := strings.Split(s, "\n")
if reflect.DeepEqual(lines, y.lines) {
return nil
}
y.lines = lines
y.fireResourceChanged(y.lines, y.filter(y.query, y.lines))
return nil
}
// AddListener adds a new model listener.
func (y *YAML) AddListener(l ResourceViewerListener) {
y.listeners = append(y.listeners, l)
}
// RemoveListener delete a listener from the list.
func (y *YAML) RemoveListener(l ResourceViewerListener) {
victim := -1
for i, lis := range y.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
y.listeners = append(y.listeners[:victim], y.listeners[victim+1:]...)
}
}
// ToYAML returns a resource yaml.
func (y *YAML) ToYAML(ctx context.Context, gvr *client.GVR, path string, showManaged bool) (string, error) {
meta, err := getMeta(ctx, gvr)
if err != nil {
return "", err
}
desc, ok := meta.DAO.(dao.Describer)
if !ok {
return "", fmt.Errorf("no describer for %q", meta.DAO.GVR())
}
if desc, ok := meta.DAO.(*dao.Secret); ok {
desc.SetDecodeData(y.decode)
}
return desc.ToYAML(path, showManaged)
}
// Toggle toggles the decode flag.
func (y *YAML) Toggle() {
y.decode = !y.decode
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/helpers_test.go | internal/model/helpers_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestMetaFQN(t *testing.T) {
uu := map[string]struct {
meta metav1.ObjectMeta
e string
}{
"all_namespaces": {
meta: metav1.ObjectMeta{Name: "fred"},
e: "fred",
},
"namespaced": {
meta: metav1.ObjectMeta{Name: "fred", Namespace: "blee"},
e: "blee/fred",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, model.MetaFQN(&u.meta))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/semver_test.go | internal/model/semver_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestNewSemVer(t *testing.T) {
uu := map[string]struct {
version string
major, minor, patch int
}{
"plain": {
version: "0.11.1",
major: 0,
minor: 11,
patch: 1,
},
"normalized": {
version: "v10.11.12",
major: 10,
minor: 11,
patch: 12,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
v := model.NewSemVer(u.version)
assert.Equal(t, u.major, v.Major)
assert.Equal(t, u.minor, v.Minor)
assert.Equal(t, u.patch, v.Patch)
})
}
}
func TestSemVerIsCurrent(t *testing.T) {
uu := map[string]struct {
current, latest string
e bool
}{
"same": {
current: "0.11.1",
latest: "0.11.1",
e: true,
},
"older": {
current: "v10.11.12",
latest: "v10.11.13",
},
"newer": {
current: "10.11.13",
latest: "10.11.12",
e: true,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
v1, v2 := model.NewSemVer(u.current), model.NewSemVer(u.latest)
assert.Equal(t, u.e, v1.IsCurrent(v2))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/fish_buff_test.go | internal/model/fish_buff_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"sort"
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestFishAdd(t *testing.T) {
m := mockSuggestionListener{}
f := model.NewFishBuff(' ', model.FilterBuffer)
f.AddListener(&m)
f.SetSuggestionFn(func(string) sort.StringSlice {
return sort.StringSlice{"blee", "brew"}
})
f.Add('b')
f.SetActive(true)
assert.True(t, m.active)
assert.Equal(t, 1, m.changeCount)
assert.Equal(t, 1, m.suggCount)
assert.Equal(t, "blee", m.suggestion)
c, ok := f.CurrentSuggestion()
assert.True(t, ok)
assert.Equal(t, "blee", c)
c, ok = f.NextSuggestion()
assert.True(t, ok)
assert.Equal(t, "brew", c)
c, ok = f.PrevSuggestion()
assert.True(t, ok)
assert.Equal(t, "blee", c)
}
func TestFishDelete(t *testing.T) {
m := mockSuggestionListener{}
f := model.NewFishBuff(' ', model.FilterBuffer)
f.AddListener(&m)
f.SetSuggestionFn(func(string) sort.StringSlice {
return sort.StringSlice{"blee", "duh"}
})
f.Add('a')
f.Delete()
f.SetActive(true)
assert.Equal(t, 2, m.changeCount)
assert.Equal(t, 3, m.suggCount)
assert.True(t, m.active)
assert.Equal(t, "blee", m.suggestion)
c, ok := f.CurrentSuggestion()
assert.True(t, ok)
assert.Equal(t, "blee", c)
c, ok = f.NextSuggestion()
assert.True(t, ok)
assert.Equal(t, "duh", c)
c, ok = f.PrevSuggestion()
assert.True(t, ok)
assert.Equal(t, "blee", c)
}
// Helpers...
type mockSuggestionListener struct {
changeCount, suggCount int
suggestion, text string
active bool
}
func (m *mockSuggestionListener) BufferChanged(_, _ string) {
m.changeCount++
}
func (m *mockSuggestionListener) BufferCompleted(text, suggest string) {
if m.suggestion != suggest {
m.suggCount++
}
m.text, m.suggestion = text, suggest
}
func (m *mockSuggestionListener) BufferActive(state bool, _ model.BufferKind) {
m.active = state
}
func (m *mockSuggestionListener) SuggestionChanged(_, sugg string) {
m.suggestion = sugg
m.suggCount++
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/values.go | internal/model/values.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"strings"
"sync/atomic"
"time"
backoff "github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/sahilm/fuzzy"
)
// Values tracks Helm values representations.
type Values struct {
factory dao.Factory
gvr *client.GVR
inUpdate int32
path string
query string
lines []string
allValues bool
listeners []ResourceViewerListener
options ViewerToggleOpts
}
// NewValues return a new Helm values resource model.
func NewValues(gvr *client.GVR, path string) *Values {
return &Values{
gvr: gvr,
path: path,
allValues: false,
}
}
// Init initializes the model.
func (v *Values) Init(f dao.Factory) error {
v.factory = f
var err error
v.lines, err = v.getValues()
return err
}
func (v *Values) getValues() ([]string, error) {
accessor, err := dao.AccessorFor(v.factory, v.gvr)
if err != nil {
return nil, err
}
valuer, ok := accessor.(dao.Valuer)
if !ok {
return nil, fmt.Errorf("resource %s is not Valuer", v.gvr)
}
values, err := valuer.GetValues(v.path, v.allValues)
if err != nil {
return nil, err
}
return strings.Split(string(values), "\n"), nil
}
// GVR returns the resource gvr.
func (v *Values) GVR() *client.GVR {
return v.gvr
}
// ToggleValues toggles between user supplied values and computed values.
func (v *Values) ToggleValues() error {
v.allValues = !v.allValues
lines, err := v.getValues()
if err != nil {
return err
}
v.lines = lines
return nil
}
// GetPath returns the active resource path.
func (v *Values) GetPath() string {
return v.path
}
// SetOptions toggle model options.
func (v *Values) SetOptions(ctx context.Context, opts ViewerToggleOpts) {
v.options = opts
if err := v.refresh(ctx); err != nil {
v.fireResourceFailed(err)
}
}
// Filter filters the model.
func (v *Values) Filter(q string) {
v.query = q
v.filterChanged(v.lines)
}
func (v *Values) filterChanged(lines []string) {
v.fireResourceChanged(lines, v.filter(v.query, lines))
}
func (v *Values) filter(q string, lines []string) fuzzy.Matches {
if q == "" {
return nil
}
if f, ok := internal.IsFuzzySelector(q); ok {
return v.fuzzyFilter(strings.TrimSpace(f), lines)
}
return rxFilter(q, lines)
}
func (*Values) fuzzyFilter(q string, lines []string) fuzzy.Matches {
return fuzzy.Find(q, lines)
}
func (v *Values) fireResourceChanged(lines []string, matches fuzzy.Matches) {
for _, l := range v.listeners {
l.ResourceChanged(lines, matches)
}
}
func (v *Values) fireResourceFailed(err error) {
for _, l := range v.listeners {
l.ResourceFailed(err)
}
}
// ClearFilter clear out the filter.
func (v *Values) ClearFilter() {
v.query = ""
}
// Peek returns the current model data.
func (v *Values) Peek() []string {
return v.lines
}
// Refresh updates model data.
func (v *Values) Refresh(ctx context.Context) error {
return v.refresh(ctx)
}
// Watch watches for Values changes.
func (v *Values) Watch(ctx context.Context) error {
if err := v.refresh(ctx); err != nil {
return err
}
go v.updater(ctx)
return nil
}
func (v *Values) updater(ctx context.Context) {
defer slog.Debug("YAML canceled", slogs.GVR, v.gvr)
backOff := NewExpBackOff(ctx, defaultReaderRefreshRate, maxReaderRetryInterval)
delay := defaultReaderRefreshRate
for {
select {
case <-ctx.Done():
return
case <-time.After(delay):
if err := v.refresh(ctx); err != nil {
v.fireResourceFailed(err)
if delay = backOff.NextBackOff(); delay == backoff.Stop {
slog.Error("Giving up retrieving chart values", slogs.Error, err)
return
}
} else {
backOff.Reset()
delay = defaultReaderRefreshRate
}
}
}
}
func (v *Values) refresh(context.Context) error {
if !atomic.CompareAndSwapInt32(&v.inUpdate, 0, 1) {
slog.Debug("Dropping update...")
return fmt.Errorf("reconcile in progress. Dropping update")
}
defer atomic.StoreInt32(&v.inUpdate, 0)
v.reconcile()
return nil
}
func (v *Values) reconcile() {
v.fireResourceChanged(v.lines, v.filter(v.query, v.lines))
}
// AddListener adds a new model listener.
func (v *Values) AddListener(l ResourceViewerListener) {
v.listeners = append(v.listeners, l)
}
// RemoveListener delete a listener from the list.
func (v *Values) RemoveListener(l ResourceViewerListener) {
victim := -1
for i, lis := range v.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
v.listeners = append(v.listeners[:victim], v.listeners[victim+1:]...)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/stack.go | internal/model/stack.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"fmt"
"log/slog"
"sync"
"github.com/derailed/k9s/internal/slogs"
)
const (
// StackPush denotes an add on the stack.
StackPush StackAction = 1 << iota
// StackPop denotes a delete on the stack.
StackPop
)
// StackAction represents an action on the stack.
type StackAction int
// StackEvent represents an operation on a view stack.
type StackEvent struct {
// Kind represents the event condition.
Action StackAction
// Item represents the targeted item.
Component Component
}
// StackListener represents a stack listener.
type StackListener interface {
// StackPushed indicates a new item was added.
StackPushed(Component)
// StackPopped indicates an item was deleted
StackPopped(old, new Component)
// StackTop indicates the top of the stack
StackTop(Component)
}
// Stack represents a stacks of components.
type Stack struct {
components []Component
listeners []StackListener
mx sync.RWMutex
}
// NewStack returns a new initialized stack.
func NewStack() *Stack {
return &Stack{}
}
// Flatten returns a string representation of the component stack.
func (s *Stack) Flatten() []string {
s.mx.RLock()
defer s.mx.RUnlock()
ss := make([]string, len(s.components))
for i, c := range s.components {
ss[i] = c.Name()
}
return ss
}
// RemoveListener removes a listener.
func (s *Stack) RemoveListener(l StackListener) {
victim := -1
for i, lis := range s.listeners {
if lis == l {
victim = i
break
}
}
if victim == -1 {
return
}
s.listeners = append(s.listeners[:victim], s.listeners[victim+1:]...)
}
// AddListener registers a stack listener.
func (s *Stack) AddListener(l StackListener) {
s.listeners = append(s.listeners, l)
if !s.Empty() {
l.StackTop(s.Top())
}
}
// Push adds a new item.
func (s *Stack) Push(c Component) {
if top := s.Top(); top != nil {
top.Stop()
}
s.mx.Lock()
s.components = append(s.components, c)
s.mx.Unlock()
s.notify(StackPush, c)
}
// Pop removed the top item and returns it.
func (s *Stack) Pop() (Component, bool) {
if s.Empty() {
return nil, false
}
var c Component
s.mx.Lock()
c = s.components[len(s.components)-1]
c.Stop()
s.components = s.components[:len(s.components)-1]
s.mx.Unlock()
s.notify(StackPop, c)
return c, true
}
// Peek returns stack state.
func (s *Stack) Peek() []Component {
s.mx.RLock()
defer s.mx.RUnlock()
return s.components
}
// Clear clear out the stack using pops.
func (s *Stack) Clear() {
for range s.components {
s.Pop()
}
}
// Empty returns true if the stack is empty.
func (s *Stack) Empty() bool {
s.mx.RLock()
defer s.mx.RUnlock()
return len(s.components) == 0
}
// IsLast indicates if stack only has one item left.
func (s *Stack) IsLast() bool {
return len(s.components) == 1
}
// Previous returns the previous component if any.
func (s *Stack) Previous() Component {
if s.Empty() {
return nil
}
if s.IsLast() {
return s.Top()
}
return s.components[len(s.components)-2]
}
// Top returns the top most item or nil if the stack is empty.
func (s *Stack) Top() Component {
if s.Empty() {
return nil
}
s.mx.RLock()
defer s.mx.RUnlock()
return s.components[len(s.components)-1]
}
func (s *Stack) notify(a StackAction, c Component) {
for _, l := range s.listeners {
switch a {
case StackPush:
l.StackPushed(c)
case StackPop:
l.StackPopped(c, s.Top())
}
}
}
// ----------------------------------------------------------------------------
// Helpers...
// Dump prints out the stack.
func (s *Stack) Dump() {
slog.Debug("Stack Dump", slogs.Stack, fmt.Sprintf("%p", s))
for i, c := range s.components {
slog.Debug(fmt.Sprintf("%d -- %s -- %#v", i, c.Name(), c))
}
slog.Debug("------------------")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/log.go | internal/model/log.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"log/slog"
"sync"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/color"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
)
// LogsListener represents a log model listener.
type LogsListener interface {
// LogChanged notifies the model changed.
LogChanged([][]byte)
// LogCleared indicates logs are cleared.
LogCleared()
// LogFailed indicates a log failure.
LogFailed(error)
// LogStop indicates logging was canceled.
LogStop()
// LogResume indicates logging has resumed.
LogResume()
// LogCanceled indicates no more logs will come.
LogCanceled()
}
// Log represents a resource logger.
type Log struct {
factory dao.Factory
lines *dao.LogItems
listeners []LogsListener
gvr *client.GVR
logOptions *dao.LogOptions
cancelFn context.CancelFunc
mx sync.RWMutex
filter string
lastSent int
flushTimeout time.Duration
}
// NewLog returns a new model.
func NewLog(gvr *client.GVR, opts *dao.LogOptions, flushTimeout time.Duration) *Log {
return &Log{
gvr: gvr,
logOptions: opts,
lines: dao.NewLogItems(),
flushTimeout: flushTimeout,
}
}
func (l *Log) GVR() *client.GVR {
return l.gvr
}
func (l *Log) LogOptions() *dao.LogOptions {
return l.logOptions
}
// SinceSeconds returns since seconds option.
func (l *Log) SinceSeconds() int64 {
l.mx.RLock()
defer l.mx.RUnlock()
return l.logOptions.SinceSeconds
}
// IsHead returns log head option.
func (l *Log) IsHead() bool {
l.mx.RLock()
defer l.mx.RUnlock()
return l.logOptions.Head
}
// ToggleShowTimestamp toggles to logs timestamps.
func (l *Log) ToggleShowTimestamp(b bool) {
l.logOptions.ShowTimestamp = b
l.Refresh()
}
func (l *Log) Head(ctx context.Context) {
l.mx.Lock()
l.logOptions.Head = true
l.mx.Unlock()
l.Restart(ctx)
}
// SetSinceSeconds sets the logs retrieval time.
func (l *Log) SetSinceSeconds(ctx context.Context, i int64) {
l.logOptions.SinceSeconds, l.logOptions.Head = i, false
l.Restart(ctx)
}
// Configure sets logger configuration.
func (l *Log) Configure(opts config.Logger) {
l.logOptions.Lines = opts.TailCount
l.logOptions.SinceSeconds = opts.SinceSeconds
}
// GetPath returns resource path.
func (l *Log) GetPath() string {
return l.logOptions.Path
}
// GetContainer returns the resource container if any or "" otherwise.
func (l *Log) GetContainer() string {
return l.logOptions.Container
}
// HasDefaultContainer returns true if the pod has a default container, false otherwise.
func (l *Log) HasDefaultContainer() bool {
return l.logOptions.DefaultContainer != ""
}
// Init initializes the model.
func (l *Log) Init(f dao.Factory) {
l.factory = f
}
// Clear the logs.
func (l *Log) Clear() {
l.mx.Lock()
l.lines.Clear()
l.lastSent = 0
l.mx.Unlock()
l.fireLogCleared()
}
// Refresh refreshes the logs.
func (l *Log) Refresh() {
l.fireLogCleared()
ll := make([][]byte, l.lines.Len())
l.lines.Render(0, l.logOptions.ShowTimestamp, ll)
l.fireLogChanged(ll)
}
// Restart restarts the logger.
func (l *Log) Restart(ctx context.Context) {
l.Stop()
l.Clear()
l.fireLogResume()
l.Start(ctx)
}
// Start starts logging.
func (l *Log) Start(ctx context.Context) {
if err := l.load(ctx); err != nil {
slog.Error("Tail logs failed!", slogs.Error, err)
l.fireLogError(err)
}
}
// Stop terminates logging.
func (l *Log) Stop() {
l.cancel()
}
// Set sets the log lines (for testing only!)
func (l *Log) Set(lines *dao.LogItems) {
l.mx.Lock()
l.lines.Merge(lines)
l.mx.Unlock()
l.fireLogCleared()
ll := make([][]byte, l.lines.Len())
l.lines.Render(0, l.logOptions.ShowTimestamp, ll)
l.fireLogChanged(ll)
}
// ClearFilter resets the log filter if any.
func (l *Log) ClearFilter() {
l.mx.Lock()
l.filter = ""
l.mx.Unlock()
l.fireLogCleared()
ll := make([][]byte, l.lines.Len())
l.lines.Render(0, l.logOptions.ShowTimestamp, ll)
l.fireLogChanged(ll)
}
// Filter filters the model using either fuzzy or regexp.
func (l *Log) Filter(q string) {
l.mx.Lock()
l.filter = q
l.mx.Unlock()
l.fireLogCleared()
l.fireLogBuffChanged(0)
}
func (l *Log) cancel() {
l.mx.Lock()
defer l.mx.Unlock()
if l.cancelFn != nil {
l.cancelFn()
l.cancelFn = nil
}
}
func (l *Log) load(ctx context.Context) error {
accessor, err := dao.AccessorFor(l.factory, l.gvr)
if err != nil {
return err
}
loggable, ok := accessor.(dao.Loggable)
if !ok {
return fmt.Errorf("resource %s is not Loggable", l.gvr)
}
l.cancel()
ctx = context.WithValue(ctx, internal.KeyFactory, l.factory)
ctx, l.cancelFn = context.WithCancel(ctx)
cc, err := loggable.TailLogs(ctx, l.logOptions)
if err != nil {
slog.Error("Tail logs failed", slogs.Error, err)
l.cancel()
l.fireLogError(err)
}
for _, c := range cc {
go l.updateLogs(ctx, c)
}
return nil
}
// Append adds a log line.
func (l *Log) Append(line *dao.LogItem) {
if line == nil || line.IsEmpty() {
return
}
l.mx.Lock()
defer l.mx.Unlock()
l.logOptions.SinceTime = line.GetTimestamp()
if l.lines.Len() < int(l.logOptions.Lines) {
l.lines.Add(line)
return
}
l.lines.Shift(line)
l.lastSent--
if l.lastSent < 0 {
l.lastSent = 0
}
}
// Notify fires of notifications to the listeners.
func (l *Log) Notify() {
l.mx.Lock()
defer l.mx.Unlock()
if l.lastSent < l.lines.Len() {
l.fireLogBuffChanged(l.lastSent)
l.lastSent = l.lines.Len()
}
}
// ToggleAllContainers toggles to show all containers logs.
func (l *Log) ToggleAllContainers(ctx context.Context) {
l.logOptions.ToggleAllContainers()
l.Restart(ctx)
}
func (l *Log) updateLogs(ctx context.Context, c dao.LogChan) {
for {
select {
case item, ok := <-c:
if !ok {
l.Append(item)
l.Notify()
return
}
if item == dao.ItemEOF {
l.fireCanceled()
return
}
l.Append(item)
var overflow bool
l.mx.RLock()
overflow = int64(l.lines.Len()-l.lastSent) > l.logOptions.Lines
l.mx.RUnlock()
if overflow {
l.Notify()
}
case <-time.After(l.flushTimeout):
l.Notify()
case <-ctx.Done():
return
}
}
}
// AddListener adds a new model listener.
func (l *Log) AddListener(listener LogsListener) {
l.mx.Lock()
defer l.mx.Unlock()
l.listeners = append(l.listeners, listener)
}
// RemoveListener delete a listener from the list.
func (l *Log) RemoveListener(listener LogsListener) {
l.mx.Lock()
defer l.mx.Unlock()
victim := -1
for i, lis := range l.listeners {
if lis == listener {
victim = i
break
}
}
if victim >= 0 {
l.listeners = append(l.listeners[:victim], l.listeners[victim+1:]...)
}
}
func (l *Log) applyFilter(index int, q string) ([][]byte, error) {
if q == "" {
return nil, nil
}
matches, indices, err := l.lines.Filter(index, q, l.logOptions.ShowTimestamp)
if err != nil {
return nil, err
}
// No filter!
if matches == nil {
ll := make([][]byte, l.lines.Len())
l.lines.Render(index, l.logOptions.ShowTimestamp, ll)
return ll, nil
}
// Blank filter
if len(matches) == 0 {
return nil, nil
}
filtered := make([][]byte, 0, len(matches))
ll := make([][]byte, l.lines.Len())
l.lines.Lines(index, l.logOptions.ShowTimestamp, ll)
for i, idx := range matches {
filtered = append(filtered, color.Highlight(ll[idx], indices[i], 209))
}
return filtered, nil
}
func (l *Log) fireLogBuffChanged(index int) {
ll := make([][]byte, l.lines.Len()-index)
if l.filter == "" {
l.lines.Render(index, l.logOptions.ShowTimestamp, ll)
} else {
ff, err := l.applyFilter(index, l.filter)
if err != nil {
l.fireLogError(err)
return
}
ll = ff
}
if len(ll) > 0 {
l.fireLogChanged(ll)
}
}
func (l *Log) fireLogResume() {
for _, lis := range l.listeners {
lis.LogResume()
}
}
func (l *Log) fireCanceled() {
for _, lis := range l.listeners {
lis.LogCanceled()
}
}
func (l *Log) fireLogError(err error) {
for _, lis := range l.listeners {
lis.LogFailed(err)
}
}
func (l *Log) fireLogChanged(lines [][]byte) {
for _, lis := range l.listeners {
lis.LogChanged(lines)
}
}
func (l *Log) fireLogCleared() {
var ll []LogsListener
l.mx.RLock()
ll = l.listeners
l.mx.RUnlock()
for _, lis := range ll {
lis.LogCleared()
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/history.go | internal/model/history.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"log/slog"
"strings"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/view/cmd"
)
// MaxHistory tracks max command history.
const MaxHistory = 20
// History represents a command history.
type History struct {
commands []string
limit int
currentIdx int
}
// NewHistory returns a new instance.
func NewHistory(limit int) *History {
return &History{
limit: limit,
currentIdx: -1,
}
}
// List returns the command history.
func (h *History) List() []string {
return h.commands
}
// Top returns the last command in the history if present.
func (h *History) Top() (string, bool) {
h.currentIdx = len(h.commands) - 1
return h.at(h.currentIdx)
}
func (h *History) SwitchNS(ns string) {
c, ok := h.Top()
if !ok {
return
}
i := cmd.NewInterpreter(c)
i.SwitchNS(ns)
line := i.GetLine()
if _, ok := i.NSArg(); ok && line != c {
h.Push(line)
slog.Debug("History (switch-ns)", slogs.Stack, strings.Join(h.List(), "|"))
return
}
}
// Last returns the nth command prior to last.
func (h *History) Last(idx int) (string, bool) {
h.currentIdx = len(h.commands) - idx
return h.at(h.currentIdx)
}
func (h *History) at(idx int) (string, bool) {
if idx < 0 || idx >= len(h.commands) {
return "", false
}
return h.commands[idx], true
}
// Back moves the history position index back by one.
func (h *History) Back() (string, bool) {
if h.Empty() || h.currentIdx <= 0 {
return "", false
}
h.currentIdx--
return h.at(h.currentIdx)
}
// Forward moves the history position index forward by one
func (h *History) Forward() (string, bool) {
h.currentIdx++
if h.Empty() || h.currentIdx >= len(h.commands) {
return "", false
}
return h.at(h.currentIdx)
}
// Pop removes the single most recent history item
// and returns a bool if the list changed.
func (h *History) Pop() bool {
return h.popN(1)
}
// PopN removes the N most recent history item
// and returns a bool if the list changed.
// Argument specifies how many to remove from the history
func (h *History) popN(n int) bool {
pop := len(h.commands) - n
if h.Empty() || pop < 0 {
return false
}
h.commands = h.commands[:pop]
h.currentIdx = len(h.commands) - 1
return true
}
// Push adds a new item.
func (h *History) Push(c string) {
if c == "" || len(h.commands) >= h.limit {
return
}
if t, ok := h.Top(); ok && t == c {
return
}
if h.currentIdx < len(h.commands)-1 {
h.commands = h.commands[:h.currentIdx+1]
}
h.commands = append(h.commands, strings.ToLower(c))
h.currentIdx = len(h.commands) - 1
}
// Clear clears out the stack.
func (h *History) Clear() {
h.commands = nil
h.currentIdx = -1
}
// Empty returns true if no history.
func (h *History) Empty() bool {
return len(h.commands) == 0
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/pulse_health.go | internal/model/pulse_health.go | package model
import (
"context"
"log/slog"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
)
const pulseRate = 10 * time.Second
type HealthPoint struct {
GVR *client.GVR
Total, Faults int
}
type GVRs []*client.GVR
var PulseGVRs = client.GVRs{
client.NodeGVR,
client.NsGVR,
client.SvcGVR,
client.EvGVR,
client.PodGVR,
client.DpGVR,
client.StsGVR,
client.DsGVR,
client.JobGVR,
client.CjGVR,
client.PvGVR,
client.PvcGVR,
client.HpaGVR,
client.IngGVR,
client.NpGVR,
client.SaGVR,
}
func (g GVRs) First() *client.GVR {
return g[0]
}
func (g GVRs) Last() *client.GVR {
return g[len(g)-1]
}
func (g GVRs) Index(gvr *client.GVR) int {
for i := range g {
if g[i] == gvr {
return i
}
}
return -1
}
// PulseHealth tracks resources health.
type PulseHealth struct {
factory dao.Factory
}
// NewPulseHealth returns a new instance.
func NewPulseHealth(f dao.Factory) *PulseHealth {
return &PulseHealth{factory: f}
}
func (h *PulseHealth) Watch(ctx context.Context, ns string) HealthChan {
c := make(HealthChan, 2)
ctx = context.WithValue(ctx, internal.KeyWithMetrics, false)
go func(ctx context.Context, ns string, c HealthChan) {
if err := h.checkPulse(ctx, ns, c); err != nil {
slog.Error("Pulse check failed", slogs.Error, err)
}
for {
select {
case <-ctx.Done():
close(c)
return
case <-time.After(pulseRate):
if err := h.checkPulse(ctx, ns, c); err != nil {
slog.Error("Pulse check failed", slogs.Error, err)
}
}
}
}(ctx, ns, c)
return c
}
func (h *PulseHealth) checkPulse(ctx context.Context, ns string, c HealthChan) error {
slog.Debug("Checking pulses...")
for _, gvr := range PulseGVRs {
check, err := h.check(ctx, ns, gvr)
if err != nil {
return err
}
c <- check
}
return nil
}
func (h *PulseHealth) check(ctx context.Context, ns string, gvr *client.GVR) (HealthPoint, error) {
meta, ok := Registry[gvr]
if !ok {
meta = ResourceMeta{
DAO: new(dao.Table),
Renderer: new(render.Table),
}
}
if meta.DAO == nil {
meta.DAO = &dao.Resource{}
}
meta.DAO.Init(h.factory, gvr)
oo, err := meta.DAO.List(ctx, ns)
if err != nil {
return HealthPoint{}, err
}
c := HealthPoint{GVR: gvr, Total: len(oo)}
if isTable(oo) {
ta := oo[0].(*metav1.Table)
c.Total = len(ta.Rows)
for _, row := range ta.Rows {
if err := meta.Renderer.Healthy(ctx, row); err != nil {
c.Faults++
}
}
} else {
for _, o := range oo {
if err := meta.Renderer.Healthy(ctx, o); err != nil {
c.Faults++
}
}
}
slog.Debug("Checked", slogs.GVR, gvr, slogs.Config, c)
return c, nil
}
func isTable(oo []runtime.Object) bool {
if len(oo) == 0 || len(oo) > 1 {
return false
}
_, ok := oo[0].(*metav1.Table)
return ok
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/cluster_info.go | internal/model/cluster_info.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"net/http"
"sync"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/slogs"
"k8s.io/apimachinery/pkg/util/cache"
)
const (
k9sGitURL = "https://api.github.com/repos/derailed/k9s/releases/latest"
cacheSize = 10
cacheExpiry = 1 * time.Hour
k9sLatestRevKey = "k9sRev"
)
// ClusterInfoListener registers a listener for model changes.
type ClusterInfoListener interface {
// ClusterInfoChanged notifies the cluster meta was changed.
ClusterInfoChanged(prev, curr *ClusterMeta)
// ClusterInfoUpdated notifies the cluster meta was updated.
ClusterInfoUpdated(*ClusterMeta)
}
// ClusterMeta represents cluster meta data.
type ClusterMeta struct {
Context, Cluster string
User string
K9sVer, K9sLatest string
K8sVer string
Cpu, Mem, Ephemeral int
}
// NewClusterMeta returns a new instance.
func NewClusterMeta() *ClusterMeta {
return &ClusterMeta{
Context: client.NA,
Cluster: client.NA,
User: client.NA,
K9sVer: client.NA,
K8sVer: client.NA,
Cpu: 0,
Mem: 0,
Ephemeral: 0,
}
}
// Deltas diffs cluster meta return true if different, false otherwise.
func (c *ClusterMeta) Deltas(n *ClusterMeta) bool {
if c.Cpu != n.Cpu || c.Mem != n.Mem || c.Ephemeral != n.Ephemeral {
return true
}
return c.Context != n.Context ||
c.Cluster != n.Cluster ||
c.User != n.User ||
c.K8sVer != n.K8sVer ||
c.K9sVer != n.K9sVer ||
c.K9sLatest != n.K9sLatest
}
// ClusterInfo models cluster metadata.
type ClusterInfo struct {
cluster *Cluster
factory dao.Factory
data *ClusterMeta
version string
cfg *config.K9s
listeners []ClusterInfoListener
cache *cache.LRUExpireCache
mx sync.RWMutex
}
// NewClusterInfo returns a new instance.
func NewClusterInfo(f dao.Factory, v string, cfg *config.K9s) *ClusterInfo {
c := ClusterInfo{
factory: f,
cluster: NewCluster(f),
data: NewClusterMeta(),
version: v,
cfg: cfg,
cache: cache.NewLRUExpireCache(cacheSize),
}
return &c
}
func (c *ClusterInfo) fetchK9sLatestRev() string {
rev, ok := c.cache.Get(k9sLatestRevKey)
if ok {
return rev.(string)
}
latestRev, err := fetchLatestRev()
if err != nil {
slog.Warn("k9s latest rev fetch failed", slogs.Error, err)
} else {
c.cache.Add(k9sLatestRevKey, latestRev, cacheExpiry)
}
return latestRev
}
// Reset resets context and reload.
func (c *ClusterInfo) Reset(f dao.Factory) {
if f == nil {
return
}
c.mx.Lock()
c.cluster, c.data = NewCluster(f), NewClusterMeta()
c.mx.Unlock()
c.Refresh()
}
// Refresh fetches the latest cluster meta.
func (c *ClusterInfo) Refresh() {
data := NewClusterMeta()
if c.factory.Client().ConnectionOK() {
data.Context = c.cluster.ContextName()
data.Cluster = c.cluster.ClusterName()
data.User = c.cluster.UserName()
data.K8sVer = c.cluster.Version()
ctx, cancel := context.WithTimeout(context.Background(), c.cluster.factory.Client().Config().CallTimeout())
defer cancel()
var mx client.ClusterMetrics
if err := c.cluster.Metrics(ctx, &mx); err == nil {
data.Cpu, data.Mem, data.Ephemeral = mx.PercCPU, mx.PercMEM, mx.PercEphemeral
}
}
data.K9sVer = c.version
v1 := NewSemVer(data.K9sVer)
var latestRev string
if !c.cfg.SkipLatestRevCheck {
latestRev = c.fetchK9sLatestRev()
}
v2 := NewSemVer(latestRev)
data.K9sVer, data.K9sLatest = v1.String(), v2.String()
if v1.IsCurrent(v2) {
data.K9sLatest = ""
}
if c.data.Deltas(data) {
c.fireMetaChanged(c.data, data)
} else {
c.fireNoMetaChanged(data)
}
c.mx.Lock()
c.data = data
c.mx.Unlock()
}
// AddListener adds a new model listener.
func (c *ClusterInfo) AddListener(l ClusterInfoListener) {
c.listeners = append(c.listeners, l)
}
// RemoveListener delete a listener from the list.
func (c *ClusterInfo) RemoveListener(l ClusterInfoListener) {
victim := -1
for i, lis := range c.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
c.listeners = append(c.listeners[:victim], c.listeners[victim+1:]...)
}
}
func (c *ClusterInfo) fireMetaChanged(prev, cur *ClusterMeta) {
for _, l := range c.listeners {
l.ClusterInfoChanged(prev, cur)
}
}
func (c *ClusterInfo) fireNoMetaChanged(data *ClusterMeta) {
for _, l := range c.listeners {
l.ClusterInfoUpdated(data)
}
}
// Helpers...
func fetchLatestRev() (string, error) {
slog.Debug("Fetching latest k9s rev...")
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, k9sGitURL, http.NoBody)
if err != nil {
return "", err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return "", err
}
defer func() {
if resp.Body != nil {
_ = resp.Body.Close()
}
}()
b, err := io.ReadAll(resp.Body)
if err != nil {
return "", err
}
m := make(map[string]any, 20)
if err := json.Unmarshal(b, &m); err != nil {
return "", err
}
if v, ok := m["name"]; ok {
slog.Debug("K9s latest rev", slogs.Revision, v.(string))
return v.(string), nil
}
return "", errors.New("no version found")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/hint.go | internal/model/hint.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
// HintListener represents a menu hints listener.
type HintListener interface {
HintsChanged(MenuHints)
}
// Hint represent a hint model.
type Hint struct {
data MenuHints
listeners []HintListener
}
// NewHint return new hint model.
func NewHint() *Hint {
return &Hint{}
}
// RemoveListener deletes a listener.
func (h *Hint) RemoveListener(l HintListener) {
victim := -1
for i, lis := range h.listeners {
if lis == l {
victim = i
break
}
}
if victim == -1 {
return
}
h.listeners = append(h.listeners[:victim], h.listeners[victim+1:]...)
}
// AddListener adds a hint listener.
func (h *Hint) AddListener(l HintListener) {
h.listeners = append(h.listeners, l)
}
// SetHints set model hints.
func (h *Hint) SetHints(hh MenuHints) {
h.data = hh
h.fireChanged()
}
// Peek returns the model data.
func (h *Hint) Peek() MenuHints {
return h.data
}
func (h *Hint) fireChanged() {
for _, l := range h.listeners {
l.HintsChanged(h.data)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/table_int_test.go | internal/model/table_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"encoding/json"
"fmt"
"os"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/watch"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
)
func TestTableReconcile(t *testing.T) {
ta := NewTable(client.PodGVR)
ta.SetNamespace(client.NamespaceAll)
f := makeFactory()
f.rows = []runtime.Object{load(t, "p1")}
ctx := context.WithValue(context.Background(), internal.KeyFactory, f)
ctx = context.WithValue(ctx, internal.KeyFields, "")
ctx = context.WithValue(ctx, internal.KeyWithMetrics, false)
err := ta.reconcile(ctx)
require.NoError(t, err)
data := ta.Peek()
assert.Equal(t, 26, data.HeaderCount())
assert.Equal(t, 1, data.RowCount())
assert.Equal(t, client.NamespaceAll, data.GetNamespace())
}
func TestTableList(t *testing.T) {
ta := NewTable(client.PodGVR)
ta.SetNamespace("blee")
acc := accessor{}
ctx := context.WithValue(context.Background(), internal.KeyFactory, makeFactory())
rows, err := ta.list(ctx, &acc)
require.NoError(t, err)
assert.Len(t, rows, 1)
}
func TestTableGet(t *testing.T) {
ta := NewTable(client.PodGVR)
ta.SetNamespace("blee")
f := makeFactory()
f.rows = []runtime.Object{load(t, "p1")}
ctx := context.WithValue(context.Background(), internal.KeyFactory, f)
ctx = context.WithValue(ctx, internal.KeyWithMetrics, false)
row, err := ta.Get(ctx, "fred")
require.NoError(t, err)
assert.NotNil(t, row)
assert.Len(t, row.(*render.PodWithMetrics).Raw.Object, 5)
}
func TestTableMeta(t *testing.T) {
uu := map[string]struct {
gvr *client.GVR
accessor dao.Accessor
renderer model1.Renderer
}{
"generic": {
gvr: client.CoGVR,
accessor: &dao.Container{},
renderer: &render.Container{},
},
"node": {
gvr: client.NodeGVR,
accessor: &dao.Node{},
renderer: &render.Node{},
},
}
for k := range uu {
u := uu[k]
ta := NewTable(u.gvr)
m := resourceMeta(ta.gvr)
assert.Equal(t, u.accessor, m.DAO)
assert.Equal(t, u.renderer, m.Renderer)
}
}
// ----------------------------------------------------------------------------
// Helpers...
func mustLoad(n string) *unstructured.Unstructured {
raw, err := os.ReadFile(fmt.Sprintf("testdata/%s.json", n))
if err != nil {
panic(err)
}
var o unstructured.Unstructured
if err = json.Unmarshal(raw, &o); err != nil {
panic(err)
}
return &o
}
func load(t *testing.T, 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
}
// ----------------------------------------------------------------------------
func makeFactory() testFactory {
return testFactory{}
}
type testFactory struct {
rows []runtime.Object
}
var _ dao.Factory = testFactory{}
func (testFactory) Client() client.Connection {
return client.NewTestAPIClient()
}
func (f testFactory) Get(*client.GVR, string, bool, labels.Selector) (runtime.Object, error) {
if len(f.rows) > 0 {
return f.rows[0], nil
}
return nil, nil
}
func (f testFactory) List(*client.GVR, string, bool, labels.Selector) ([]runtime.Object, error) {
if len(f.rows) > 0 {
return f.rows, nil
}
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) WaitForCacheSync() {}
func (testFactory) Forwarders() watch.Forwarders {
return nil
}
func (testFactory) DeleteForwarder(string) {}
// ----------------------------------------------------------------------------
type accessor struct {
gvr *client.GVR
}
var _ dao.Accessor = (*accessor)(nil)
func (*accessor) SetIncludeObject(bool) {}
func (*accessor) List(context.Context, string) ([]runtime.Object, error) {
return []runtime.Object{&render.PodWithMetrics{Raw: mustLoad("p1")}}, nil
}
func (*accessor) Get(context.Context, string) (runtime.Object, error) {
return &render.PodWithMetrics{Raw: mustLoad("p1")}, nil
}
func (a *accessor) Init(_ dao.Factory, gvr *client.GVR) {
a.gvr = gvr
}
func (a *accessor) GVR() string {
return a.gvr.String()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/cmd_buff.go | internal/model/cmd_buff.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"sync"
"time"
)
const (
maxBuff = 10
keyEntryDelay = 100 * time.Millisecond
// CommandBuffer represents a command buffer.
CommandBuffer BufferKind = 1 << iota
// FilterBuffer represents a filter buffer.
FilterBuffer
)
type (
// BufferKind indicates a buffer type.
BufferKind int8
// BuffWatcher represents a command buffer listener.
BuffWatcher interface {
// BufferCompleted indicates input was accepted.
BufferCompleted(text, suggestion string)
// BufferChanged indicates the buffer was changed.
BufferChanged(text, suggestion string)
// BufferActive indicates the buff activity changed.
BufferActive(state bool, kind BufferKind)
}
)
// CmdBuff represents user command input.
type CmdBuff struct {
buff []rune
suggestion string
listeners map[BuffWatcher]struct{}
hotKey rune
kind BufferKind
active bool
cancel context.CancelFunc
mx sync.RWMutex
}
// NewCmdBuff returns a new command buffer.
func NewCmdBuff(key rune, kind BufferKind) *CmdBuff {
return &CmdBuff{
hotKey: key,
kind: kind,
buff: make([]rune, 0, maxBuff),
listeners: make(map[BuffWatcher]struct{}),
}
}
// InCmdMode checks if a command exists and the buffer is active.
func (c *CmdBuff) InCmdMode() bool {
c.mx.RLock()
defer c.mx.RUnlock()
if !c.active {
return false
}
return len(c.buff) > 0
}
// IsActive checks if command buffer is active.
func (c *CmdBuff) IsActive() bool {
c.mx.RLock()
defer c.mx.RUnlock()
return c.active
}
// SetActive toggles cmd buffer active state.
func (c *CmdBuff) SetActive(b bool) {
c.mx.Lock()
c.active = b
c.mx.Unlock()
c.fireActive(c.active)
}
// GetText returns the current text.
func (c *CmdBuff) GetText() string {
c.mx.RLock()
defer c.mx.RUnlock()
return string(c.buff)
}
// GetKind returns the buffer kind.
func (c *CmdBuff) GetKind() BufferKind {
c.mx.RLock()
defer c.mx.RUnlock()
return c.kind
}
// GetSuggestion returns the current suggestion.
func (c *CmdBuff) GetSuggestion() string {
c.mx.RLock()
defer c.mx.RUnlock()
return c.suggestion
}
func (c *CmdBuff) hasCancel() bool {
c.mx.RLock()
defer c.mx.RUnlock()
return c.cancel != nil
}
func (c *CmdBuff) setCancel(f context.CancelFunc) {
c.mx.Lock()
c.cancel = f
c.mx.Unlock()
}
func (c *CmdBuff) resetCancel() {
c.mx.Lock()
c.cancel = nil
c.mx.Unlock()
}
// SetText initializes the buffer with a command.
func (c *CmdBuff) SetText(text, suggestion string, wipe bool) {
c.mx.Lock()
if wipe {
c.buff, c.suggestion = []rune(text), suggestion
} else {
c.buff, c.suggestion = append(c.buff, []rune(text)...), suggestion
}
c.mx.Unlock()
c.fireBufferCompleted(c.GetText(), c.GetSuggestion())
}
// Add adds a new character to the buffer.
func (c *CmdBuff) Add(r rune) {
c.mx.Lock()
c.buff = append(c.buff, r)
c.mx.Unlock()
c.fireBufferChanged(c.GetText(), c.GetSuggestion())
if c.hasCancel() {
return
}
ctx, cancel := context.WithTimeout(context.Background(), keyEntryDelay)
c.setCancel(cancel)
go func() {
<-ctx.Done()
c.fireBufferCompleted(c.GetText(), c.GetSuggestion())
c.resetCancel()
}()
}
// Delete removes the last character from the buffer.
func (c *CmdBuff) Delete() {
if c.Empty() {
return
}
c.SetText(string(c.buff[:len(c.buff)-1]), "", true)
c.fireBufferChanged(c.GetText(), c.GetSuggestion())
if c.hasCancel() {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
c.setCancel(cancel)
go func() {
<-ctx.Done()
c.fireBufferCompleted(c.GetText(), c.GetSuggestion())
c.resetCancel()
}()
}
// ClearText clears out command buffer.
func (c *CmdBuff) ClearText(fire bool) {
c.mx.Lock()
c.buff, c.suggestion = c.buff[:0], ""
c.mx.Unlock()
if fire {
c.fireBufferCompleted(c.GetText(), c.GetSuggestion())
}
}
// Reset clears out the command buffer and deactivates it.
func (c *CmdBuff) Reset() {
c.ClearText(true)
c.SetActive(false)
c.fireBufferCompleted(c.GetText(), c.GetSuggestion())
}
// Empty returns true if no cmd, false otherwise.
func (c *CmdBuff) Empty() bool {
c.mx.RLock()
defer c.mx.RUnlock()
return len(c.buff) == 0
}
// ----------------------------------------------------------------------------
// Event Listeners...
// AddListener registers a cmd buffer listener.
func (c *CmdBuff) AddListener(w BuffWatcher) {
c.mx.Lock()
c.listeners[w] = struct{}{}
c.mx.Unlock()
}
// RemoveListener removes a listener.
func (c *CmdBuff) RemoveListener(l BuffWatcher) {
c.mx.Lock()
delete(c.listeners, l)
c.mx.Unlock()
}
func (c *CmdBuff) fireBufferCompleted(t, s string) {
for l := range c.listeners {
l.BufferCompleted(t, s)
}
}
func (c *CmdBuff) fireBufferChanged(t, s string) {
for l := range c.listeners {
l.BufferChanged(t, s)
}
}
func (c *CmdBuff) fireActive(b bool) {
for l := range c.listeners {
l.BufferActive(b, c.GetKind())
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/stack_test.go | internal/model/stack_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"context"
"log/slog"
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/labels"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestStackClear(t *testing.T) {
comps := []model.Component{makeC("c1"), makeC("c2"), makeC("c3")}
uu := map[string]struct {
items []model.Component
}{
"empty": {
items: []model.Component{},
},
"items": {
items: comps,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, c := range u.items {
s.Push(c)
}
s.Clear()
assert.True(t, s.Empty())
})
}
}
func TestStackPrevious(t *testing.T) {
comps := []model.Component{makeC("c1"), makeC("c2"), makeC("c3")}
uu := map[string]struct {
items []model.Component
pops int
e model.Component
}{
"empty": {
items: []model.Component{},
pops: 0,
e: nil,
},
"one_left": {
items: comps,
pops: 1,
e: comps[0],
},
"none_left": {
items: comps,
pops: 2,
e: comps[0],
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, c := range u.items {
s.Push(c)
}
for range u.pops {
s.Pop()
}
assert.Equal(t, u.e, s.Previous())
})
}
}
func TestStackIsLast(t *testing.T) {
uu := map[string]struct {
items []model.Component
pops int
e bool
}{
"empty": {
items: []model.Component{},
},
"normal": {
items: []model.Component{makeC("c1"), makeC("c2"), makeC("c3")},
pops: 1,
},
"last": {
items: []model.Component{makeC("c1"), makeC("c2"), makeC("c3")},
pops: 2,
e: true,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, c := range u.items {
s.Push(c)
}
for range u.pops {
s.Pop()
}
assert.Equal(t, u.e, s.IsLast())
})
}
}
func TestStackFlatten(t *testing.T) {
uu := map[string]struct {
items []model.Component
e []string
}{
"empty": {
items: []model.Component{},
e: []string{},
},
"normal": {
items: []model.Component{makeC("c1"), makeC("c2"), makeC("c3")},
e: []string{"c1", "c2", "c3"},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, c := range u.items {
s.Push(c)
}
assert.Equal(t, u.e, s.Flatten())
assert.Len(t, s.Peek(), len(u.e))
})
}
}
func TestStackPush(t *testing.T) {
top := c{}
uu := map[string]struct {
items []model.Component
pop int
e bool
top model.Component
}{
"empty": {
items: []model.Component{},
pop: 3,
e: true,
},
"full": {
items: []model.Component{c{}, c{}, top},
pop: 3,
e: true,
},
"pop": {
items: []model.Component{c{}, c{}, top},
pop: 2,
e: false,
top: top,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, c := range u.items {
s.Push(c)
}
for range u.pop {
s.Pop()
}
assert.Equal(t, u.e, s.Empty())
if !u.e {
assert.Equal(t, u.top, s.Top())
}
})
}
}
func TestStackTop(t *testing.T) {
top := c{}
uu := map[string]struct {
items []model.Component
e model.Component
}{
"blank": {
items: []model.Component{},
},
"push3": {
items: []model.Component{c{}, c{}, top},
e: top,
},
"push1": {
items: []model.Component{top},
e: top,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
s := model.NewStack()
for _, item := range u.items {
s.Push(item)
}
v := s.Top()
assert.Equal(t, u.e, v)
})
}
}
func TestStackAddListener(t *testing.T) {
items := []model.Component{c{}, c{}, c{}}
s := model.NewStack()
l := stackL{}
s.AddListener(&l)
for _, item := range items {
s.Push(item)
}
assert.Equal(t, 3, l.count)
for range items {
s.Pop()
}
assert.Equal(t, 0, l.count)
}
func TestStackAddListenerAfter(t *testing.T) {
items := []model.Component{c{}, c{}, c{}}
s := model.NewStack()
l := stackL{}
for _, item := range items {
s.Push(item)
}
s.AddListener(&l)
assert.Equal(t, 1, l.tops)
assert.Equal(t, 0, l.count)
}
func TestStackRemoveListener(t *testing.T) {
s := model.NewStack()
l1, l2, l3 := &stackL{}, &stackL{}, &stackL{}
s.AddListener(l1)
s.AddListener(l2)
s.RemoveListener(l2)
s.RemoveListener(l3)
s.RemoveListener(l1)
s.Push(c{})
assert.Equal(t, 0, l1.count)
assert.Equal(t, 0, l2.count)
assert.Equal(t, 0, l3.count)
}
// ----------------------------------------------------------------------------
// Helpers...
type stackL struct {
count, tops int
}
func (s *stackL) StackPushed(model.Component) {
s.count++
}
func (s *stackL) StackPopped(_, _ model.Component) {
s.count--
}
func (s *stackL) StackTop(model.Component) { s.tops++ }
type c struct {
name string
}
func makeC(n string) c {
return c{name: n}
}
func (c) InCmdMode() bool { return false }
func (c c) Name() string { return c.name }
func (c) SetCommand(*cmd.Interpreter) {}
func (c) Hints() model.MenuHints { return nil }
func (c) HasFocus() bool { return false }
func (c) ExtraHints() map[string]string { return nil }
func (c) Draw(tcell.Screen) {}
func (c) InputHandler() func(*tcell.EventKey, func(tview.Primitive)) { return nil }
func (c) MouseHandler() func(action tview.MouseAction, event *tcell.EventMouse, setFocus func(p tview.Primitive)) (consumed bool, capture tview.Primitive) {
return nil
}
func (c) SetRect(int, int, int, int) {}
func (c) GetRect() (a, b, c, d int) { return 0, 0, 0, 0 }
func (c) GetFocusable() tview.Focusable { return nil }
func (c) Focus(func(tview.Primitive)) {}
func (c) Blur() {}
func (c) Start() {}
func (c) Stop() {}
func (c) Init(context.Context) error { return nil }
func (c) SetFilter(string, bool) {}
func (c) SetLabelSelector(labels.Selector, bool) {}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/helpers_int_test.go | internal/model/helpers_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"testing"
"github.com/sahilm/fuzzy"
"github.com/stretchr/testify/assert"
)
func Test_rxFilter(t *testing.T) {
uu := map[string]struct {
q string
lines []string
e fuzzy.Matches
}{
"empty-lines": {
q: "foo",
e: fuzzy.Matches{},
},
"no-match": {
q: "foo",
lines: []string{"bar"},
e: fuzzy.Matches{},
},
"single-match": {
q: "foo",
lines: []string{"foo", "bar", "baz"},
e: fuzzy.Matches{
{
Str: "foo",
Index: 0,
MatchedIndexes: []int{0, 1, 2},
},
},
},
"start-rx-match": {
q: "(?i)^foo",
lines: []string{"foo", "fob", "barfoo"},
e: fuzzy.Matches{
{
Str: "(?i)^foo",
Index: 0,
MatchedIndexes: []int{0, 1, 2},
},
},
},
"end-rx-match": {
q: "foo$",
lines: []string{"foo", "fob", "barfoo"},
e: fuzzy.Matches{
{
Str: "foo$",
Index: 0,
MatchedIndexes: []int{0, 1, 2},
},
{
Str: "foo$",
Index: 2,
MatchedIndexes: []int{3, 4, 5},
},
},
},
"multiple-matches": {
q: "foo",
lines: []string{"foo", "bar", "foo bar foo", "baz"},
e: fuzzy.Matches{
{
Str: "foo",
Index: 0,
MatchedIndexes: []int{0, 1, 2},
},
{
Str: "foo",
Index: 2,
MatchedIndexes: []int{0, 1, 2},
},
{
Str: "foo",
Index: 2,
MatchedIndexes: []int{8, 9, 10},
},
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, rxFilter(u.q, u.lines))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/text_test.go | internal/model/text_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/sahilm/fuzzy"
"github.com/stretchr/testify/assert"
)
func TestNewText(t *testing.T) {
m := model.NewText()
lis := textLis{}
m.AddListener(&lis)
m.SetText("Hello World\nBumbleBeeTuna")
assert.Equal(t, 1, lis.changed)
assert.Equal(t, 2, lis.lines)
assert.Equal(t, 0, lis.filtered)
assert.Equal(t, 0, lis.matches)
}
func TestTextFilterRXMatch(t *testing.T) {
m := model.NewText()
lis := textLis{}
m.AddListener(&lis)
m.SetText("Hello World\nBumbleBeeTuna")
m.Filter("world")
assert.Equal(t, 1, lis.changed)
assert.Equal(t, 2, lis.lines)
assert.Equal(t, 1, lis.filtered)
assert.Equal(t, 1, lis.matches)
assert.Equal(t, 6, lis.index)
}
func TestTextFilterFuzzyMatch(t *testing.T) {
m := model.NewText()
lis := textLis{}
m.AddListener(&lis)
m.SetText("Hello World\nBumbleBeeTuna")
m.Filter("-f world")
assert.Equal(t, 1, lis.changed)
assert.Equal(t, 2, lis.lines)
assert.Equal(t, 1, lis.filtered)
assert.Equal(t, 1, lis.matches)
assert.Equal(t, 6, lis.index)
}
func TestTextFilterNoMatch(t *testing.T) {
m := model.NewText()
lis := textLis{}
m.AddListener(&lis)
m.SetText("Hello World\nBumbleBeeTuna")
m.Filter("blee")
assert.Equal(t, 1, lis.changed)
assert.Equal(t, 2, lis.lines)
assert.Equal(t, 1, lis.filtered)
assert.Equal(t, 0, lis.matches)
assert.Equal(t, 0, lis.index)
}
// Helpers...
type textLis struct {
changed, filtered, matches, lines, index int
}
func (l *textLis) TextChanged(ll []string) {
l.lines = len(ll)
l.changed++
}
func (l *textLis) TextFiltered(_ []string, mm fuzzy.Matches) {
l.matches = len(mm)
l.filtered++
if len(mm) > 0 && len(mm[0].MatchedIndexes) > 0 {
l.index = mm[0].MatchedIndexes[0]
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/hint_test.go | internal/model/hint_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model_test
import (
"testing"
"github.com/derailed/k9s/internal/model"
"github.com/stretchr/testify/assert"
)
func TestHint(t *testing.T) {
uu := map[string]struct {
hh model.MenuHints
e int
}{
"none": {
model.MenuHints{},
0,
},
"hints": {
model.MenuHints{
{Mnemonic: "a", Description: "blee"},
{Mnemonic: "b", Description: "fred"},
},
2,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
h := model.NewHint()
l := hintL{count: -1}
h.AddListener(&l)
h.SetHints(u.hh)
assert.Equal(t, u.e, l.count)
assert.Len(t, h.Peek(), u.e)
})
}
}
func TestHintRemoveListener(t *testing.T) {
h := model.NewHint()
l1, l2, l3 := &hintL{}, &hintL{}, &hintL{}
h.AddListener(l1)
h.AddListener(l2)
h.RemoveListener(l2)
h.RemoveListener(l3)
h.RemoveListener(l1)
h.SetHints(model.MenuHints{
model.MenuHint{Mnemonic: "a", Description: "Blee"},
})
assert.Equal(t, 0, l1.count)
assert.Equal(t, 0, l2.count)
assert.Equal(t, 0, l3.count)
}
// ----------------------------------------------------------------------------
// Helpers...
type hintL struct {
count int
}
func (h *hintL) HintsChanged(hh model.MenuHints) {
h.count++
h.count += len(hh)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/pulse.go | internal/model/pulse.go | package model
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/health"
)
// PulseListener represents a health model listener.
type PulseListener interface {
// PulseChanged notifies the model data changed.
PulseChanged(*health.Check)
// PulseFailed notifies the health check failed.
PulseFailed(error)
// MetricsChanged update metrics time series.
MetricsChanged(dao.TimeSeries)
}
// Pulse tracks multiple resources health.
type Pulse struct {
gvr *client.GVR
namespace string
listeners []PulseListener
health *PulseHealth
}
// NewPulse returns a new pulse.
func NewPulse(gvr *client.GVR) *Pulse {
return &Pulse{
gvr: gvr,
}
}
type HealthChan chan HealthPoint
// Watch monitors pulses.
func (p *Pulse) Watch(ctx context.Context) (HealthChan, dao.MetricsChan, error) {
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return nil, nil, fmt.Errorf("expected Factory in context but got %T", ctx.Value(internal.KeyFactory))
}
if p.health == nil {
p.health = NewPulseHealth(f)
}
healthChan := p.health.Watch(ctx, p.namespace)
metricsChan := dao.DialRecorder(f.Client()).Watch(ctx, p.namespace)
return healthChan, metricsChan, nil
}
// Refresh update the model now.
func (*Pulse) Refresh(context.Context) {}
// GetNamespace returns the model namespace.
func (p *Pulse) GetNamespace() string {
return p.namespace
}
// SetNamespace sets up model namespace.
func (p *Pulse) SetNamespace(ns string) {
if client.IsAllNamespaces(ns) {
ns = client.BlankNamespace
}
p.namespace = ns
}
// AddListener adds a listener.
func (p *Pulse) AddListener(l PulseListener) {
p.listeners = append(p.listeners, l)
}
// RemoveListener delete a listener.
func (p *Pulse) RemoveListener(l PulseListener) {
victim := -1
for i, lis := range p.listeners {
if lis == l {
victim = i
break
}
}
if victim >= 0 {
p.listeners = append(p.listeners[:victim], p.listeners[victim+1:]...)
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/semver.go | internal/model/semver.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"fmt"
"regexp"
"strconv"
)
var versionRX = regexp.MustCompile(`\Av(\d+)\.(\d+)\.(\d+)\z`)
// SemVer represents a semantic version.
type SemVer struct {
Major, Minor, Patch int
}
// NewSemVer returns a new semantic version.
func NewSemVer(version string) *SemVer {
var v SemVer
v.Major, v.Minor, v.Patch = v.parse(NormalizeVersion(version))
return &v
}
// String returns version as a string.
func (v *SemVer) String() string {
return fmt.Sprintf("v%d.%d.%d", v.Major, v.Minor, v.Patch)
}
func (*SemVer) parse(version string) (major, minor, patch int) {
mm := versionRX.FindStringSubmatch(version)
if len(mm) < 4 {
return
}
major, _ = strconv.Atoi(mm[1])
minor, _ = strconv.Atoi(mm[2])
patch, _ = strconv.Atoi(mm[3])
return
}
// NormalizeVersion ensures the version starts with a v.
func NormalizeVersion(version string) string {
if version == "" {
return version
}
if version[0] == 'v' {
return version
}
return "v" + version
}
// IsCurrent asserts if at latest release.
func (v *SemVer) IsCurrent(latest *SemVer) bool {
return v.Major >= latest.Major && v.Minor >= latest.Minor && v.Patch >= latest.Patch
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/model/helpers.go | internal/model/helpers.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package model
import (
"context"
"fmt"
"regexp"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/sahilm/fuzzy"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func getMeta(ctx context.Context, gvr *client.GVR) (ResourceMeta, error) {
meta := resourceMeta(gvr)
factory, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return ResourceMeta{}, fmt.Errorf("expected Factory in context but got %T", ctx.Value(internal.KeyFactory))
}
meta.DAO.Init(factory, gvr)
return meta, nil
}
func resourceMeta(gvr *client.GVR) ResourceMeta {
meta, ok := Registry[gvr]
if !ok {
meta = ResourceMeta{
DAO: new(dao.Table),
Renderer: new(render.Table),
}
}
if meta.DAO == nil {
meta.DAO = new(dao.Resource)
}
return meta
}
// MetaFQN returns a fully qualified resource name.
func MetaFQN(m *metav1.ObjectMeta) string {
return FQN(m.Namespace, m.Name)
}
// FQN returns a fully qualified resource name.
func FQN(ns, n string) string {
if ns == "" {
return n
}
return ns + "/" + n
}
// NewExpBackOff returns a new exponential backoff timer.
func NewExpBackOff(ctx context.Context, start, maxVal time.Duration) backoff.BackOffContext {
bf := backoff.NewExponentialBackOff()
bf.InitialInterval, bf.MaxElapsedTime = start, maxVal
return backoff.WithContext(bf, ctx)
}
func rxFilter(q string, lines []string) fuzzy.Matches {
rx, err := regexp.Compile(`(?i)` + q)
if err != nil {
return nil
}
matches := make(fuzzy.Matches, 0, len(lines))
for i, l := range lines {
locs := rx.FindAllStringIndex(l, -1)
for _, loc := range locs {
indexes := make([]int, 0, loc[1]-loc[0])
for v := loc[0]; v < loc[1]; v++ {
indexes = append(indexes, v)
}
matches = append(matches, fuzzy.Match{Str: q, Index: i, MatchedIndexes: indexes})
}
}
return matches
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/generic.go | internal/xray/generic.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/client"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// Generic renders a generic resource to screen.
type Generic struct {
table *metav1.Table
}
// SetTable sets the tabular resource.
func (g *Generic) SetTable(_ string, t *metav1.Table) {
g.table = t
}
// Render renders a K8s resource to screen.
func (g *Generic) Render(ctx context.Context, ns string, o any) error {
row, ok := o.(metav1.TableRow)
if !ok {
return fmt.Errorf("expecting a TableRow but got %T", o)
}
n, ok := row.Cells[0].(string)
if !ok {
return fmt.Errorf("expecting row 0 to be a string but got %T", row.Cells[0])
}
root := NewTreeNode(client.NewGVR("generic"), client.FQN(ns, n))
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting TreeNode but got %T", ctx.Value(KeyParent))
}
parent.Add(root)
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/ds_test.go | internal/xray/ds_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/runtime"
)
func TestDaemonSetRender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "ds",
level1: 1,
level2: 1,
status: xray.OkStatus,
},
}
var re xray.DaemonSet
for k := range uu {
f := makeFactory()
f.rows = map[*client.GVR][]runtime.Object{client.PodGVR: {load(t, "po")}}
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.DsGVR, "daemonsets")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, f)
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/sa_test.go | internal/xray/sa_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSARender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "sa",
level1: 1,
level2: 2,
status: xray.OkStatus,
},
}
var re xray.ServiceAccount
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.SaGVR, "serviceaccounts")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/pod_test.go | internal/xray/pod_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestPodRender(t *testing.T) {
uu := map[string]struct {
file string
count, children int
status string
}{
"plain": {
file: "po",
children: 1,
count: 7,
status: xray.OkStatus,
},
"withInit": {
file: "init",
children: 1,
count: 7,
status: xray.OkStatus,
},
"cilium": {
file: "cilium",
children: 1,
count: 8,
status: xray.OkStatus,
},
}
var re xray.Pod
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.PodGVR, "pods")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", &render.PodWithMetrics{Raw: o}))
assert.Equal(t, u.children, root.CountChildren())
assert.Equal(t, u.count, root.Count(client.NoGVR))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/container.go | internal/xray/container.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
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"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/labels"
)
// Container represents an xray renderer.
type Container struct{}
// Render renders an xray node.
func (c *Container) Render(ctx context.Context, ns string, o any) error {
co, ok := o.(render.ContainerRes)
if !ok {
return fmt.Errorf("expected ContainerRes, but got %T", o)
}
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return fmt.Errorf("no factory found in context")
}
root := NewTreeNode(client.CoGVR, client.FQN(ns, co.Container.Name))
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
pns, _ := client.Namespaced(parent.ID)
c.envRefs(f, root, pns, co.Container)
parent.Add(root)
return nil
}
func (c *Container) envRefs(f dao.Factory, parent *TreeNode, ns string, co *v1.Container) {
for _, e := range co.Env {
if e.ValueFrom == nil {
continue
}
c.secretRefs(f, parent, ns, e.ValueFrom.SecretKeyRef)
c.configMapRefs(f, parent, ns, e.ValueFrom.ConfigMapKeyRef)
}
for _, e := range co.EnvFrom {
if e.ConfigMapRef != nil {
gvr, id := client.CmGVR, client.FQN(ns, e.ConfigMapRef.Name)
addRef(f, parent, gvr, id, e.ConfigMapRef.Optional)
}
if e.SecretRef != nil {
gvr, id := client.SecGVR, client.FQN(ns, e.SecretRef.Name)
addRef(f, parent, gvr, id, e.SecretRef.Optional)
}
}
}
func (c *Container) secretRefs(f dao.Factory, parent *TreeNode, ns string, ref *v1.SecretKeySelector) {
if ref == nil {
return
}
gvr, id := client.SecGVR, client.FQN(ns, ref.Name)
addRef(f, parent, gvr, id, ref.Optional)
}
func (c *Container) configMapRefs(f dao.Factory, parent *TreeNode, ns string, ref *v1.ConfigMapKeySelector) {
if ref == nil {
return
}
gvr, id := client.CmGVR, client.FQN(ns, ref.Name)
addRef(f, parent, gvr, id, ref.Optional)
}
// ----------------------------------------------------------------------------
// Helpers...
func addRef(f dao.Factory, parent *TreeNode, gvr *client.GVR, id string, optional *bool) {
if parent.Find(gvr, id) == nil {
n := NewTreeNode(gvr, id)
validate(f, n, optional)
parent.Add(n)
}
}
func validate(f dao.Factory, n *TreeNode, optional *bool) {
res, err := f.Get(n.GVR, n.ID, true, labels.Everything())
if err != nil || res == nil {
if optional == nil || !*optional {
slog.Warn("Missing ref",
slogs.GVR, n.GVR,
slogs.ID, n.ID,
)
n.Extras[StatusKey] = MissingRefStatus
}
return
}
n.Extras[StatusKey] = OkStatus
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/rs_test.go | internal/xray/rs_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/runtime"
)
func TestReplicaSetRender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "rs",
level1: 1,
level2: 1,
status: xray.OkStatus,
},
}
var re xray.ReplicaSet
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
f := makeFactory()
f.rows = map[*client.GVR][]runtime.Object{
client.PodGVR: {load(t, "po")},
}
o := load(t, u.file)
root := xray.NewTreeNode(client.RsGVR, "replicasets")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, f)
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/pod.go | internal/xray/pod.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"strconv"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
// Pod represents an xray renderer.
type Pod struct{}
// Render renders an xray node.
func (p *Pod) Render(ctx context.Context, ns string, o any) error {
pwm, ok := o.(*render.PodWithMetrics)
if !ok {
return fmt.Errorf("expected PodWithMetrics, but got %T", o)
}
var po v1.Pod
err := runtime.DefaultUnstructuredConverter.FromUnstructured(pwm.Raw.Object, &po)
if err != nil {
return err
}
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return fmt.Errorf("no factory found in context")
}
node := NewTreeNode(client.PodGVR, client.FQN(po.Namespace, po.Name))
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
if err := p.containerRefs(ctx, node, po.Namespace, &po.Spec); err != nil {
return err
}
p.podVolumeRefs(f, node, po.Namespace, po.Spec.Volumes)
if err := p.serviceAccountRef(ctx, f, node, po.Namespace, &po.Spec); err != nil {
return err
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, po.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(node)
return p.validate(node, po)
}
func (p *Pod) validate(node *TreeNode, po v1.Pod) error {
var re render.Pod
phase := re.Phase(po.DeletionTimestamp, &po.Spec, &po.Status)
ss := po.Status.ContainerStatuses
readyCnt, _, _, _ := re.ContainerStats(ss)
status := OkStatus
if readyCnt != len(ss) {
status = ToastStatus
}
if phase == "Completed" {
status = CompletedStatus
}
node.Extras[StatusKey] = status
node.Extras[InfoKey] = strconv.Itoa(readyCnt) + "/" + strconv.Itoa(len(ss))
return nil
}
func (*Pod) containerRefs(ctx context.Context, parent *TreeNode, ns string, spec *v1.PodSpec) error {
ctx = context.WithValue(ctx, KeyParent, parent)
var cre Container
for i := range len(spec.InitContainers) {
if err := cre.Render(ctx, ns, render.ContainerRes{Container: &spec.InitContainers[i]}); err != nil {
return err
}
}
for i := range len(spec.Containers) {
if err := cre.Render(ctx, ns, render.ContainerRes{Container: &spec.Containers[i]}); err != nil {
return err
}
}
for i := range len(spec.EphemeralContainers) {
if err := cre.Render(ctx, ns, render.ContainerRes{Container: &spec.Containers[i]}); err != nil {
return err
}
}
return nil
}
func (*Pod) serviceAccountRef(ctx context.Context, f dao.Factory, parent *TreeNode, ns string, spec *v1.PodSpec) error {
if spec.ServiceAccountName == "" {
return nil
}
fqn := client.FQN(ns, spec.ServiceAccountName)
o, err := f.Get(client.SaGVR, fqn, true, labels.Everything())
if err != nil {
return err
}
if o == nil {
addRef(f, parent, client.SaGVR, fqn, nil)
return nil
}
var saRE ServiceAccount
ctx = context.WithValue(ctx, KeyParent, parent)
ctx = context.WithValue(ctx, KeySAAutomount, spec.AutomountServiceAccountToken)
return saRE.Render(ctx, ns, o)
}
func (*Pod) podVolumeRefs(f dao.Factory, parent *TreeNode, ns string, vv []v1.Volume) {
for i := range vv {
sec := vv[i].Secret
if sec != nil {
addRef(f, parent, client.SecGVR, client.FQN(ns, sec.SecretName), sec.Optional)
continue
}
cm := vv[i].ConfigMap
if cm != nil {
addRef(f, parent, client.CmGVR, client.FQN(ns, cm.Name), cm.Optional)
continue
}
pvc := vv[i].PersistentVolumeClaim
if pvc != nil {
addRef(f, parent, client.PvcGVR, client.FQN(ns, pvc.ClaimName), nil)
}
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/container_test.go | internal/xray/container_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"os"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/watch"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/informers"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestCOConfigMapRefs(t *testing.T) {
var re xray.Container
root := xray.NewTreeNode(client.NewGVR("root"), "root")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", render.ContainerRes{Container: makeCMContainer("c1", false)}))
assert.Equal(t, xray.MissingRefStatus, root.Children[0].Children[0].Extras[xray.StatusKey])
}
func TestCORefs(t *testing.T) {
uu := map[string]struct {
co render.ContainerRes
level1, level2 int
e string
}{
"cm_required": {
co: render.ContainerRes{Container: makeCMContainer("c1", false)},
level1: 1,
level2: 1,
e: xray.MissingRefStatus,
},
"cm_optional": {
co: render.ContainerRes{Container: makeCMContainer("c1", true)},
level1: 1,
level2: 1,
e: xray.OkStatus,
},
"cm_doubleRef": {
co: render.ContainerRes{Container: makeDoubleCMKeysContainer("c1", false)},
level1: 1,
level2: 1,
e: xray.MissingRefStatus,
},
"sec_required": {
co: render.ContainerRes{Container: makeSecContainer("c1", false)},
level1: 1,
level2: 1,
e: xray.MissingRefStatus,
},
"sec_optional": {
co: render.ContainerRes{Container: makeSecContainer("c1", true)},
level1: 1,
level2: 1,
e: xray.OkStatus,
},
"envFrom_optional": {
co: render.ContainerRes{Container: makeCMEnvFromContainer("c1", false)},
level1: 1,
level2: 2,
e: xray.MissingRefStatus,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
var re xray.Container
root := xray.NewTreeNode(client.NewGVR("root"), "root")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", u.co))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
assert.Equal(t, u.e, root.Children[0].Children[0].Extras[xray.StatusKey])
})
}
}
// ----------------------------------------------------------------------------
// Helpers...
func makeFactory() testFactory {
return testFactory{}
}
type testFactory struct {
rows map[*client.GVR][]runtime.Object
}
var _ dao.Factory = testFactory{}
func (f testFactory) Client() client.Connection {
return nil
}
func (f testFactory) Get(gvr *client.GVR, _ string, _ bool, _ labels.Selector) (runtime.Object, error) {
oo, ok := f.rows[gvr]
if ok && len(oo) > 0 {
return oo[0], nil
}
return nil, nil
}
func (f testFactory) List(gvr *client.GVR, _ string, _ bool, _ labels.Selector) ([]runtime.Object, error) {
oo, ok := f.rows[gvr]
if ok {
return oo, nil
}
return nil, nil
}
func (f testFactory) ForResource(string, *client.GVR) (informers.GenericInformer, error) {
return nil, nil
}
func (f testFactory) CanForResource(string, *client.GVR, []string) (informers.GenericInformer, error) {
return nil, nil
}
func (f testFactory) WaitForCacheSync() {}
func (f testFactory) Forwarders() watch.Forwarders {
return nil
}
func (f testFactory) DeleteForwarder(string) {}
func makeCMEnvFromContainer(n string, optional bool) *v1.Container {
return &v1.Container{
Name: n,
EnvFrom: []v1.EnvFromSource{
{
ConfigMapRef: &v1.ConfigMapEnvSource{
LocalObjectReference: v1.LocalObjectReference{
Name: "cm1",
},
Optional: &optional,
},
SecretRef: &v1.SecretEnvSource{
LocalObjectReference: v1.LocalObjectReference{
Name: "sec1",
},
Optional: &optional,
},
},
},
}
}
func makeCMContainer(n string, optional bool) *v1.Container {
return &v1.Container{
Name: n,
Env: []v1.EnvVar{
{
Name: "e1",
ValueFrom: &v1.EnvVarSource{
ConfigMapKeyRef: &v1.ConfigMapKeySelector{
LocalObjectReference: v1.LocalObjectReference{
Name: "cm1",
},
Key: "k1",
Optional: &optional,
},
},
},
},
}
}
func makeSecContainer(n string, optional bool) *v1.Container {
return &v1.Container{
Name: n,
Env: []v1.EnvVar{
{
Name: "e1",
ValueFrom: &v1.EnvVarSource{
SecretKeyRef: &v1.SecretKeySelector{
LocalObjectReference: v1.LocalObjectReference{
Name: "sec1",
},
Key: "k1",
Optional: &optional,
},
},
},
},
}
}
func makeDoubleCMKeysContainer(n string, optional bool) *v1.Container {
return &v1.Container{
Name: n,
Env: []v1.EnvVar{
{
Name: "e1",
ValueFrom: &v1.EnvVarSource{
ConfigMapKeyRef: &v1.ConfigMapKeySelector{
LocalObjectReference: v1.LocalObjectReference{
Name: "cm1",
},
Key: "k2",
Optional: &optional,
},
},
},
{
Name: "e2",
ValueFrom: &v1.EnvVarSource{
ConfigMapKeyRef: &v1.ConfigMapKeySelector{
LocalObjectReference: v1.LocalObjectReference{
Name: "cm1",
},
Key: "k1",
Optional: &optional,
},
},
},
},
}
}
func load(t *testing.T, 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/xray/ns_test.go | internal/xray/ns_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestNamespaceRender(t *testing.T) {
uu := map[string]struct {
file string
level1 int
status string
}{
"plain": {
file: "ns",
level1: 1,
status: xray.OkStatus,
},
}
var re xray.Namespace
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.NsGVR, "namespaces")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/dp.go | internal/xray/dp.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
appsv1 "k8s.io/api/apps/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
// Deployment represents an xray renderer.
type Deployment struct{}
// Render renders an xray node.
func (d *Deployment) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
var dp appsv1.Deployment
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &dp)
if err != nil {
return err
}
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
root := NewTreeNode(client.DpGVR, client.FQN(dp.Namespace, dp.Name))
oo, err := locatePods(ctx, dp.Namespace, dp.Spec.Selector)
if err != nil {
return err
}
ctx = context.WithValue(ctx, KeyParent, root)
var re Pod
for _, o := range oo {
p, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expecting *Unstructured but got %T", o)
}
if err := re.Render(ctx, ns, &render.PodWithMetrics{Raw: p}); err != nil {
return err
}
}
if root.IsLeaf() {
return nil
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, dp.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(root)
return d.validate(root, dp)
}
func (*Deployment) validate(root *TreeNode, dp appsv1.Deployment) error {
root.Extras[StatusKey] = OkStatus
var r int32
if dp.Spec.Replicas != nil {
r = int32(*dp.Spec.Replicas)
}
a := dp.Status.AvailableReplicas
if a != r || dp.Status.UnavailableReplicas != 0 {
root.Extras[StatusKey] = ToastStatus
}
root.Extras[InfoKey] = fmt.Sprintf("%d/%d/%d", a, r, dp.Status.UnavailableReplicas)
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func locatePods(ctx context.Context, ns string, sel *metav1.LabelSelector) ([]runtime.Object, error) {
l, err := metav1.LabelSelectorAsSelector(sel)
if err != nil {
return nil, err
}
fsel, err := labels.ConvertSelectorToLabelsMap(l.String())
if err != nil {
return nil, err
}
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return nil, fmt.Errorf("expecting a factory but got %T", ctx.Value(internal.KeyFactory))
}
return f.List(client.PodGVR, ns, false, fsel.AsSelector())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/ds.go | internal/xray/ds.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
appsv1 "k8s.io/api/apps/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
// DaemonSet represents an xray renderer.
type DaemonSet struct{}
// Render renders an xray node.
func (d *DaemonSet) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
var ds appsv1.DaemonSet
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &ds)
if err != nil {
return err
}
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
root := NewTreeNode(client.DsGVR, client.FQN(ds.Namespace, ds.Name))
oo, err := locatePods(ctx, ds.Namespace, ds.Spec.Selector)
if err != nil {
return err
}
ctx = context.WithValue(ctx, KeyParent, root)
var re Pod
for _, o := range oo {
p, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expecting *Unstructured but got %T", o)
}
if err := re.Render(ctx, ns, &render.PodWithMetrics{Raw: p}); err != nil {
return err
}
}
if root.IsLeaf() {
return nil
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, ds.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(root)
return d.validate(root, ds)
}
func (*DaemonSet) validate(root *TreeNode, ds appsv1.DaemonSet) error {
root.Extras[StatusKey] = OkStatus
d := ds.Status.DesiredNumberScheduled
a := ds.Status.NumberAvailable
if d != a {
root.Extras[StatusKey] = ToastStatus
}
root.Extras[InfoKey] = fmt.Sprintf("%d/%d", a, d)
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/ns.go | internal/xray/ns.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/client"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
// Namespace represents an xray renderer.
type Namespace struct{}
// Render renders an xray node.
func (n *Namespace) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected NamespaceWithMetrics, but got %T", o)
}
var nss v1.Namespace
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &nss)
if err != nil {
return err
}
root := NewTreeNode(client.NsGVR, client.FQN(client.ClusterScope, nss.Name))
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
parent.Add(root)
return n.validate(root, nss)
}
func (*Namespace) validate(root *TreeNode, ns v1.Namespace) error {
root.Extras[StatusKey] = OkStatus
if ns.Status.Phase == v1.NamespaceTerminating {
root.Extras[StatusKey] = ToastStatus
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/tree_node.go | internal/xray/tree_node.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"fmt"
"log/slog"
"reflect"
"sort"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/fvbommel/sortorder"
)
const (
// KeyParent indicates a parent node context key.
KeyParent TreeRef = "parent"
// KeySAAutomount indicates whether an automount sa token is active or not.
KeySAAutomount TreeRef = "automount"
// PathSeparator represents a node path separator.
PathSeparator = "::"
// StatusKey status map key.
StatusKey = "status"
// InfoKey state map key.
InfoKey = "info"
// OkStatus stands for all is cool.
OkStatus = "ok"
// ToastStatus stands for a resource is not up to snuff
// aka not running or incomplete.
ToastStatus = "toast"
// CompletedStatus stands for a completed resource.
CompletedStatus = "completed"
// MissingRefStatus stands for a non existing resource reference.
MissingRefStatus = "noref"
)
// ----------------------------------------------------------------------------
// TreeRef namespaces tree context values.
type TreeRef string
// ----------------------------------------------------------------------------
// NodeSpec represents a node resource specification.
type NodeSpec struct {
GVRs client.GVRs
Paths, Statuses []string
}
// ParentGVR returns the parent GVR.
func (s NodeSpec) ParentGVR() *client.GVR {
if len(s.GVRs) > 1 {
return s.GVRs[1]
}
return nil
}
// ParentPath returns the parent path.
func (s NodeSpec) ParentPath() *string {
if len(s.Paths) > 1 {
return &s.Paths[1]
}
return nil
}
// GVR returns the current GVR.
func (s NodeSpec) GVR() *client.GVR {
return s.GVRs[0]
}
// Path returns the current path.
func (s NodeSpec) Path() string {
return s.Paths[0]
}
// Status returns the current status.
func (s NodeSpec) Status() string {
return s.Statuses[0]
}
// AsPath returns path hierarchy as string.
func (s NodeSpec) AsPath() string {
return strings.Join(s.Paths, PathSeparator)
}
// AsGVR returns a gvr hierarchy as string.
func (s NodeSpec) AsGVR() string {
ss := make([]string, 0, len(s.GVRs))
for _, gvr := range s.GVRs {
ss = append(ss, gvr.R())
}
return strings.Join(ss, PathSeparator)
}
// AsStatus returns a status hierarchy as string.
func (s NodeSpec) AsStatus() string {
return strings.Join(s.Statuses, PathSeparator)
}
// ----------------------------------------------------------------------------
// ChildNodes represents a collection of children nodes.
type ChildNodes []*TreeNode
// Len returns the list size.
func (c ChildNodes) Len() int {
return len(c)
}
// Swap swaps list values.
func (c ChildNodes) Swap(i, j int) {
c[i], c[j] = c[j], c[i]
}
// Less returns true if i < j.
func (c ChildNodes) Less(i, j int) bool {
id1, id2 := c[i].ID, c[j].ID
return sortorder.NaturalLess(id1, id2)
}
// ----------------------------------------------------------------------------
// TreeNode represents a resource tree node.
type TreeNode struct {
GVR *client.GVR
ID string
Children ChildNodes
Parent *TreeNode
Extras map[string]string
}
// NewTreeNode returns a new instance.
func NewTreeNode(gvr *client.GVR, id string) *TreeNode {
return &TreeNode{
GVR: gvr,
ID: id,
Extras: map[string]string{StatusKey: OkStatus},
}
}
// CountChildren returns the children count.
func (t *TreeNode) CountChildren() int {
return len(t.Children)
}
// Count all the nodes from this node.
func (t *TreeNode) Count(gvr *client.GVR) int {
counter := 0
if t.GVR == gvr || gvr == client.NoGVR {
counter++
}
for _, c := range t.Children {
counter += c.Count(gvr)
}
return counter
}
// Diff computes a tree diff.
func (t *TreeNode) Diff(d *TreeNode) bool {
if t == nil {
return d != nil
}
if t.CountChildren() != d.CountChildren() {
return true
}
if t.ID != d.ID || t.GVR != d.GVR || !reflect.DeepEqual(t.Extras, d.Extras) {
return true
}
for i := 0; i < len(t.Children); i++ {
if t.Children[i].Diff(d.Children[i]) {
return true
}
}
return false
}
// Sort sorts the tree nodes.
func (t *TreeNode) Sort() {
sort.Sort(t.Children)
for _, c := range t.Children {
c.Sort()
}
}
// Spec returns this node specification.
func (t *TreeNode) Spec() NodeSpec {
var gvrs client.GVRs
var paths, statuses []string
for parent := t; parent != nil; parent = parent.Parent {
gvrs = append(gvrs, parent.GVR)
paths = append(paths, parent.ID)
statuses = append(statuses, parent.Extras[StatusKey])
}
return NodeSpec{
GVRs: gvrs,
Paths: paths,
Statuses: statuses,
}
}
// Flatten returns a collection of node specs.
func (t *TreeNode) Flatten() []NodeSpec {
refs := make([]NodeSpec, 0, len(t.Children))
for _, c := range t.Children {
if c.IsLeaf() {
refs = append(refs, c.Spec())
continue
}
refs = append(refs, c.Flatten()...)
}
return refs
}
// Blank returns true if this node is unset.
func (t *TreeNode) Blank() bool {
return t.GVR == client.NoGVR && t.ID == ""
}
// Hydrate hydrates a full tree bases on a collection of specifications.
func Hydrate(specs []NodeSpec) *TreeNode {
root := NewTreeNode(client.NoGVR, "")
nav := root
for _, spec := range specs {
for i := len(spec.Paths) - 1; i >= 0; i-- {
if nav.Blank() {
nav.GVR, nav.ID, nav.Extras[StatusKey] = spec.GVRs[i], spec.Paths[i], spec.Statuses[i]
continue
}
c := NewTreeNode(spec.GVRs[i], spec.Paths[i])
c.Extras[StatusKey] = spec.Statuses[i]
if n := nav.Find(spec.GVRs[i], spec.Paths[i]); n == nil {
nav.Add(c)
nav = c
} else {
nav = n
}
}
nav = root
}
return root
}
// Level computes the current node level.
func (t *TreeNode) Level() int {
var level int
p := t
for p != nil {
p = p.Parent
level++
}
return level - 1
}
// MaxDepth computes the max tree depth.
func (t *TreeNode) MaxDepth(depth int) int {
max := depth
for _, c := range t.Children {
m := c.MaxDepth(depth + 1)
if m > max {
max = m
}
}
return max
}
// Root returns the current tree root node.
func (t *TreeNode) Root() *TreeNode {
for p := t; p != nil; p = p.Parent {
if p.Parent == nil {
return p
}
}
return nil
}
// IsLeaf returns true if node has no children.
func (t *TreeNode) IsLeaf() bool {
return t.CountChildren() == 0
}
// IsRoot returns true if node is top node.
func (t *TreeNode) IsRoot() bool {
return t.Parent == nil
}
// ShallowClone performs a shallow node clone.
func (t *TreeNode) ShallowClone() *TreeNode {
return &TreeNode{GVR: t.GVR, ID: t.ID, Extras: t.Extras}
}
// Filter filters the node based on query.
func (t *TreeNode) Filter(q string, filter func(q, path string) bool) *TreeNode {
specs := t.Flatten()
matches := make([]NodeSpec, 0, len(specs))
for _, s := range specs {
if filter(q, s.AsPath()+s.AsStatus()) {
matches = append(matches, s)
}
}
if len(matches) == 0 {
return nil
}
return Hydrate(matches)
}
// Add adds a new child node.
func (t *TreeNode) Add(c *TreeNode) {
c.Parent = t
t.Children = append(t.Children, c)
}
// Clear delete all descendant nodes.
func (t *TreeNode) Clear() {
t.Children = []*TreeNode{}
}
// Find locates a node given a gvr/id spec.
func (t *TreeNode) Find(gvr *client.GVR, id string) *TreeNode {
if t.GVR == gvr && t.ID == id {
return t
}
for _, c := range t.Children {
if v := c.Find(gvr, id); v != nil {
return v
}
}
return nil
}
// Title computes the node title.
func (t *TreeNode) Title(noIcons bool) string {
return t.computeTitle(noIcons)
}
// ----------------------------------------------------------------------------
// Helpers...
// Dump for debug...
func (t *TreeNode) Dump() {
dump(t, 0)
}
func dump(n *TreeNode, level int) {
if n == nil {
slog.Debug("NO DATA!!")
return
}
slog.Debug(fmt.Sprintf("%s%s::%s\n", strings.Repeat(" ", level), n.GVR, n.ID))
for _, c := range n.Children {
dump(c, level+1)
}
}
// DumpStdOut to stdout for debug.
func (t *TreeNode) DumpStdOut() {
dumpStdOut(t, 0)
}
func dumpStdOut(n *TreeNode, level int) {
if n == nil {
fmt.Println("NO DATA!!")
return
}
fmt.Printf("%s%s::%s\n", strings.Repeat(" ", level), n.GVR, n.ID)
for _, c := range n.Children {
dumpStdOut(c, level+1)
}
}
func category(gvr *client.GVR) string {
meta, err := dao.MetaAccess.MetaFor(gvr)
if err != nil {
return ""
}
return meta.SingularName
}
func (t TreeNode) computeTitle(noIcons bool) string {
if !noIcons {
return t.toEmojiTitle()
}
return t.toTitle()
}
const (
titleFmt = " [gray::-]%s/[white::b][%s::b]%s[::]"
topTitleFmt = " [white::b][%s::b]%s[::]"
toast = "TOAST"
)
func (t TreeNode) toTitle() (title string) {
_, n := client.Namespaced(t.ID)
color, status := "white", "OK"
if v, ok := t.Extras[StatusKey]; ok {
switch v {
case ToastStatus:
color, status = "orangered", toast
case MissingRefStatus:
color, status = "orange", toast+"_REF"
}
}
defer func() {
if status != "OK" {
title += fmt.Sprintf(" [gray::-][yellow:%s:b]%s[gray::-]", color, status)
}
}()
categ := category(t.GVR)
if categ == "" {
title = fmt.Sprintf(topTitleFmt, color, n)
} else {
title = fmt.Sprintf(titleFmt, categ, color, n)
}
if !t.IsLeaf() {
title += fmt.Sprintf("[white::d](%d[-::d])[-::-]", t.CountChildren())
}
info, ok := t.Extras[InfoKey]
if !ok {
return
}
title += fmt.Sprintf(" [antiquewhite::][%s][::]", info)
return
}
const colorFmt = "%s [%s::b]%s[::]"
func (t TreeNode) toEmojiTitle() (title string) {
_, n := client.Namespaced(t.ID)
color, status := "white", "OK"
if v, ok := t.Extras[StatusKey]; ok {
switch v {
case ToastStatus:
color, status = "orangered", toast
case MissingRefStatus:
color, status = "orange", toast+"_REF"
}
}
defer func() {
if status != "OK" {
title += fmt.Sprintf(" [gray::-][yellow:%s:b]%s[gray::-]", color, status)
}
}()
title = fmt.Sprintf(colorFmt, toEmoji(t.GVR), color, n)
if !t.IsLeaf() {
title += fmt.Sprintf("[white::d](%d[-::d])[-::-]", t.CountChildren())
}
info, ok := t.Extras[InfoKey]
if !ok {
return
}
title += fmt.Sprintf(" [antiquewhite::][%s][::]", info)
return
}
func toEmoji(gvr *client.GVR) string {
if e := v1Emoji(gvr); e != "" {
return e
}
if e := appsEmoji(gvr); e != "" {
return e
}
if e := issueEmoji(gvr.String()); e != "" {
return e
}
switch gvr {
case client.HpaGVR:
return "♎️"
case client.CrGVR, client.CrbGVR:
return "👩"
case client.RoGVR, client.RobGVR:
return "👨🏻"
case client.NpGVR:
return "📕"
case client.PdbGVR:
return "🏷 "
case client.PspGVR:
return "👮♂️"
case client.CoGVR:
return "🐳"
case client.NewGVR("report"):
return "🧼"
default:
return "📎"
}
}
func issueEmoji(gvr string) string {
switch gvr {
case "issue_0":
return "👍"
case "issue_1":
return "🔊"
case "issue_2":
return "☣️ "
case "issue_3":
return "🧨"
default:
return ""
}
}
func v1Emoji(gvr *client.GVR) string {
switch gvr {
case client.NsGVR:
return "🗂 "
case client.NodeGVR:
return "🖥 "
case client.PodGVR:
return "🚛"
case client.SvcGVR:
return "💁♀️"
case client.SaGVR:
return "💳"
case client.PvGVR:
return "📚"
case client.PvcGVR:
return "🎟 "
case client.SecGVR:
return "🔒"
case client.CmGVR:
return "🗺 "
default:
return ""
}
}
func appsEmoji(gvr *client.GVR) string {
switch gvr {
case client.DpGVR:
return "🪂"
case client.StsGVR:
return "🎎"
case client.DsGVR:
return "😈"
case client.RsGVR:
return "👯♂️"
default:
return ""
}
}
// EmojiInfo returns emoji help.
func EmojiInfo() map[string]string {
gvrs := []*client.GVR{
client.CoGVR,
client.NsGVR,
client.PodGVR,
client.SvcGVR,
client.SaGVR,
client.PvGVR,
client.PvcGVR,
client.SecGVR,
client.CmGVR,
client.DpGVR,
client.StsGVR,
client.DsGVR,
}
m := make(map[string]string, len(gvrs))
for _, gvr := range gvrs {
m[gvr.R()] = toEmoji(gvr)
}
return m
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/svc.go | internal/xray/svc.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/render"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
// Service represents an xray renderer.
type Service struct{}
// Render renders an xray node.
func (s *Service) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
var svc v1.Service
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &svc)
if err != nil {
return err
}
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
root := NewTreeNode(client.SvcGVR, client.FQN(svc.Namespace, svc.Name))
oo, err := s.locatePods(ctx, svc.Namespace, svc.Spec.Selector)
if err != nil {
return err
}
ctx = context.WithValue(ctx, KeyParent, root)
var re Pod
for _, o := range oo {
p, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expecting *Unstructured but got %T", o)
}
if err := re.Render(ctx, ns, &render.PodWithMetrics{Raw: p}); err != nil {
return err
}
}
root.Extras[StatusKey] = OkStatus
if root.IsLeaf() {
return nil
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, svc.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(root)
return nil
}
func (s *Service) locatePods(ctx context.Context, ns string, sel map[string]string) ([]runtime.Object, error) {
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return nil, fmt.Errorf("expecting a factory but got %T", ctx.Value(internal.KeyFactory))
}
ll := make([]string, 0, len(sel))
for k, v := range sel {
ll = append(ll, fmt.Sprintf("%s=%s", k, v))
}
fsel, err := labels.ConvertSelectorToLabelsMap(strings.Join(ll, ","))
if err != nil {
return nil, err
}
return f.List(client.PodGVR, ns, false, fsel.AsSelector())
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/sa.go | internal/xray/sa.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
// ServiceAccount represents an xray renderer.
type ServiceAccount struct{}
// Render renders an xray node.
func (s *ServiceAccount) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("ServiceAccount render expecting *Unstructured, but got %T", o)
}
var sa v1.ServiceAccount
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &sa)
if err != nil {
return err
}
f, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
if !ok {
return fmt.Errorf("no factory found in context")
}
node := NewTreeNode(client.SaGVR, client.FQN(sa.Namespace, sa.Name))
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
parent.Add(node)
for _, sec := range sa.Secrets {
addRef(f, node, client.SecGVR, client.FQN(sa.Namespace, sec.Name), nil)
}
for _, sec := range sa.ImagePullSecrets {
addRef(f, node, client.SecGVR, client.FQN(sa.Namespace, sec.Name), nil)
}
auto, _ := ctx.Value(KeySAAutomount).(*bool)
return s.validate(node, sa, auto)
}
func (*ServiceAccount) validate(node *TreeNode, sa v1.ServiceAccount, auto *bool) error {
node.Extras[StatusKey] = OkStatus
if sa.AutomountServiceAccountToken != nil {
node.Extras[InfoKey] = fmt.Sprintf("automount=%t", *sa.AutomountServiceAccountToken)
}
if auto != nil {
node.Extras[InfoKey] = fmt.Sprintf("automount=%t", *auto)
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/section.go | internal/xray/section.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
)
// Section represents an xray renderer.
type Section struct {
render.Base
}
// Render renders an xray node.
func (s *Section) Render(ctx context.Context, ns string, o any) error {
section, ok := o.(render.Section)
if !ok {
return fmt.Errorf("expected Section, but got %T", o)
}
root := NewTreeNode(client.NewGVR(section.GVR), section.Title)
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
s.outcomeRefs(root, section)
parent.Add(root)
return nil
}
func (*Section) outcomeRefs(parent *TreeNode, section render.Section) {
for k, issues := range section.Outcome {
p := NewTreeNode(client.NewGVR(section.GVR), cleanse(k))
parent.Add(p)
for _, issue := range issues {
msg := colorize(cleanse(issue.Message), issue.Level)
c := NewTreeNode(client.NewGVR(fmt.Sprintf("issue_%d", issue.Level)), msg)
if issue.Group == "__root__" {
p.Add(c)
continue
}
if pa := p.Find(client.NewGVR(issue.GVR), issue.Group); pa != nil {
pa.Add(c)
continue
}
pa := NewTreeNode(client.NewGVR(issue.GVR), issue.Group)
pa.Add(c)
p.Add(pa)
}
}
}
// ----------------------------------------------------------------------------
// Helpers...
func colorize(s string, l render.Level) string {
c := "green"
// nolint:exhaustive
switch l {
case render.ErrorLevel:
c = "red"
case render.WarnLevel:
c = "orange"
case render.InfoLevel:
c = "blue"
}
return fmt.Sprintf("[%s::]%s", c, s)
}
func cleanse(s string) string {
s = strings.ReplaceAll(s, "[", "(")
s = strings.ReplaceAll(s, "]", ")")
s = strings.ReplaceAll(s, "/", "::")
return s
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/dp_test.go | internal/xray/dp_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/runtime"
)
func TestDeployRender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "dp",
level1: 1,
level2: 1,
status: xray.OkStatus,
},
}
var re xray.Deployment
for k := range uu {
f := makeFactory()
f.rows = map[*client.GVR][]runtime.Object{
client.PodGVR: {load(t, "po")},
client.SaGVR: {load(t, "sa")},
}
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.DpGVR, "deployments")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, f)
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/svc_test.go | internal/xray/svc_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/runtime"
)
func TestServiceRender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "svc",
level1: 1,
level2: 1,
status: xray.OkStatus,
},
}
var re xray.Service
for k := range uu {
f := makeFactory()
f.rows = map[*client.GVR][]runtime.Object{client.PodGVR: {load(t, "po")}}
u := uu[k]
t.Run(k, func(t *testing.T) {
o := load(t, u.file)
root := xray.NewTreeNode(client.SvcGVR, "services")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, f)
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/sts.go | internal/xray/sts.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
appsv1 "k8s.io/api/apps/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
// StatefulSet represents an xray renderer.
type StatefulSet struct{}
// Render renders an xray node.
func (s *StatefulSet) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
var sts appsv1.StatefulSet
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &sts)
if err != nil {
return err
}
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
root := NewTreeNode(client.StsGVR, client.FQN(sts.Namespace, sts.Name))
oo, err := locatePods(ctx, sts.Namespace, sts.Spec.Selector)
if err != nil {
return err
}
ctx = context.WithValue(ctx, KeyParent, root)
var re Pod
for _, o := range oo {
p, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expecting *Unstructured but got %T", o)
}
if err := re.Render(ctx, ns, &render.PodWithMetrics{Raw: p}); err != nil {
return err
}
}
if root.IsLeaf() {
return nil
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, sts.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(root)
return s.validate(root, sts)
}
func (*StatefulSet) validate(root *TreeNode, sts appsv1.StatefulSet) error {
root.Extras[StatusKey] = OkStatus
var r int32
if sts.Spec.Replicas != nil {
r = int32(*sts.Spec.Replicas)
}
a := sts.Status.CurrentReplicas
if a != r {
root.Extras[StatusKey] = ToastStatus
}
root.Extras[InfoKey] = fmt.Sprintf("%d/%d", a, 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/xray/tree_node_test.go | internal/xray/tree_node_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"regexp"
"strings"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
)
func TestTreeNodeCount(t *testing.T) {
uu := map[string]struct {
root *xray.TreeNode
e int
}{
"simple": {
root: root1(),
e: 3,
},
"complex": {
root: root3(),
e: 26,
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.root.Count(client.NoGVR))
})
}
}
func TestTreeNodeFilter(t *testing.T) {
uu := map[string]struct {
q string
root, e *xray.TreeNode
}{
"filter_simple": {
root: root1(),
e: diff1(),
q: "c1",
},
"filter_complex": {
root: root2(),
e: diff2(),
q: "c2",
},
"filter_no_match": {
root: root2(),
e: nil,
q: "bozo",
},
"filter_all_match": {
root: root2(),
e: root2(),
q: "",
},
"filter_complex1": {
root: root3(),
e: diff3(),
q: "coredns",
},
}
rx := func(q, path string) bool {
rx := regexp.MustCompile(`(?i)` + q)
tokens := strings.Split(path, "::")
for _, t := range tokens {
if rx.MatchString(t) {
return true
}
}
return false
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
filtered := u.root.Filter(u.q, rx)
assert.Equal(t, u.e, filtered)
})
}
}
func TestTreeNodeHydrate(t *testing.T) {
threeOK := []string{"ok", "ok", "ok"}
fiveOK := append(threeOK, "ok", "ok")
uu := map[string]struct {
spec []xray.NodeSpec
e *xray.TreeNode
}{
"flat_simple": {
spec: []xray.NodeSpec{
{
GVRs: []*client.GVR{client.CoGVR, client.PodGVR},
Paths: []string{"c1", "default/p1"},
Statuses: threeOK,
},
{
GVRs: []*client.GVR{client.CoGVR, client.PodGVR},
Paths: []string{"c2", "default/p1"},
Statuses: threeOK,
},
},
e: root1(),
},
"flat_complex": {
spec: []xray.NodeSpec{
{
GVRs: []*client.GVR{client.SecGVR, client.CoGVR, client.PodGVR},
Paths: []string{"s1", "c1", "default/p1"},
Statuses: threeOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.CoGVR, client.PodGVR},
Paths: []string{"s2", "c2", "default/p1"},
Statuses: threeOK,
},
},
e: root2(),
},
"complex1": {
spec: []xray.NodeSpec{
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"default/default-token-rr22g", "default/nginx-6b866d578b-c6tcn", "default/nginx", "-/default", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.CmGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/coredns", "kube-system/coredns-6955765f44-89q2p", "kube-system/coredns", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/coredns-token-5cq9j", "kube-system/coredns-6955765f44-89q2p", "kube-system/coredns", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.CmGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/coredns", "kube-system/coredns-6955765f44-r9j9t", "kube-system/coredns", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/coredns-token-5cq9j", "kube-system/coredns-6955765f44-r9j9t", "kube-system/coredns", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/default-token-thzt8", "kube-system/metrics-server-6754dbc9df-88bk4", "kube-system/metrics-server", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kube-system/nginx-ingress-token-kff5q", "kube-system/nginx-ingress-controller-6fc5bcc8c9-cwp55", "kube-system/nginx-ingress-controller", "-/kube-system", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kubernetes-dashboard/kubernetes-dashboard-token-d6rt4", "kubernetes-dashboard/dashboard-metrics-scraper-7b64584c5c-c7b56", "kubernetes-dashboard/dashboard-metrics-scraper", "-/kubernetes-dashboard", "deployments"},
Statuses: fiveOK,
},
{
GVRs: []*client.GVR{client.SecGVR, client.PodGVR, client.DpGVR, client.NsGVR, client.DpGVR},
Paths: []string{"kubernetes-dashboard/kubernetes-dashboard-token-d6rt4", "kubernetes-dashboard/kubernetes-dashboard-79d9cd965-b4c7d", "kubernetes-dashboard/kubernetes-dashboard", "-/kubernetes-dashboard", "deployments"},
Statuses: fiveOK,
},
},
e: root3(),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
root := xray.Hydrate(u.spec)
assert.Equal(t, u.e.Flatten(), root.Flatten())
})
}
}
func TestTreeNodeFlatten(t *testing.T) {
uu := map[string]struct {
root *xray.TreeNode
e []xray.NodeSpec
}{
"flat_simple": {
root: root1(),
e: []xray.NodeSpec{
{
GVRs: []*client.GVR{client.CoGVR, client.PodGVR},
Paths: []string{"c1", "default/p1"},
Statuses: []string{"ok", "ok"},
},
{
GVRs: []*client.GVR{client.CoGVR, client.PodGVR},
Paths: []string{"c2", "default/p1"},
Statuses: []string{"ok", "ok"},
},
},
},
"flat_complex": {
root: root2(),
e: []xray.NodeSpec{
{
GVRs: []*client.GVR{client.SecGVR, client.CoGVR, client.PodGVR},
Paths: []string{"s1", "c1", "default/p1"},
Statuses: []string{"ok", "ok", "ok"},
},
{
GVRs: []*client.GVR{client.SecGVR, client.CoGVR, client.PodGVR},
Paths: []string{"s2", "c2", "default/p1"},
Statuses: []string{"ok", "ok", "ok"},
},
},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
flat := u.root.Flatten()
assert.Equal(t, u.e, flat)
})
}
}
func TestTreeNodeDiff(t *testing.T) {
uu := map[string]struct {
n1, n2 *xray.TreeNode
e bool
}{
"blank": {
n1: &xray.TreeNode{},
n2: &xray.TreeNode{},
},
"same": {
n1: xray.NewTreeNode(client.PodGVR, "default/p1"),
n2: xray.NewTreeNode(client.PodGVR, "default/p1"),
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, u.n1.Diff(u.n2))
})
}
}
func TestTreeNodeClone(t *testing.T) {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
n.Add(c1)
c := n.ShallowClone()
assert.Equal(t, n.GVR, c.GVR)
}
func TestTreeNodeRoot(t *testing.T) {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
c2 := xray.NewTreeNode(client.CoGVR, "c2")
n.Add(c1)
n.Add(c2)
assert.Equal(t, 2, n.CountChildren())
assert.Equal(t, n, n.Root())
assert.True(t, n.IsRoot())
assert.False(t, n.IsLeaf())
assert.Equal(t, n, c1.Root())
assert.False(t, c1.IsRoot())
assert.Equal(t, n, c2.Root())
assert.True(t, c1.IsLeaf())
}
func TestTreeNodeLevel(t *testing.T) {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
c2 := xray.NewTreeNode(client.CoGVR, "c2")
n.Add(c1)
n.Add(c2)
assert.Equal(t, 0, n.Level())
assert.Equal(t, 1, c1.Level())
assert.Equal(t, 1, c2.Level())
}
func TestTreeNodeMaxDepth(t *testing.T) {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
c2 := xray.NewTreeNode(client.CoGVR, "c2")
n.Add(c1)
n.Add(c2)
assert.Equal(t, 1, n.MaxDepth(0))
}
// ----------------------------------------------------------------------------
// Helpers...
func root1() *xray.TreeNode {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
c2 := xray.NewTreeNode(client.CoGVR, "c2")
n.Add(c1)
n.Add(c2)
return n
}
func diff1() *xray.TreeNode {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c1")
n.Add(c1)
return n
}
func root2() *xray.TreeNode {
c1 := xray.NewTreeNode(client.CoGVR, "c1")
s1 := xray.NewTreeNode(client.SecGVR, "s1")
c1.Add(s1)
c2 := xray.NewTreeNode(client.CoGVR, "c2")
s2 := xray.NewTreeNode(client.SecGVR, "s2")
c2.Add(s2)
n := xray.NewTreeNode(client.PodGVR, "default/p1")
n.Add(c1)
n.Add(c2)
return n
}
func diff2() *xray.TreeNode {
n := xray.NewTreeNode(client.PodGVR, "default/p1")
c1 := xray.NewTreeNode(client.CoGVR, "c2")
n.Add(c1)
s1 := xray.NewTreeNode(client.SecGVR, "s2")
c1.Add(s1)
return n
}
func root3() *xray.TreeNode {
n := xray.NewTreeNode(client.DpGVR, "deployments")
ns1 := xray.NewTreeNode(client.NsGVR, "-/default")
n.Add(ns1)
{
d1 := xray.NewTreeNode(client.DpGVR, "default/nginx")
ns1.Add(d1)
{
p1 := xray.NewTreeNode(client.PodGVR, "default/nginx-6b866d578b-c6tcn")
d1.Add(p1)
{
s1 := xray.NewTreeNode(client.SecGVR, "default/default-token-rr22g")
p1.Add(s1)
}
}
}
ns2 := xray.NewTreeNode(client.NsGVR, "-/kube-system")
n.Add(ns2)
{
d2 := xray.NewTreeNode(client.DpGVR, "kube-system/coredns")
ns2.Add(d2)
{
p2 := xray.NewTreeNode(client.PodGVR, "kube-system/coredns-6955765f44-89q2p")
d2.Add(p2)
{
c1 := xray.NewTreeNode(client.CmGVR, "kube-system/coredns")
p2.Add(c1)
s2 := xray.NewTreeNode(client.SecGVR, "kube-system/coredns-token-5cq9j")
p2.Add(s2)
}
p3 := xray.NewTreeNode(client.PodGVR, "kube-system/coredns-6955765f44-r9j9t")
d2.Add(p3)
{
c2 := xray.NewTreeNode(client.CmGVR, "kube-system/coredns")
p3.Add(c2)
s3 := xray.NewTreeNode(client.SecGVR, "kube-system/coredns-token-5cq9j")
p3.Add(s3)
}
}
d3 := xray.NewTreeNode(client.DpGVR, "kube-system/metrics-server")
ns2.Add(d3)
{
p3 := xray.NewTreeNode(client.PodGVR, "kube-system/metrics-server-6754dbc9df-88bk4")
d3.Add(p3)
{
s4 := xray.NewTreeNode(client.SecGVR, "kube-system/default-token-thzt8")
p3.Add(s4)
}
}
d4 := xray.NewTreeNode(client.DpGVR, "kube-system/nginx-ingress-controller")
ns2.Add(d4)
{
p4 := xray.NewTreeNode(client.PodGVR, "kube-system/nginx-ingress-controller-6fc5bcc8c9-cwp55")
d4.Add(p4)
{
s5 := xray.NewTreeNode(client.SecGVR, "kube-system/nginx-ingress-token-kff5q")
p4.Add(s5)
}
}
}
ns3 := xray.NewTreeNode(client.NsGVR, "-/kubernetes-dashboard")
n.Add(ns3)
{
d5 := xray.NewTreeNode(client.DpGVR, "kubernetes-dashboard/dashboard-metrics-scraper")
ns3.Add(d5)
{
p5 := xray.NewTreeNode(client.PodGVR, "kubernetes-dashboard/dashboard-metrics-scraper-7b64584c5c-c7b56")
d5.Add(p5)
{
s6 := xray.NewTreeNode(client.SecGVR, "kubernetes-dashboard/kubernetes-dashboard-token-d6rt4")
p5.Add(s6)
}
}
d6 := xray.NewTreeNode(client.DpGVR, "kubernetes-dashboard/kubernetes-dashboard")
ns3.Add(d6)
{
p6 := xray.NewTreeNode(client.PodGVR, "kubernetes-dashboard/kubernetes-dashboard-79d9cd965-b4c7d")
d6.Add(p6)
{
s6 := xray.NewTreeNode(client.SecGVR, "kubernetes-dashboard/kubernetes-dashboard-token-d6rt4")
p6.Add(s6)
}
}
}
return n
}
func diff3() *xray.TreeNode {
n := xray.NewTreeNode(client.DpGVR, "deployments")
ns2 := xray.NewTreeNode(client.NsGVR, "-/kube-system")
n.Add(ns2)
{
d2 := xray.NewTreeNode(client.DpGVR, "kube-system/coredns")
ns2.Add(d2)
{
p2 := xray.NewTreeNode(client.PodGVR, "kube-system/coredns-6955765f44-89q2p")
d2.Add(p2)
{
c1 := xray.NewTreeNode(client.CmGVR, "kube-system/coredns")
p2.Add(c1)
s2 := xray.NewTreeNode(client.SecGVR, "kube-system/coredns-token-5cq9j")
p2.Add(s2)
}
p3 := xray.NewTreeNode(client.PodGVR, "kube-system/coredns-6955765f44-r9j9t")
d2.Add(p3)
{
c2 := xray.NewTreeNode(client.CmGVR, "kube-system/coredns")
p3.Add(c2)
s3 := xray.NewTreeNode(client.SecGVR, "kube-system/coredns-token-5cq9j")
p3.Add(s3)
}
}
}
return n
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/rs.go | internal/xray/rs.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray
import (
"context"
"fmt"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/render"
appsv1 "k8s.io/api/apps/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime"
)
// ReplicaSet represents an xray renderer.
type ReplicaSet struct{}
// Render renders an xray node.
func (r *ReplicaSet) Render(ctx context.Context, ns string, o any) error {
raw, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expected Unstructured, but got %T", o)
}
var rs appsv1.ReplicaSet
err := runtime.DefaultUnstructuredConverter.FromUnstructured(raw.Object, &rs)
if err != nil {
return err
}
parent, ok := ctx.Value(KeyParent).(*TreeNode)
if !ok {
return fmt.Errorf("expecting a TreeNode but got %T", ctx.Value(KeyParent))
}
root := NewTreeNode(client.RsGVR, client.FQN(rs.Namespace, rs.Name))
oo, err := locatePods(ctx, rs.Namespace, rs.Spec.Selector)
if err != nil {
return err
}
ctx = context.WithValue(ctx, KeyParent, root)
var re Pod
for _, o := range oo {
p, ok := o.(*unstructured.Unstructured)
if !ok {
return fmt.Errorf("expecting *Unstructured but got %T", o)
}
if err := re.Render(ctx, ns, &render.PodWithMetrics{Raw: p}); err != nil {
return err
}
}
if root.IsLeaf() {
return nil
}
gvr, nsID := client.NsGVR, client.FQN(client.ClusterScope, rs.Namespace)
nsn := parent.Find(gvr, nsID)
if nsn == nil {
nsn = NewTreeNode(gvr, nsID)
parent.Add(nsn)
}
nsn.Add(root)
return r.validate(root, rs)
}
func (*ReplicaSet) validate(root *TreeNode, rs appsv1.ReplicaSet) error {
root.Extras[StatusKey] = OkStatus
var r int32
if rs.Spec.Replicas != nil {
r = int32(*rs.Spec.Replicas)
}
a := rs.Status.Replicas
if a != r {
root.Extras[StatusKey] = ToastStatus
}
root.Extras[InfoKey] = fmt.Sprintf("%d/%d", a, 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/xray/sts_test.go | internal/xray/sts_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"k8s.io/apimachinery/pkg/runtime"
)
func TestStatefulSetRender(t *testing.T) {
uu := map[string]struct {
file string
level1, level2 int
status string
}{
"plain": {
file: "sts",
level1: 1,
level2: 1,
status: xray.OkStatus,
},
}
var re xray.StatefulSet
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
f := makeFactory()
f.rows = map[*client.GVR][]runtime.Object{client.PodGVR: {load(t, "po")}}
o := load(t, u.file)
root := xray.NewTreeNode(client.StsGVR, "statefulsets")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, f)
require.NoError(t, re.Render(ctx, "", o))
assert.Equal(t, u.level1, root.CountChildren())
assert.Equal(t, u.level2, root.Children[0].CountChildren())
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/xray/generic_test.go | internal/xray/generic_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package xray_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/xray"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
metav1beta1 "k8s.io/apimachinery/pkg/apis/meta/v1beta1"
)
func TestGenericRender(t *testing.T) {
uu := map[string]struct {
level1 int
status string
}{
"plain": {
level1: 1,
status: xray.OkStatus,
},
}
var re xray.Generic
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
root := xray.NewTreeNode(client.NewGVR("generic"), "generics")
ctx := context.WithValue(context.Background(), xray.KeyParent, root)
ctx = context.WithValue(ctx, internal.KeyFactory, makeFactory())
require.NoError(t, re.Render(ctx, "", makeTable()))
assert.Equal(t, u.level1, root.CountChildren())
})
}
}
// Helpers...
func makeTable() metav1beta1.TableRow {
return metav1beta1.TableRow{
Cells: []any{"fred", "blee"},
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/perf/benchmark.go | internal/perf/benchmark.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package perf
import (
"bytes"
"context"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"time"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/slogs"
"github.com/rakyll/hey/requester"
)
const (
// BOZO!! Revisit bench and when we should timeout.
benchTimeout = 2 * time.Minute
benchFmat = "%s_%s_%d.txt"
k9sUA = "k9s/"
)
// Benchmark puts a workload under load.
type Benchmark struct {
canceled bool
config *config.BenchConfig
worker *requester.Work
cancelFn context.CancelFunc
mx sync.RWMutex
}
// NewBenchmark returns a new benchmark.
func NewBenchmark(base, version string, cfg *config.BenchConfig) (*Benchmark, error) {
b := Benchmark{config: cfg}
if err := b.init(base, version); err != nil {
return nil, err
}
return &b, nil
}
func (b *Benchmark) init(base, version string) error {
var ctx context.Context
ctx, b.cancelFn = context.WithTimeout(context.Background(), benchTimeout)
req, err := http.NewRequestWithContext(ctx, b.config.HTTP.Method, base, http.NoBody)
if err != nil {
return err
}
if b.config.Auth.User != "" || b.config.Auth.Password != "" {
req.SetBasicAuth(b.config.Auth.User, b.config.Auth.Password)
}
req.Header = b.config.HTTP.Headers
slog.Debug("Benchmarking Request", slogs.URL, req.URL.String())
ua := req.UserAgent()
if ua == "" {
ua = k9sUA
} else {
ua += " " + k9sUA
}
ua += version
if req.Header == nil {
req.Header = make(http.Header)
}
req.Header.Set("User-Agent", ua)
slog.Debug(fmt.Sprintf("Using bench config N:%d--C:%d", b.config.N, b.config.C))
b.worker = &requester.Work{
Request: req,
RequestBody: []byte(b.config.HTTP.Body),
N: b.config.N,
C: b.config.C,
H2: b.config.HTTP.HTTP2,
}
return nil
}
// Cancel kills the benchmark in progress.
func (b *Benchmark) Cancel() {
if b == nil {
return
}
b.mx.Lock()
defer b.mx.Unlock()
b.canceled = true
if b.cancelFn != nil {
b.cancelFn()
b.cancelFn = nil
}
}
// Canceled checks if the benchmark was canceled.
func (b *Benchmark) Canceled() bool {
return b.canceled
}
// Run starts a benchmark.
func (b *Benchmark) Run(cluster, ct string, done func()) {
slog.Debug("Running benchmark",
slogs.Cluster, cluster,
slogs.Context, ct,
)
buff := new(bytes.Buffer)
b.worker.Writer = buff
// this call will block until the benchmark is complete or times out.
b.worker.Run()
b.worker.Stop()
if buff.Len() > 0 {
if err := b.save(cluster, ct, buff); err != nil {
slog.Error("Saving Benchmark", slogs.Error, err)
}
}
done()
}
func (b *Benchmark) save(cluster, ct string, r io.Reader) error {
ns, n := client.Namespaced(b.config.Name)
n = strings.ReplaceAll(n, "|", "_")
n = strings.ReplaceAll(n, ":", "_")
dir, err := config.EnsureBenchmarksDir(cluster, ct)
if err != nil {
return err
}
bf := filepath.Join(dir, fmt.Sprintf(benchFmat, ns, n, time.Now().UnixNano()))
if e := data.EnsureDirPath(bf, data.DefaultDirMod); e != nil {
return e
}
f, err := os.Create(bf)
if err != nil {
return err
}
defer func() {
if e := f.Close(); e != nil {
slog.Error("Benchmark file close failed",
slogs.Error, e,
slogs.Path, bf,
)
}
}()
if _, err = io.Copy(f, r); err != nil {
return err
}
return nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/details.go | internal/view/details.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"io"
"strings"
"github.com/derailed/k9s/internal/config"
"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"
"github.com/sahilm/fuzzy"
"k8s.io/apimachinery/pkg/labels"
)
const (
detailsTitleFmt = "[fg:bg:b] %s([hilite:bg:b]%s[fg:bg:-])[fg:bg:-] "
contentTXT = "text"
contentYAML = "yaml"
)
// Details represents a generic text viewer.
type Details struct {
*tview.Flex
text *tview.TextView
actions *ui.KeyActions
app *App
title, subject string
cmdBuff *model.FishBuff
model *model.Text
currentRegion, maxRegions int
searchable bool
fullScreen bool
contentType string
}
// NewDetails returns a details viewer.
func NewDetails(app *App, title, subject, contentType string, searchable bool) *Details {
d := Details{
Flex: tview.NewFlex(),
text: tview.NewTextView(),
app: app,
title: title,
subject: subject,
actions: ui.NewKeyActions(),
cmdBuff: model.NewFishBuff('/', model.FilterBuffer),
model: model.NewText(),
searchable: searchable,
contentType: contentType,
}
d.AddItem(d.text, 0, 1, true)
return &d
}
func (*Details) SetCommand(*cmd.Interpreter) {}
func (*Details) SetFilter(string, bool) {}
func (*Details) SetLabelSelector(labels.Selector, bool) {}
// Init initializes the viewer.
func (d *Details) Init(_ context.Context) error {
if d.title != "" {
d.SetBorder(true)
}
d.text.SetScrollable(true).SetWrap(true).SetRegions(true)
d.text.SetDynamicColors(true)
d.text.SetHighlightColor(tcell.ColorOrange)
d.SetTitleColor(tcell.ColorAqua)
d.SetInputCapture(d.keyboard)
d.SetBorderPadding(0, 0, 1, 1)
d.updateTitle()
d.app.Styles.AddListener(d)
d.StylesChanged(d.app.Styles)
d.setFullScreen(d.app.Config.K9s.UI.DefaultsToFullScreen)
d.app.Prompt().SetModel(d.cmdBuff)
d.cmdBuff.AddListener(d)
d.bindKeys()
d.SetInputCapture(d.keyboard)
d.model.AddListener(d)
return nil
}
// InCmdMode checks if prompt is active.
func (d *Details) InCmdMode() bool {
return d.cmdBuff.InCmdMode()
}
// TextChanged notifies the model changed.
func (d *Details) TextChanged(lines []string) {
switch d.contentType {
case contentYAML:
d.text.SetText(colorizeYAML(d.app.Styles.Views().Yaml, strings.Join(lines, "\n")))
default:
d.text.SetText(strings.Join(lines, "\n"))
}
d.text.ScrollToBeginning()
}
// TextFiltered notifies when the filter changed.
func (d *Details) TextFiltered(lines []string, matches fuzzy.Matches) {
d.currentRegion, d.maxRegions = 0, len(matches)
ll := linesWithRegions(lines, matches)
d.text.SetText(colorizeYAML(d.app.Styles.Views().Yaml, strings.Join(ll, "\n")))
d.text.Highlight()
if len(matches) > 0 {
d.text.Highlight("search_0")
d.text.ScrollToHighlight()
}
}
// BufferChanged indicates the buffer was changed.
func (*Details) BufferChanged(_, _ string) {}
// BufferCompleted indicates input was accepted.
func (d *Details) BufferCompleted(text, _ string) {
d.model.Filter(text)
d.updateTitle()
}
// BufferActive indicates the buff activity changed.
func (d *Details) BufferActive(state bool, k model.BufferKind) {
d.app.BufferActive(state, k)
}
func (d *Details) bindKeys() {
d.actions.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewSharedKeyAction("Filter", d.filterCmd, false),
tcell.KeyEscape: ui.NewKeyAction("Back", d.resetCmd, false),
ui.KeyQ: ui.NewKeyAction("Back", d.resetCmd, false),
tcell.KeyCtrlS: ui.NewKeyAction("Save", d.saveCmd, false),
ui.KeyC: ui.NewKeyAction("Copy", cpCmd(d.app.Flash(), d.text), true),
ui.KeyF: ui.NewKeyAction("Toggle FullScreen", d.toggleFullScreenCmd, true),
ui.KeyN: ui.NewKeyAction("Next Match", d.nextCmd, true),
ui.KeyShiftN: ui.NewKeyAction("Prev Match", d.prevCmd, true),
ui.KeySlash: ui.NewSharedKeyAction("Filter Mode", d.activateCmd, false),
tcell.KeyDelete: ui.NewSharedKeyAction("Erase", d.eraseCmd, false),
})
if !d.searchable {
d.actions.Delete(ui.KeyN, ui.KeyShiftN)
}
}
func (d *Details) keyboard(evt *tcell.EventKey) *tcell.EventKey {
if a, ok := d.actions.Get(ui.AsKey(evt)); ok {
return a.Action(evt)
}
return evt
}
// StylesChanged notifies the skin changed.
func (d *Details) StylesChanged(s *config.Styles) {
d.SetBackgroundColor(s.BgColor())
d.text.SetTextColor(s.FgColor())
d.SetBorderFocusColor(s.Frame().Border.FocusColor.Color())
d.TextChanged(d.model.Peek())
}
// Update updates the view content.
func (d *Details) Update(buff string) *Details {
d.model.SetText(buff)
return d
}
func (d *Details) GetWriter() io.Writer {
return d.text
}
// SetSubject updates the subject.
func (d *Details) SetSubject(s string) {
d.subject = s
}
// Actions returns menu actions.
func (d *Details) Actions() *ui.KeyActions {
return d.actions
}
// Name returns the component name.
func (d *Details) Name() string { return d.title }
// Start starts the view updater.
func (*Details) Start() {}
// Stop terminates the updater.
func (d *Details) Stop() {
d.app.Styles.RemoveListener(d)
}
// Hints returns menu hints.
func (d *Details) Hints() model.MenuHints {
return d.actions.Hints()
}
// ExtraHints returns additional hints.
func (*Details) ExtraHints() map[string]string {
return nil
}
func (d *Details) nextCmd(evt *tcell.EventKey) *tcell.EventKey {
if d.cmdBuff.Empty() {
return evt
}
d.currentRegion++
if d.currentRegion >= d.maxRegions {
d.currentRegion = 0
}
d.text.Highlight(fmt.Sprintf("search_%d", d.currentRegion))
d.text.ScrollToHighlight()
d.updateTitle()
return nil
}
func (d *Details) toggleFullScreenCmd(evt *tcell.EventKey) *tcell.EventKey {
if d.app.InCmdMode() {
return evt
}
d.setFullScreen(!d.fullScreen)
return nil
}
func (d *Details) setFullScreen(isFullScreen bool) {
d.fullScreen = isFullScreen
d.SetFullScreen(isFullScreen)
d.SetBorder(!isFullScreen)
if isFullScreen {
d.SetBorderPadding(0, 0, 0, 0)
} else {
d.SetBorderPadding(0, 0, 1, 1)
}
}
func (d *Details) prevCmd(evt *tcell.EventKey) *tcell.EventKey {
if d.cmdBuff.Empty() {
return evt
}
d.currentRegion--
if d.currentRegion < 0 {
d.currentRegion = d.maxRegions - 1
}
d.text.Highlight(fmt.Sprintf("search_%d", d.currentRegion))
d.text.ScrollToHighlight()
d.updateTitle()
return nil
}
func (d *Details) filterCmd(*tcell.EventKey) *tcell.EventKey {
d.model.Filter(d.cmdBuff.GetText())
d.cmdBuff.SetActive(false)
d.updateTitle()
return nil
}
func (d *Details) activateCmd(evt *tcell.EventKey) *tcell.EventKey {
if d.app.InCmdMode() {
return evt
}
d.app.ResetPrompt(d.cmdBuff)
return nil
}
func (d *Details) eraseCmd(*tcell.EventKey) *tcell.EventKey {
if !d.cmdBuff.IsActive() {
return nil
}
d.cmdBuff.Delete()
return nil
}
func (d *Details) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !d.cmdBuff.InCmdMode() {
d.cmdBuff.Reset()
return d.app.PrevCmd(evt)
}
if d.cmdBuff.GetText() != "" {
d.model.ClearFilter()
}
d.cmdBuff.SetActive(false)
d.cmdBuff.Reset()
d.updateTitle()
return nil
}
func (d *Details) saveCmd(*tcell.EventKey) *tcell.EventKey {
if path, err := saveYAML(d.app.Config.K9s.ContextScreenDumpDir(), d.title, d.text.GetText(true)); err != nil {
d.app.Flash().Err(err)
} else {
d.app.Flash().Infof("Log %s saved successfully!", path)
}
return nil
}
func (d *Details) updateTitle() {
if d.title == "" {
return
}
fmat := fmt.Sprintf(detailsTitleFmt, d.title, d.subject)
var (
buff = d.cmdBuff.GetText()
styles = d.app.Styles.Frame()
)
if buff == "" {
d.SetTitle(ui.SkinTitle(fmat, &styles))
return
}
if d.maxRegions != 0 {
buff += fmt.Sprintf("[%d:%d]", d.currentRegion+1, d.maxRegions)
}
fmat += fmt.Sprintf(ui.SearchFmt, buff)
d.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/exec.go | internal/view/exec.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"log/slog"
"os"
"os/exec"
"os/signal"
"strings"
"syscall"
"time"
"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/dialog"
"github.com/fatih/color"
v1 "k8s.io/api/core/v1"
kerrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
const (
shellCheck = `command -v bash >/dev/null && exec bash || exec sh`
bannerFmt = "<<K9s-Shell>> Pod: %s | Container: %s \n"
outputPrefix = "[output]"
)
var editorEnvVars = []string{"K9S_EDITOR", "KUBE_EDITOR", "EDITOR"}
type shellOpts struct {
clear, background bool
pipes []string
binary string
banner string
args []string
}
func (s shellOpts) String() string {
return fmt.Sprintf("%s %s", s.binary, strings.Join(s.args, " "))
}
func runK(a *App, opts *shellOpts) error {
bin, err := exec.LookPath("kubectl")
if errors.Is(err, exec.ErrDot) {
return fmt.Errorf("kubectl command must not be in the current working directory: %w", err)
}
if err != nil {
return fmt.Errorf("kubectl command is not in your path: %w", err)
}
args := []string{opts.args[0]}
if u, err := a.Conn().Config().ImpersonateUser(); err == nil {
args = append(args, "--as", u)
}
if g, err := a.Conn().Config().ImpersonateGroups(); err == nil {
args = append(args, "--as-group", g)
}
if isInsecure := a.Conn().Config().Flags().Insecure; isInsecure != nil && *isInsecure {
args = append(args, "--insecure-skip-tls-verify")
}
args = append(args, "--context", a.Config.K9s.ActiveContextName())
if cfg := a.Conn().Config().Flags().KubeConfig; cfg != nil && *cfg != "" {
args = append(args, "--kubeconfig", *cfg)
}
if len(args) > 0 {
opts.args = append(args, opts.args[1:]...)
}
opts.binary = bin
suspended, errChan, stChan := run(a, opts)
if !suspended {
return fmt.Errorf("unable to run command")
}
for v := range stChan {
slog.Debug("stdout", slogs.Line, v)
}
var errs error
for e := range errChan {
errs = errors.Join(errs, e)
}
return errs
}
func run(a *App, opts *shellOpts) (ok bool, errC chan error, outC chan string) {
errChan := make(chan error, 1)
statusChan := make(chan string, 1)
if opts.background {
if err := execute(opts, statusChan); err != nil {
errChan <- err
a.Flash().Errf("Exec failed %q: %s", opts, err)
}
close(errChan)
return true, errChan, statusChan
}
a.Halt()
defer a.Resume()
return a.Suspend(func() {
if err := execute(opts, statusChan); err != nil {
errChan <- err
a.Flash().Errf("Exec failed %q: %s", opts, err)
}
close(errChan)
}), errChan, statusChan
}
func edit(a *App, opts *shellOpts) bool {
var (
bin string
err error
)
for _, e := range editorEnvVars {
env := os.Getenv(e)
if env == "" {
continue
}
// There may be situations where the user sets the editor as the binary
// followed by some arguments (e.g. "code -w" to make it work with vscode)
//
// In such cases, the actual binary is only the first token
envTokens := strings.Split(env, " ")
if bin, err = exec.LookPath(envTokens[0]); err == nil {
// Make sure the path is at the end (this allows running editors
// with custom options)
if len(envTokens) > 1 {
originalArgs := opts.args
opts.args = envTokens[1:]
opts.args = append(opts.args, originalArgs...)
}
break
}
}
if bin == "" {
a.Flash().Errf("You must set at least one of those env vars: %s", strings.Join(editorEnvVars, "|"))
return false
}
opts.binary, opts.background = bin, false
suspended, errChan, _ := run(a, opts)
if !suspended {
a.Flash().Errf("edit command failed")
}
status := true
for e := range errChan {
a.Flash().Err(e)
status = false
}
return status
}
func execute(opts *shellOpts, statusChan chan<- string) error {
if opts.clear {
clearScreen()
}
ctx, cancel := context.WithCancel(context.Background())
defer func() {
if !opts.background {
cancel()
clearScreen()
}
}()
var interrupted bool
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
go func(cancel context.CancelFunc) {
defer slog.Debug("Got signal canceled")
select {
case sig := <-sigChan:
slog.Debug("Command canceled with signal", slogs.Sig, sig)
cancel()
case <-ctx.Done():
slog.Debug("Signal context canceled!")
}
interrupted = true
}(cancel)
cmds := make([]*exec.Cmd, 0, 1)
cmd := exec.CommandContext(ctx, opts.binary, opts.args...)
slog.Debug("Exec command", slogs.Command, opts)
if env := os.Getenv("K9S_EDITOR"); env != "" {
// There may be situations where the user sets the editor as the binary
// followed by some arguments (e.g. "code -w" to make it work with vscode)
//
// In such cases, the actual binary is only the first token
binTokens := strings.Split(env, " ")
if bin, err := exec.LookPath(binTokens[0]); err == nil {
binTokens[0] = bin
cmd.Env = append(os.Environ(), fmt.Sprintf("KUBE_EDITOR=%s", strings.Join(binTokens, " ")))
}
}
cmds = append(cmds, cmd)
for _, p := range opts.pipes {
tokens := strings.Split(p, " ")
if len(tokens) < 2 {
continue
}
cmd := exec.CommandContext(ctx, tokens[0], tokens[1:]...)
slog.Debug("Exec command", slogs.Command, cmd)
cmds = append(cmds, cmd)
}
var o, e bytes.Buffer
err := pipe(ctx, opts, statusChan, &o, &e, cmds...)
if err != nil && !interrupted {
slog.Error("Pipe Exec failed",
slogs.Error, err,
slogs.Command, cmds,
)
return errors.Join(err, fmt.Errorf("%s", e.String()))
}
return nil
}
func runKu(ctx context.Context, a *App, opts *shellOpts) (string, error) {
bin, err := exec.LookPath("kubectl")
if errors.Is(err, exec.ErrDot) {
slog.Error("Kubectl exec can not reside in current working directory", slogs.Error, err)
return "", err
}
if err != nil {
slog.Error("Kubectl exec not found", slogs.Error, err)
return "", err
}
var args []string
if u, err := a.Conn().Config().ImpersonateUser(); err == nil {
args = append(args, "--as", u)
}
if g, err := a.Conn().Config().ImpersonateGroups(); err == nil {
args = append(args, "--as-group", g)
}
args = append(args, "--context", a.Config.K9s.ActiveContextName())
if cfg := a.Conn().Config().Flags().KubeConfig; cfg != nil && *cfg != "" {
args = append(args, "--kubeconfig", *cfg)
}
if len(args) > 0 {
opts.args = append(args, opts.args...)
}
opts.binary, opts.background = bin, false
return oneShoot(ctx, opts)
}
func oneShoot(ctx context.Context, opts *shellOpts) (string, error) {
if opts.clear {
clearScreen()
}
slog.Debug("Executing command",
slogs.Bin, opts.binary,
slogs.Args, strings.Join(opts.args, " "),
)
cmd := exec.CommandContext(ctx, opts.binary, opts.args...)
var err error
buff := bytes.NewBufferString("")
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, buff, buff
_, _ = cmd.Stdout.Write([]byte(opts.banner))
err = cmd.Run()
return strings.Trim(buff.String(), "\n"), err
}
func clearScreen() {
fmt.Print("\033[H\033[2J")
}
const (
k9sShell = "k9s-shell"
k9sShellRetryCount = 50
k9sShellRetryDelay = 2 * time.Second
)
func launchNodeShell(v model.Igniter, a *App, node string) {
if err := nukeK9sShell(a); err != nil {
a.Flash().Errf("Cleaning node shell failed: %s", err)
return
}
msg := fmt.Sprintf("Launching node shell on %s...", node)
d := a.Styles.Dialog()
dialog.ShowPrompt(&d, a.Content.Pages, "Launching", msg, func(ctx context.Context) {
err := launchShellPod(ctx, a, node)
if err != nil {
if !errors.Is(err, context.Canceled) {
a.Flash().Errf("Launching node shell failed: %s", err)
}
return
}
go launchPodShell(v, a)
}, func() {
if err := nukeK9sShell(a); err != nil {
a.Flash().Errf("Cleaning node shell failed: %s", err)
return
}
})
}
func launchPodShell(v model.Igniter, a *App) {
if a.Config.K9s.ShellPod == nil {
slog.Error("Shell pod not configured!")
return
}
defer func() {
if err := nukeK9sShell(a); err != nil {
a.Flash().Errf("Launching node shell failed: %s", err)
return
}
}()
v.Stop()
defer v.Start()
ns := a.Config.K9s.ShellPod.Namespace
if err := sshIn(a, client.FQN(ns, k9sShellPodName()), k9sShell); err != nil {
a.Flash().Errf("Launching node shell failed: %s", err)
}
}
func sshIn(a *App, fqn, co string) error {
cfg := a.Config.K9s.ShellPod
platform, err := getPodOS(a.factory, fqn)
if err != nil {
slog.Warn("os detect failed", slogs.Error, err)
}
args := buildShellArgs("exec", fqn, co, a.Conn().Config().Flags())
args = append(args, "--")
if len(cfg.Command) > 0 {
args = append(args, cfg.Command...)
args = append(args, cfg.Args...)
} else {
if platform == windowsOS {
args = append(args, "--", powerShell)
}
args = append(args, "sh", "-c", shellCheck)
}
slog.Debug("Running command with args", slogs.Args, args)
c := color.New(color.BgGreen).Add(color.FgBlack).Add(color.Bold)
err = runK(a, &shellOpts{
clear: true,
banner: c.Sprintf(bannerFmt, fqn, co),
args: args},
)
if err != nil {
return fmt.Errorf("shell exec failed: %w", err)
}
return nil
}
func nukeK9sShell(a *App) error {
ct, err := a.Config.K9s.ActiveContext()
if err != nil {
return err
}
if !ct.FeatureGates.NodeShell || a.Config.K9s.ShellPod == nil {
return nil
}
ns := a.Config.K9s.ShellPod.Namespace
ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()
dial, err := a.Conn().Dial()
if err != nil {
return err
}
err = dial.CoreV1().Pods(ns).Delete(ctx, k9sShellPodName(), metav1.DeleteOptions{})
if kerrors.IsNotFound(err) {
return nil
}
return err
}
func launchShellPod(ctx context.Context, a *App, node string) error {
var (
spo = a.Config.K9s.ShellPod
spec = k9sShellPod(node, spo)
)
dial, err := a.Conn().Dial()
if err != nil {
return err
}
conn := dial.CoreV1().Pods(spo.Namespace)
if _, err = conn.Create(ctx, spec, metav1.CreateOptions{}); err != nil {
return err
}
for i := range k9sShellRetryCount {
o, err := a.factory.Get(client.PodGVR, client.FQN(spo.Namespace, k9sShellPodName()), true, labels.Everything())
if err != nil {
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(k9sShellRetryDelay):
continue
}
}
var pod v1.Pod
if err := runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod); err != nil {
return err
}
slog.Debug("Checking k9s shell pod retries",
slogs.Retry, i,
slogs.PodPhase, pod.Status.Phase,
)
if pod.Status.Phase == v1.PodRunning {
return nil
}
select {
case <-ctx.Done():
return ctx.Err()
case <-time.After(k9sShellRetryDelay):
}
}
return fmt.Errorf("unable to launch shell pod on node %s", node)
}
func k9sShellPodName() string {
return fmt.Sprintf("%s-%d", k9sShell, os.Getpid())
}
func k9sShellPod(node string, cfg *config.ShellPod) *v1.Pod {
var grace int64
var priv = true
slog.Debug("Shell pod config", slogs.ShellPodCfg, cfg)
c := v1.Container{
Name: k9sShell,
Image: cfg.Image,
ImagePullPolicy: cfg.ImagePullPolicy,
VolumeMounts: []v1.VolumeMount{
{
Name: "root-vol",
MountPath: "/host",
ReadOnly: true,
},
},
Resources: asResource(cfg.Limits),
Stdin: true,
TTY: cfg.TTY,
SecurityContext: &v1.SecurityContext{
Privileged: &priv,
},
}
v := []v1.Volume{
{
Name: "root-vol",
VolumeSource: v1.VolumeSource{
HostPath: &v1.HostPathVolumeSource{
Path: "/",
},
},
},
}
if len(cfg.Command) != 0 {
c.Command = cfg.Command
}
if len(cfg.Args) > 0 {
c.Args = cfg.Args
}
if len(cfg.HostPathVolume) > 0 {
for _, h := range cfg.HostPathVolume {
c.VolumeMounts = append(c.VolumeMounts, v1.VolumeMount{
Name: h.Name,
MountPath: h.MountPath,
ReadOnly: h.ReadOnly,
})
v = append(v, v1.Volume{
Name: h.Name,
VolumeSource: v1.VolumeSource{
HostPath: &v1.HostPathVolumeSource{
Path: h.HostPath,
},
},
})
}
}
return &v1.Pod{
ObjectMeta: metav1.ObjectMeta{
Name: k9sShellPodName(),
Namespace: cfg.Namespace,
Labels: cfg.Labels,
},
Spec: v1.PodSpec{
NodeName: node,
RestartPolicy: v1.RestartPolicyNever,
HostPID: true,
HostNetwork: true,
ImagePullSecrets: cfg.ImagePullSecrets,
TerminationGracePeriodSeconds: &grace,
Volumes: v,
Containers: []v1.Container{c},
Tolerations: []v1.Toleration{
{
Operator: v1.TolerationOperator("Exists"),
},
},
},
}
}
func asResource(r config.Limits) v1.ResourceRequirements {
return v1.ResourceRequirements{
Limits: v1.ResourceList{
v1.ResourceCPU: resource.MustParse(r[v1.ResourceCPU]),
v1.ResourceMemory: resource.MustParse(r[v1.ResourceMemory]),
},
}
}
func pipe(_ context.Context, opts *shellOpts, statusChan chan<- string, w, e *bytes.Buffer, cmds ...*exec.Cmd) error {
if len(cmds) == 0 {
return nil
}
if len(cmds) == 1 {
cmd := cmds[0]
if opts.background {
go func() {
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, w, e
if err := cmd.Run(); err != nil {
slog.Error("Command exec failed", slogs.Error, err)
} else {
for _, l := range strings.Split(w.String(), "\n") {
if l != "" {
statusChan <- fmt.Sprintf("%s %s", outputPrefix, l)
}
}
statusChan <- fmt.Sprintf("Command completed successfully: %q", render.Truncate(cmd.String(), 20))
slog.Info("Command ran successfully", slogs.Command, cmd.String())
}
close(statusChan)
}()
return nil
}
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
_, _ = cmd.Stdout.Write([]byte(opts.banner))
slog.Debug("Exec started")
err := cmd.Run()
var ex *exec.ExitError
// Check if exec failed from a signal
if errors.As(err, &ex) && !ex.Exited() {
return nil
}
slog.Debug("Command exec done", slogs.Error, err)
if err == nil {
statusChan <- fmt.Sprintf("Command completed successfully: %q", cmd.String())
}
close(statusChan)
if err != nil {
err = fmt.Errorf("command failed. Check k9s logs: %w", err)
}
return err
}
last := len(cmds) - 1
for i := range cmds {
cmds[i].Stderr = os.Stderr
if i+1 < len(cmds) {
r, w := io.Pipe()
cmds[i].Stdout, cmds[i+1].Stdin = w, r
}
}
cmds[last].Stdout = os.Stdout
for _, cmd := range cmds {
slog.Debug("Starting command", slogs.Command, cmd)
if err := cmd.Start(); err != nil {
return err
}
}
return cmds[len(cmds)-1].Wait()
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/policy.go | internal/view/policy.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"
)
const (
group = "Group"
user = "User"
sa = "ServiceAccount"
)
// Policy presents a RBAC rules viewer based on what a given user/group or sa can do.
type Policy struct {
ResourceViewer
subjectKind, subjectName string
}
// NewPolicy returns a new viewer.
func NewPolicy(_ *App, subject, name string) *Policy {
p := Policy{
ResourceViewer: NewBrowser(client.PolGVR),
subjectKind: subject,
subjectName: name,
}
p.AddBindKeysFn(p.bindKeys)
p.GetTable().SetSortCol("API-GROUP", false)
p.SetContextFn(p.subjectCtx)
p.GetTable().SetEnterFn(blankEnterFn)
return &p
}
func (p *Policy) subjectCtx(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeySubjectKind, mapSubject(p.subjectKind))
ctx = context.WithValue(ctx, internal.KeyPath, mapSubject(p.subjectKind)+":"+p.subjectName)
return context.WithValue(ctx, internal.KeySubjectName, p.subjectName)
}
func (p *Policy) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Bulk(ui.KeyMap{
ui.KeyShiftN: ui.NewKeyAction("Sort Name", p.GetTable().SortColCmd(nameCol, true), false),
ui.KeyShiftA: ui.NewKeyAction("Sort Api-Group", p.GetTable().SortColCmd("API-GROUP", true), false),
ui.KeyShiftB: ui.NewKeyAction("Sort Binding", p.GetTable().SortColCmd("BINDING", true), false),
})
}
func mapSubject(subject string) string {
switch subject {
case "g":
return group
case "s":
return sa
case "u":
return user
default:
return subject
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/page_stack.go | internal/view/page_stack.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/ui"
)
// PageStack represents a stack of pages.
type PageStack struct {
*ui.Pages
app *App
}
// NewPageStack returns a new page stack.
func NewPageStack() *PageStack {
return &PageStack{
Pages: ui.NewPages(),
}
}
// Init initializes the view.
func (p *PageStack) Init(ctx context.Context) (err error) {
if p.app, err = extractApp(ctx); err != nil {
return err
}
p.AddListener(p)
return nil
}
// StackPushed notifies a new page was added.
func (p *PageStack) StackPushed(c model.Component) {
c.Start()
p.app.SetFocus(c)
}
// StackPopped notifies a page was removed.
func (p *PageStack) StackPopped(o, top model.Component) {
o.Stop()
p.StackTop(top)
}
// StackTop notifies for the top component.
func (p *PageStack) StackTop(top model.Component) {
if top == nil {
return
}
top.Start()
p.app.SetFocus(top)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/actions.go | internal/view/actions.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"errors"
"fmt"
"log/slog"
"slices"
"strings"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
"k8s.io/apimachinery/pkg/util/sets"
)
// AllScopes represents actions available for all views.
const AllScopes = "all"
// Runner represents a runnable action handler.
type Runner interface {
// App returns the current app.
App() *App
// GetSelectedItem returns the current selected item.
GetSelectedItem() string
// Aliases returns all aliases assoxciated with the view GVR.
Aliases() sets.Set[string]
// EnvFn returns the current environment function.
EnvFn() EnvFunc
}
func hasAll(scopes []string) bool {
return slices.Contains(scopes, AllScopes)
}
func includes(aliases []string, s string) bool {
return slices.Contains(aliases, s)
}
func inScope(scopes []string, aliases sets.Set[string]) bool {
if hasAll(scopes) {
return true
}
for _, s := range scopes {
if _, ok := aliases[s]; ok {
return ok
}
}
return false
}
func hotKeyActions(r Runner, aa *ui.KeyActions) error {
hh := config.NewHotKeys()
aa.Range(func(k tcell.Key, a ui.KeyAction) {
if a.Opts.HotKey {
aa.Delete(k)
}
})
var errs error
if err := hh.Load(r.App().Config.ContextHotkeysPath()); err != nil {
errs = errors.Join(errs, err)
}
for k, hk := range hh.HotKey {
key, err := asKey(hk.ShortCut)
if err != nil {
errs = errors.Join(errs, err)
continue
}
if _, ok := aa.Get(key); ok {
if !hk.Override {
errs = errors.Join(errs, fmt.Errorf("duplicate hotkey found for %q in %q", hk.ShortCut, k))
continue
}
slog.Debug("HotKey overrode action shortcut",
slogs.Shortcut, hk.ShortCut,
slogs.Key, k,
)
}
command, err := r.EnvFn()().Substitute(hk.Command)
if err != nil {
slog.Warn("Invalid shortcut command", slogs.Error, err)
continue
}
aa.Add(key, ui.NewKeyActionWithOpts(
hk.Description,
gotoCmd(r, command, "", !hk.KeepHistory),
ui.ActionOpts{
Shared: true,
HotKey: true,
},
))
}
return errs
}
func gotoCmd(r Runner, cmd, path string, clearStack bool) ui.ActionHandler {
return func(*tcell.EventKey) *tcell.EventKey {
r.App().gotoResource(cmd, path, clearStack, true)
return nil
}
}
func pluginActions(r Runner, aa *ui.KeyActions) error {
// Skip plugin loading if no valid connection
if r.App().Conn() == nil || !r.App().Conn().ConnectionOK() {
return nil
}
aa.Range(func(k tcell.Key, a ui.KeyAction) {
if a.Opts.Plugin {
aa.Delete(k)
}
})
path, err := r.App().Config.ContextPluginsPath()
if err != nil {
return err
}
pp := config.NewPlugins()
if err := pp.Load(path, true); err != nil {
return err
}
var (
errs error
aliases = r.Aliases()
ro = r.App().Config.IsReadOnly()
)
for k := range pp.Plugins {
if !inScope(pp.Plugins[k].Scopes, aliases) || (ro && pp.Plugins[k].Dangerous) {
continue
}
key, err := asKey(pp.Plugins[k].ShortCut)
if err != nil {
errs = errors.Join(errs, err)
continue
}
if _, ok := aa.Get(key); ok {
if !pp.Plugins[k].Override {
errs = errors.Join(errs, fmt.Errorf("duplicate plugin key found for %q in %q", pp.Plugins[k].ShortCut, k))
continue
}
slog.Debug("Plugin overrode action shortcut",
slogs.Plugin, k,
slogs.Key, pp.Plugins[k].ShortCut,
)
}
plugin := pp.Plugins[k]
aa.Add(key, ui.NewKeyActionWithOpts(
pp.Plugins[k].Description,
pluginAction(r, &plugin),
ui.ActionOpts{
Visible: true,
Plugin: true,
Dangerous: plugin.Dangerous,
},
))
}
return errs
}
func pluginAction(r Runner, p *config.Plugin) ui.ActionHandler {
return func(evt *tcell.EventKey) *tcell.EventKey {
path := r.GetSelectedItem()
if path == "" {
return evt
}
if r.EnvFn() == nil {
return nil
}
args := make([]string, len(p.Args))
for i, a := range p.Args {
arg, err := r.EnvFn()().Substitute(a)
if err != nil {
slog.Error("Plugin Args match failed", slogs.Error, err)
return nil
}
args[i] = arg
}
cb := func() {
opts := shellOpts{
binary: p.Command,
background: p.Background,
pipes: p.Pipes,
args: args,
}
suspend, errChan, statusChan := run(r.App(), &opts)
if !suspend {
r.App().Flash().Infof("Plugin command failed: %q", p.Description)
return
}
var errs error
for e := range errChan {
errs = errors.Join(errs, e)
}
if errs != nil {
if !strings.Contains(errs.Error(), "signal: interrupt") {
slog.Error("Plugin command failed", slogs.Error, errs)
r.App().cowCmd(errs.Error())
return
}
}
go func() {
for st := range statusChan {
if !p.OverwriteOutput {
r.App().Flash().Infof("Plugin command launched successfully: %q", st)
} else if strings.Contains(st, outputPrefix) {
infoMsg := strings.TrimPrefix(st, outputPrefix)
r.App().Flash().Info(strings.TrimSpace(infoMsg))
return
}
}
}()
}
if p.Confirm {
msg := fmt.Sprintf("Run?\n%s %s", p.Command, strings.Join(args, " "))
d := r.App().Styles.Dialog()
dialog.ShowConfirm(&d, r.App().Content.Pages, "Confirm "+p.Description, msg, cb, func() {})
return nil
}
cb()
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/pvc.go | internal/view/pvc.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"
)
// PersistentVolumeClaim represents a PVC custom viewer.
type PersistentVolumeClaim struct {
ResourceViewer
}
// NewPersistentVolumeClaim returns a new viewer.
func NewPersistentVolumeClaim(gvr *client.GVR) ResourceViewer {
v := PersistentVolumeClaim{
ResourceViewer: NewOwnerExtender(NewBrowser(gvr)),
}
v.AddBindKeysFn(v.bindKeys)
return &v
}
func (p *PersistentVolumeClaim) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyU: ui.NewKeyAction("UsedBy", p.refCmd, true),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", p.GetTable().SortColCmd("STATUS", true), false),
ui.KeyShiftV: ui.NewKeyAction("Sort Volume", p.GetTable().SortColCmd("VOLUME", true), false),
ui.KeyShiftO: ui.NewKeyAction("Sort StorageClass", p.GetTable().SortColCmd("STORAGECLASS", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort Capacity", p.GetTable().SortColCmd("CAPACITY", true), false),
})
}
func (p *PersistentVolumeClaim) refCmd(evt *tcell.EventKey) *tcell.EventKey {
return scanRefs(evt, p.App(), p.GetTable(), client.PvcGVR)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/command_test.go | internal/view/command_test.go | package view
import (
"errors"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/view/cmd"
"github.com/stretchr/testify/assert"
)
func Test_viewMetaFor(t *testing.T) {
uu := map[string]struct {
cmd string
gvr *client.GVR
p *cmd.Interpreter
err error
}{
"empty": {
cmd: "",
gvr: client.PodGVR,
err: errors.New("`` command not found"),
},
"toast": {
cmd: "v1/pd",
gvr: client.PodGVR,
err: errors.New("`v1/pd` command not found"),
},
"gvr": {
cmd: "v1/pods",
gvr: client.PodGVR,
p: cmd.NewInterpreter("v1/pods"),
err: errors.New("blah"),
},
"short-name": {
cmd: "po",
gvr: client.PodGVR,
p: cmd.NewInterpreter("v1/pods", "po"),
err: errors.New("blee"),
},
"custom-alias": {
cmd: "pdl",
gvr: client.PodGVR,
p: cmd.NewInterpreter("v1/pods @fred 'app=blee' default", "pdl"),
err: errors.New("blee"),
},
"inception": {
cmd: "pdal blee",
gvr: client.PodGVR,
p: cmd.NewInterpreter("v1/pods @fred 'app=blee' blee", "pdal", "pod"),
err: errors.New("blee"),
},
}
c := &Command{
alias: &dao.Alias{
Aliases: config.NewAliases(),
},
}
c.alias.Define(client.PodGVR, "po", "pod", "pods", client.PodGVR.String())
c.alias.Define(client.NewGVR("pod default"), "pd")
c.alias.Define(client.NewGVR("pod @fred 'app=blee' default"), "pdl")
c.alias.Define(client.NewGVR("pdl"), "pdal")
for k, u := range uu {
t.Run(k, func(t *testing.T) {
p := cmd.NewInterpreter(u.cmd)
gvr, _, acmd, err := c.viewMetaFor(p)
if err != nil {
assert.Equal(t, u.err.Error(), err.Error())
} else {
assert.Equal(t, u.gvr, gvr)
assert.Equal(t, u.p, acmd)
}
})
}
}
| 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.go | internal/view/pf_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"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/port"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/watch"
"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"
"k8s.io/client-go/tools/portforward"
)
// PortForwardExtender adds port-forward extensions.
type PortForwardExtender struct {
ResourceViewer
}
// NewPortForwardExtender returns a new extender.
func NewPortForwardExtender(r ResourceViewer) ResourceViewer {
p := PortForwardExtender{ResourceViewer: r}
p.AddBindKeysFn(p.bindKeys)
return &p
}
func (p *PortForwardExtender) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyF: ui.NewKeyAction("Show PortForward", p.showPFCmd, true),
ui.KeyShiftF: ui.NewKeyAction("Port-Forward", p.portFwdCmd, true),
})
}
func (p *PortForwardExtender) portFwdCmd(evt *tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return evt
}
podName, err := p.fetchPodName(path)
if err != nil {
p.App().Flash().Err(err)
return nil
}
if err := ensurePodPortFwdAllowed(p.App().factory, podName); err != nil {
p.App().Flash().Err(err)
return nil
}
if err := showFwdDialog(p, podName, startFwdCB); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *PortForwardExtender) showPFCmd(evt *tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return evt
}
podName, err := p.fetchPodName(path)
if err != nil {
p.App().Flash().Err(err)
return nil
}
if !p.App().factory.Forwarders().IsPodForwarded(podName) {
p.App().Flash().Errf("no port-forward defined")
return nil
}
pf := NewPortForward(client.PfGVR)
pf.SetContextFn(p.portForwardContext)
if err := p.App().inject(pf, false); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *PortForwardExtender) fetchPodName(path string) (string, error) {
res, err := dao.AccessorFor(p.App().factory, p.GVR())
if err != nil {
return "", err
}
ctrl, ok := res.(dao.Controller)
if !ok {
return "", fmt.Errorf("expecting a controller resource for %q", p.GVR())
}
return ctrl.Pod(path)
}
func (p *PortForwardExtender) portForwardContext(ctx context.Context) context.Context {
if bc := p.App().BenchFile; bc != "" {
ctx = context.WithValue(ctx, internal.KeyBenchCfg, p.App().BenchFile)
}
return context.WithValue(ctx, internal.KeyPath, p.GetTable().GetSelectedItem())
}
// ----------------------------------------------------------------------------
// Helpers...
func ensurePodPortFwdAllowed(factory dao.Factory, podName string) error {
pod, err := fetchPod(factory, podName)
if err != nil {
return err
}
if pod.Status.Phase != v1.PodRunning {
return fmt.Errorf("pod must be running. Current status=%v", pod.Status.Phase)
}
return nil
}
func runForward(v ResourceViewer, pf watch.Forwarder, f *portforward.PortForwarder) {
v.App().factory.AddForwarder(pf)
v.App().QueueUpdateDraw(func() {
DismissPortForwards(v, v.App().Content.Pages)
})
pf.SetActive(true)
if err := f.ForwardPorts(); err != nil {
v.App().Flash().Warnf("PortForward failed for %s: %s. Deleting!", pf.ID(), err)
}
v.App().QueueUpdateDraw(func() {
v.App().factory.DeleteForwarder(pf.ID())
pf.SetActive(false)
})
}
func startFwdCB(v ResourceViewer, path string, pts port.PortTunnels) error {
if err := pts.CheckAvailable(context.Background()); err != nil {
return err
}
tt := make([]string, 0, len(pts))
for _, pt := range pts {
if _, ok := v.App().factory.ForwarderFor(dao.PortForwardID(path, pt.Container, pt.PortMap())); ok {
return fmt.Errorf("port-forward is already active on pod %s", path)
}
pf := dao.NewPortForwarder(v.App().factory)
fwd, err := pf.Start(path, pt)
if err != nil {
return err
}
slog.Debug(">>> Starting port forward",
slogs.PFID, pf.ID(),
slogs.PFTunnel, pt,
)
go runForward(v, pf, fwd)
tt = append(tt, pt.LocalPort)
}
if len(tt) == 1 {
v.App().Flash().Infof("PortForward activated %s", tt[0])
return nil
}
v.App().Flash().Infof("PortForwards activated %s", strings.Join(tt, ","))
return nil
}
func showFwdDialog(v ResourceViewer, path string, cb PortForwardCB) error {
mm, anns, err := fetchPodPorts(v.App().factory, path)
if err != nil {
return err
}
ports := make(port.ContainerPortSpecs, 0, len(mm))
for co, pp := range mm {
for _, p := range pp {
if p.Protocol != v1.ProtocolTCP {
continue
}
ports = append(ports, port.NewPortSpec(co, p.Name, p.ContainerPort))
}
}
if spec, ok := anns[port.K9sAutoPortForwardsKey]; ok {
pfs, err := port.ParsePFs(spec)
if err != nil {
return err
}
pts, err := pfs.ToTunnels(v.App().Config.K9s.PortForwardAddress, ports, port.IsPortFree)
if err != nil {
return err
}
return startFwdCB(v, path, pts)
}
ShowPortForwards(v, path, ports, anns, cb)
return nil
}
func fetchPodPorts(f *watch.Factory, path string) (ports map[string][]v1.ContainerPort, anns map[string]string, err error) {
slog.Debug("Fetching ports on pod", slogs.FQN, path)
o, err := f.Get(client.PodGVR, path, true, labels.Everything())
if err != nil {
return nil, nil, err
}
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, nil, err
}
pp := make(map[string][]v1.ContainerPort, len(pod.Spec.Containers))
for i := range pod.Spec.Containers {
pp[pod.Spec.Containers[i].Name] = pod.Spec.Containers[i].Ports
}
return pp, pod.Annotations, nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/actions_test.go | internal/view/actions_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"log/slog"
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/util/sets"
)
func init() {
slog.SetDefault(slog.New(slog.DiscardHandler))
}
func TestHasAll(t *testing.T) {
uu := map[string]struct {
scopes []string
e bool
}{
"empty": {},
"all": {
scopes: []string{"blee", "duh", AllScopes},
e: true,
},
"none": {
scopes: []string{"blee", "duh", "alla"},
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, hasAll(u.scopes))
})
}
}
func TestIncludes(t *testing.T) {
uu := map[string]struct {
s string
ss []string
e bool
}{
"empty": {},
"yes": {
s: "blee",
ss: []string{"yo", "duh", "blee"},
e: true,
},
"no": {
s: "blue",
ss: []string{"yo", "duh", "blee"},
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, includes(u.ss, u.s))
})
}
}
func TestInScope(t *testing.T) {
uu := map[string]struct {
ss []string
aa sets.Set[string]
e bool
}{
"empty": {},
"yes": {
e: true,
ss: []string{"blee", "duh", "fred"},
aa: sets.New("blee", "fred", "duh"),
},
"no": {
ss: []string{"blee", "duh", "fred"},
aa: sets.New("blee1", "fred1"),
},
"no-scopes": {
aa: sets.New("aa", "blee1", "fred1"),
},
"no-aliases": {
ss: []string{"blee1", "fred1"},
},
"all": {
e: true,
ss: []string{AllScopes},
aa: sets.New("blee1", "fred1"),
},
}
for k, u := range uu {
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, inScope(u.ss, u.aa))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/job.go | internal/view/job.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"
batchv1 "k8s.io/api/batch/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
)
// Job represents a job viewer.
type Job struct {
ResourceViewer
}
// NewJob returns a new viewer.
func NewJob(gvr *client.GVR) ResourceViewer {
var j Job
j.ResourceViewer = NewVulnerabilityExtender(
NewOwnerExtender(
NewLogsExtender(NewBrowser(gvr), j.logOptions),
),
)
j.GetTable().SetEnterFn(j.showPods)
j.GetTable().SetSortCol("AGE", true)
return &j
}
func (*Job) showPods(app *App, _ ui.Tabular, gvr *client.GVR, path string) {
o, err := app.factory.Get(gvr, path, true, labels.Everything())
if err != nil {
app.Flash().Err(err)
return
}
var job batchv1.Job
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &job)
if err != nil {
app.Flash().Err(err)
return
}
showPodsFromSelector(app, path, job.Spec.Selector)
}
func (j *Job) logOptions(prev bool) (*dao.LogOptions, error) {
path := j.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("you must provide a selection")
}
job, err := j.getInstance(path)
if err != nil {
return nil, err
}
return podLogOptions(j.App(), path, prev, &job.ObjectMeta, &job.Spec.Template.Spec), nil
}
func (j *Job) getInstance(fqn string) (*batchv1.Job, error) {
var job dao.Job
job.Init(j.App().factory, client.JobGVR)
return job.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/screen_dump_test.go | internal/view/screen_dump_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 TestScreenDumpNew(t *testing.T) {
po := view.NewScreenDump(client.SdGVR)
require.NoError(t, po.Init(makeCtx(t)))
assert.Equal(t, "ScreenDumps", po.Name())
assert.Len(t, po.Hints(), 6)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/ds_test.go | internal/view/ds_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 TestDaemonSet(t *testing.T) {
v := view.NewDaemonSet(client.DsGVR)
require.NoError(t, v.Init(makeCtx(t)))
assert.Equal(t, "DaemonSets", v.Name())
assert.Len(t, v.Hints(), 18)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/workload.go | internal/view/workload.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/model"
"github.com/derailed/k9s/internal/slogs"
"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"
)
// Workload presents a workload viewer.
type Workload struct {
ResourceViewer
}
// NewWorkload returns a new viewer.
func NewWorkload(gvr *client.GVR) ResourceViewer {
w := Workload{
ResourceViewer: NewBrowser(gvr),
}
w.GetTable().SetEnterFn(w.showRes)
w.AddBindKeysFn(w.bindKeys)
w.GetTable().SetSortCol("KIND", true)
return &w
}
func (w *Workload) bindDangerousKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyE: ui.NewKeyActionWithOpts("Edit", w.editCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
tcell.KeyCtrlD: ui.NewKeyActionWithOpts("Delete", w.deleteCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
})
}
func (w *Workload) bindKeys(aa *ui.KeyActions) {
if !w.App().Config.IsReadOnly() {
w.bindDangerousKeys(aa)
}
aa.Bulk(ui.KeyMap{
ui.KeyShiftK: ui.NewKeyAction("Sort Kind", w.GetTable().SortColCmd("KIND", true), false),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", w.GetTable().SortColCmd(statusCol, true), false),
ui.KeyShiftR: ui.NewKeyAction("Sort Ready", w.GetTable().SortColCmd("READY", true), false),
ui.KeyShiftA: ui.NewKeyAction("Sort Age", w.GetTable().SortColCmd(ageCol, true), false),
ui.KeyY: ui.NewKeyAction(yamlAction, w.yamlCmd, true),
ui.KeyD: ui.NewKeyAction("Describe", w.describeCmd, true),
})
}
func parsePath(path string) (*client.GVR, string, bool) {
tt := strings.Split(path, "|")
if len(tt) != 3 {
slog.Error("Unable to parse workload path", slogs.Path, path)
return client.NoGVR, client.FQN("", ""), false
}
return client.NewGVR(tt[0]), client.FQN(tt[1], tt[2]), true
}
func (*Workload) showRes(app *App, _ ui.Tabular, _ *client.GVR, path string) {
gvr, fqn, ok := parsePath(path)
if !ok {
app.Flash().Err(fmt.Errorf("unable to parse path: %q", path))
return
}
app.gotoResource(gvr.String(), fqn, false, true)
}
func (w *Workload) deleteCmd(evt *tcell.EventKey) *tcell.EventKey {
selections := w.GetTable().GetSelectedItems()
if len(selections) == 0 {
return evt
}
w.Stop()
defer w.Start()
{
msg := fmt.Sprintf("Delete %s %s?", w.GVR().R(), selections[0])
if len(selections) > 1 {
msg = fmt.Sprintf("Delete %d marked %s?", len(selections), w.GVR())
}
w.resourceDelete(selections, msg)
}
return nil
}
func (w *Workload) defaultContext(gvr *client.GVR, fqn string) context.Context {
ctx := context.WithValue(context.Background(), internal.KeyFactory, w.App().factory)
ctx = context.WithValue(ctx, internal.KeyGVR, gvr)
if fqn != "" {
ctx = context.WithValue(ctx, internal.KeyPath, fqn)
}
if internal.IsLabelSelector(w.GetTable().CmdBuff().GetText()) {
if sel, err := ui.ExtractLabelSelector(w.GetTable().CmdBuff().GetText()); err == nil {
ctx = context.WithValue(ctx, internal.KeyLabels, sel)
}
}
ctx = context.WithValue(ctx, internal.KeyNamespace, client.CleanseNamespace(w.App().Config.ActiveNamespace()))
ctx = context.WithValue(ctx, internal.KeyWithMetrics, w.App().factory.Client().HasMetrics())
return ctx
}
func (w *Workload) resourceDelete(selections []string, msg string) {
okFn := func(propagation *metav1.DeletionPropagation, force bool) {
w.GetTable().ShowDeleted()
if len(selections) > 1 {
w.App().Flash().Infof("Delete %d marked %s", len(selections), w.GVR())
} else {
w.App().Flash().Infof("Delete resource %s %s", w.GVR(), selections[0])
}
for _, sel := range selections {
gvr, fqn, ok := parsePath(sel)
if !ok {
w.App().Flash().Err(fmt.Errorf("unable to parse path: %q", sel))
return
}
grace := dao.DefaultGrace
if force {
grace = dao.ForceGrace
}
if err := w.GetTable().GetModel().Delete(w.defaultContext(gvr, fqn), fqn, propagation, grace); err != nil {
w.App().Flash().Errf("Delete failed with `%s", err)
} else {
w.App().factory.DeleteForwarder(sel)
}
w.GetTable().DeleteMark(sel)
}
w.GetTable().Start()
}
d := w.App().Styles.Dialog()
dialog.ShowDelete(&d, w.App().Content.Pages, msg, okFn, func() {})
}
func (w *Workload) describeCmd(evt *tcell.EventKey) *tcell.EventKey {
path := w.GetTable().GetSelectedItem()
if path == "" {
return evt
}
gvr, fqn, ok := parsePath(path)
if !ok {
w.App().Flash().Err(fmt.Errorf("unable to parse path: %q", path))
return evt
}
describeResource(w.App(), nil, gvr, fqn)
return nil
}
func (w *Workload) editCmd(evt *tcell.EventKey) *tcell.EventKey {
path := w.GetTable().GetSelectedItem()
if path == "" {
return evt
}
gvr, fqn, ok := parsePath(path)
if !ok {
w.App().Flash().Err(fmt.Errorf("unable to parse path: %q", path))
return evt
}
w.Stop()
defer w.Start()
if err := editRes(w.App(), gvr, fqn); err != nil {
w.App().Flash().Err(err)
}
return nil
}
func (w *Workload) yamlCmd(evt *tcell.EventKey) *tcell.EventKey {
path := w.GetTable().GetSelectedItem()
if path == "" {
return evt
}
gvr, fqn, ok := parsePath(path)
if !ok {
w.App().Flash().Err(fmt.Errorf("unable to parse path: %q", path))
return evt
}
v := NewLiveView(w.App(), yamlAction, model.NewYAML(gvr, fqn))
if err := v.app.inject(v, false); err != nil {
v.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/rbac_test.go | internal/view/rbac_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 TestRbacNew(t *testing.T) {
v := view.NewRbac(client.RbacGVR)
require.NoError(t, v.Init(makeCtx(t)))
assert.Equal(t, "Rbac", v.Name())
assert.Len(t, v.Hints(), 6)
}
| 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_test.go | internal/view/live_view_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"testing"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/mock"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestLiveViewSetText(t *testing.T) {
s := `
apiVersion: v1
data:
the secret name you want to quote to use tls.","title":"secretName","type":"string"}},"required":["http","class","classInSpec"],"type":"object"}
`
v := NewLiveView(NewApp(mock.NewMockConfig(t)), "fred", nil)
require.NoError(t, v.Init(context.Background()))
v.text.SetText(colorizeYAML(config.Yaml{}, s))
assert.Equal(t, s, sanitizeEsc(v.text.GetText(true)))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/dir_test.go | internal/view/dir_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDir(t *testing.T) {
v := view.NewDir("/fred")
require.NoError(t, v.Init(makeCtx(t)))
assert.Equal(t, "Directory", v.Name())
assert.Len(t, v.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/rbac.go | internal/view/rbac.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"
)
// Rbac presents an RBAC policy viewer.
type Rbac struct {
ResourceViewer
}
// NewRbac returns a new viewer.
func NewRbac(gvr *client.GVR) ResourceViewer {
r := Rbac{
ResourceViewer: NewBrowser(gvr),
}
r.AddBindKeysFn(r.bindKeys)
r.GetTable().SetSortCol("API-GROUP", true)
r.GetTable().SetEnterFn(blankEnterFn)
return &r
}
func (r *Rbac) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Add(ui.KeyShiftA, ui.NewKeyAction("Sort API-Group", r.GetTable().SortColCmd("API-GROUP", true), false))
}
func showRules(app *App, _ ui.Tabular, gvr *client.GVR, path string) {
v := NewRbac(client.RbacGVR)
v.SetContextFn(rbacCtx(gvr, path))
if err := app.inject(v, false); err != nil {
app.Flash().Err(err)
}
}
func rbacCtx(gvr *client.GVR, path string) ContextFunc {
return func(ctx context.Context) context.Context {
ctx = context.WithValue(ctx, internal.KeyPath, path)
return context.WithValue(ctx, internal.KeyGVR, gvr)
}
}
func blankEnterFn(_ *App, _ ui.Tabular, _ *client.GVR, _ string) {}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/table.go | internal/view/table.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"log/slog"
"path/filepath"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"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/view/cmd"
"github.com/derailed/tcell/v2"
)
// Table represents a table viewer.
type Table struct {
*ui.Table
app *App
enterFn EnterFunc
envFn EnvFunc
bindKeysFn []BindKeysFunc
command *cmd.Interpreter
}
// NewTable returns a new viewer.
func NewTable(gvr *client.GVR) *Table {
t := Table{
Table: ui.NewTable(gvr),
}
t.envFn = t.defaultEnv
return &t
}
// Init initializes the component.
func (t *Table) Init(ctx context.Context) (err error) {
if t.app, err = extractApp(ctx); err != nil {
return err
}
if t.app.Conn() != nil {
ctx = context.WithValue(ctx, internal.KeyHasMetrics, t.app.Conn().HasMetrics())
}
ctx = context.WithValue(ctx, internal.KeyStyles, t.app.Styles)
ctx = context.WithValue(ctx, internal.KeyViewConfig, t.app.CustomView())
t.Table.Init(ctx)
if !t.app.Config.K9s.UI.Reactive {
if err := t.app.RefreshCustomViews(); err != nil {
slog.Warn("CustomViews load failed", slogs.Error, err)
t.app.Logo().Warn("Views load failed!")
}
}
t.SetInputCapture(t.keyboard)
t.bindKeys()
t.GetModel().SetRefreshRate(t.app.Config.K9s.RefreshDuration())
t.CmdBuff().AddListener(t)
return nil
}
// SetCommand sets the current command.
func (t *Table) SetCommand(i *cmd.Interpreter) {
t.command = i
}
// HeaderIndex returns index of a given column or false if not found.
func (t *Table) HeaderIndex(colName string) (int, bool) {
for i := range t.GetColumnCount() {
h := t.GetCell(0, i)
if h == nil {
continue
}
s := h.Text
if idx := strings.Index(s, "["); idx > 0 {
s = s[:idx]
}
if s == colName {
return i, true
}
}
return 0, false
}
// SendKey sends a keyboard event (testing only!).
func (t *Table) SendKey(evt *tcell.EventKey) {
t.app.Prompt().SendKey(evt)
}
func (t *Table) keyboard(evt *tcell.EventKey) *tcell.EventKey {
key := evt.Key()
// Handle Shift+Left/Right for column selection
if evt.Modifiers()&tcell.ModShift != 0 {
if key == tcell.KeyLeft {
t.Table.SelectPrevColumn()
return nil
}
if key == tcell.KeyRight {
t.Table.SelectNextColumn()
return nil
}
}
if key == tcell.KeyUp || key == tcell.KeyDown {
return evt
}
if a, ok := t.Actions().Get(ui.AsKey(evt)); ok && !t.app.Content.IsTopDialog() {
return a.Action(evt)
}
return evt
}
// Name returns the table name.
func (t *Table) Name() string { return t.GVR().R() }
// AddBindKeysFn adds additional key bindings.
func (t *Table) AddBindKeysFn(f BindKeysFunc) {
t.bindKeysFn = append(t.bindKeysFn, f)
}
// SetEnvFn sets a function to pull viewer env vars for plugins.
func (t *Table) SetEnvFn(f EnvFunc) { t.envFn = f }
// EnvFn returns an plugin env function if available.
func (t *Table) EnvFn() EnvFunc {
return t.envFn
}
func (t *Table) defaultEnv() Env {
path := t.GetSelectedItem()
row := t.GetSelectedRow(path)
env := defaultEnv(t.app.Conn().Config(), path, t.GetModel().Peek().Header(), row)
env["FILTER"] = t.CmdBuff().GetText()
if env["FILTER"] == "" {
env["NAMESPACE"], env["FILTER"] = client.Namespaced(path)
}
env["RESOURCE_GROUP"] = t.GVR().G()
env["RESOURCE_VERSION"] = t.GVR().V()
env["RESOURCE_NAME"] = t.GVR().R()
return env
}
// App returns the current app handle.
func (t *Table) App() *App {
return t.app
}
// Start runs the component.
func (t *Table) Start() {
t.Stop()
t.CmdBuff().AddListener(t)
t.Styles().AddListener(t.Table)
cmds := []string{t.Table.GVR().String()}
if t.command != nil {
if t.command.GetLine() != t.Table.GVR().String() {
cmds = append(cmds, t.command.GetLine())
}
for _, a := range t.command.Aliases() {
cmds = append(cmds, a)
}
}
t.App().CustomView().AddListeners(t.Table, cmds...)
}
// Stop terminates the component.
func (t *Table) Stop() {
t.CmdBuff().RemoveListener(t)
t.Styles().RemoveListener(t.Table)
t.App().CustomView().RemoveListener(t.Table)
}
// SetEnterFn specifies the default enter behavior.
func (t *Table) SetEnterFn(f EnterFunc) {
t.enterFn = f
}
// SetExtraActionsFn specifies custom keyboard behavior.
func (*Table) SetExtraActionsFn(BoostActionsFunc) {}
// BufferCompleted indicates input was accepted.
func (t *Table) BufferCompleted(text, _ string) {
t.app.QueueUpdateDraw(func() {
t.Filter(text)
})
}
// BufferChanged indicates the buffer was changed.
func (*Table) BufferChanged(_, _ string) {}
// BufferActive indicates the buff activity changed.
func (t *Table) BufferActive(state bool, k model.BufferKind) {
t.app.BufferActive(state, k)
if !state {
t.app.SetFocus(t)
}
}
func (t *Table) saveCmd(*tcell.EventKey) *tcell.EventKey {
if path, err := saveTable(t.app.Config.K9s.ContextScreenDumpDir(), t.GVR().R(), t.Path, t.GetFilteredData()); err != nil {
t.app.Flash().Err(err)
} else {
t.app.Flash().Infof("File saved successfully: %q", render.Truncate(filepath.Base(path), 50))
}
return nil
}
func (t *Table) bindKeys() {
t.Actions().Bulk(ui.KeyMap{
ui.KeyHelp: ui.NewKeyAction("Help", t.App().helpCmd, true),
ui.KeySpace: ui.NewSharedKeyAction("Mark", t.markCmd, false),
tcell.KeyCtrlSpace: ui.NewSharedKeyAction("Mark Range", t.markSpanCmd, false),
tcell.KeyCtrlBackslash: ui.NewSharedKeyAction("Marks Clear", t.clearMarksCmd, false),
tcell.KeyCtrlS: ui.NewSharedKeyAction("Save", t.saveCmd, false),
ui.KeySlash: ui.NewSharedKeyAction("Filter Mode", t.activateCmd, false),
tcell.KeyCtrlZ: ui.NewKeyAction("Toggle Faults", t.toggleFaultCmd, false),
tcell.KeyCtrlW: ui.NewKeyAction("Toggle Wide", t.toggleWideCmd, false),
ui.KeyShiftN: ui.NewKeyAction("Sort Name", t.SortColCmd(nameCol, true), false),
ui.KeyShiftA: ui.NewKeyAction("Sort Age", t.SortColCmd(ageCol, true), false),
ui.KeyShiftS: ui.NewKeyAction("Sort Selected Column", t.sortSelectedColumnCmd, false),
})
}
func (t *Table) toggleFaultCmd(*tcell.EventKey) *tcell.EventKey {
t.ToggleToast()
return nil
}
func (t *Table) toggleWideCmd(*tcell.EventKey) *tcell.EventKey {
t.ToggleWide()
return nil
}
func (t *Table) sortSelectedColumnCmd(*tcell.EventKey) *tcell.EventKey {
t.Table.SortSelectedColumn()
return nil
}
func (t *Table) cpCmd(evt *tcell.EventKey) *tcell.EventKey {
path := t.GetSelectedItem()
if path == "" {
return evt
}
_, n := client.Namespaced(path)
if err := clipboardWrite(n); err != nil {
t.app.Flash().Err(err)
return nil
}
t.app.Flash().Info("Resource name copied to clipboard...")
return nil
}
func (t *Table) cpNsCmd(evt *tcell.EventKey) *tcell.EventKey {
path := t.GetSelectedItem()
if path == "" {
return evt
}
ns, _ := client.Namespaced(path)
if err := clipboardWrite(ns); err != nil {
t.app.Flash().Err(err)
return nil
}
t.app.Flash().Info("Resource namespace copied to clipboard...")
return nil
}
func (t *Table) markCmd(*tcell.EventKey) *tcell.EventKey {
t.ToggleMark()
t.Refresh()
return nil
}
func (t *Table) markSpanCmd(*tcell.EventKey) *tcell.EventKey {
t.SpanMark()
t.Refresh()
return nil
}
func (t *Table) clearMarksCmd(*tcell.EventKey) *tcell.EventKey {
t.ClearMarks()
t.Refresh()
return nil
}
func (t *Table) activateCmd(evt *tcell.EventKey) *tcell.EventKey {
if t.app.InCmdMode() {
return evt
}
t.App().ResetPrompt(t.CmdBuff())
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/log_test.go | internal/view/log_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"bytes"
"errors"
"fmt"
"io/fs"
"os"
"testing"
"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/ui"
"github.com/derailed/k9s/internal/view"
"github.com/derailed/tview"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestLog(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := view.NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
ii := dao.NewLogItems()
ii.Add(dao.NewLogItemFromString("blee\n"), dao.NewLogItemFromString("bozo\n"))
ll := make([][]byte, ii.Len())
ii.Lines(0, false, ll)
v.Flush(ll)
assert.Equal(t, "Waiting for logs...\nblee\nbozo\n", v.Logs().GetText(true))
}
func TestLogFlush(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := view.NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
items := dao.NewLogItems()
items.Add(
dao.NewLogItemFromString("\033[0;30mblee\n"),
dao.NewLogItemFromString("\033[0;32mBozo\n"),
)
ll := make([][]byte, items.Len())
items.Lines(0, false, ll)
v.Flush(ll)
assert.Equal(t, "[orange::d]Waiting for logs...\n[black::]blee\n[green::]Bozo\n\n", v.Logs().GetText(false))
}
func BenchmarkLogFlush(b *testing.B) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := view.NewLog(client.PodGVR, &opts)
_ = v.Init(makeContext(b))
items := dao.NewLogItems()
items.Add(
dao.NewLogItemFromString("\033[0;30mblee\n"),
dao.NewLogItemFromString("\033[0;101mBozo\n"),
dao.NewLogItemFromString("\033[0;101mBozo\n"),
)
ll := make([][]byte, items.Len())
items.Lines(0, false, ll)
b.ReportAllocs()
b.ResetTimer()
for range b.N {
v.Flush(ll)
}
}
func TestLogAnsi(t *testing.T) {
buff := bytes.NewBufferString("")
w := tview.ANSIWriter(buff, "white", "black")
_, _ = fmt.Fprintf(w, "[YELLOW] ok")
assert.Equal(t, "[YELLOW] ok", buff.String())
v := tview.NewTextView()
v.SetDynamicColors(true)
aw := tview.ANSIWriter(v, "white", "black")
s := "[2019-03-27T15:05:15,246][INFO ][o.e.c.r.a.AllocationService] [es-0] Cluster health status changed from [YELLOW] to [GREEN] (reason: [shards started [[.monitoring-es-6-2019.03.27][0]]"
_, _ = fmt.Fprintf(aw, "%s", s)
assert.Equal(t, s+"\n", v.GetText(false))
}
func TestLogViewSave(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := view.NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
app := makeApp(t)
ii := dao.NewLogItems()
ii.Add(dao.NewLogItemFromString("blee"), dao.NewLogItemFromString("bozo"))
ll := make([][]byte, ii.Len())
ii.Lines(0, false, ll)
v.Flush(ll)
dd := "/tmp/test-dumps/na"
require.NoError(t, ensureDumpDir(dd))
app.Config.K9s.ScreenDumpDir = "/tmp/test-dumps"
dir := app.Config.K9s.ContextScreenDumpDir()
c1, err := os.ReadDir(dir)
require.NoError(t, err, "Dir: %q", dir)
v.SaveCmd(nil)
c2, err := os.ReadDir(dir)
require.NoError(t, err, "Dir: %q", dir)
assert.Len(t, c2, len(c1)+1)
}
func TestAllContainerKeyBinding(t *testing.T) {
uu := map[string]struct {
opts *dao.LogOptions
e bool
}{
"action-present": {
opts: &dao.LogOptions{Path: "", DefaultContainer: "container"},
e: true,
},
"action-missing": {
opts: &dao.LogOptions{},
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
v := view.NewLog(client.PodGVR, u.opts)
require.NoError(t, v.Init(makeContext(t)))
_, got := v.Logs().Actions().Get(ui.KeyA)
assert.Equal(t, u.e, got)
})
}
}
// ----------------------------------------------------------------------------
// Helpers...
func makeApp(t *testing.T) *view.App {
return view.NewApp(mock.NewMockConfig(t))
}
func ensureDumpDir(n string) error {
config.AppDumpsDir = n
if _, err := os.Stat(n); errors.Is(err, fs.ErrNotExist) {
return os.MkdirAll(n, 0700)
}
if err := os.RemoveAll(n); err != nil {
return err
}
return os.MkdirAll(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/pod_test.go | internal/view/pod_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"context"
"testing"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/mock"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestPodNew(t *testing.T) {
po := view.NewPod(client.PodGVR)
require.NoError(t, po.Init(makeCtx(t)))
assert.Equal(t, "Pods", po.Name())
assert.Len(t, po.Hints(), 28)
}
// Helpers...
func makeCtx(t testing.TB) context.Context {
cfg := mock.NewMockConfig(t)
return context.WithValue(context.Background(), internal.KeyApp, view.NewApp(cfg))
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/log_int_test.go | internal/view/log_int_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"testing"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestLogAutoScroll(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
SingleContainer: true,
}
v := NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
ii := dao.NewLogItems()
ii.Add(dao.NewLogItemFromString("blee"), dao.NewLogItemFromString("bozo"))
v.GetModel().Set(ii)
v.GetModel().Notify()
assert.Len(t, v.Hints(), 18)
v.toggleAutoScrollCmd(nil)
assert.Equal(t, "Autoscroll:Off ColumnLock:Off FullScreen:Off Timestamps:Off Wrap:Off", v.Indicator().GetText(true))
}
func TestLogColumnLock(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
buff := dao.NewLogItems()
for i := range 100 {
buff.Add(dao.NewLogItemFromString(fmt.Sprintf("line-%d\n", i)))
}
v.GetModel().Set(buff)
v.toggleColumnLockCmd(nil)
const column = 2
v.Logs().ScrollTo(-1, column)
v.toggleAutoScrollCmd(nil)
r, c := v.Logs().GetScrollOffset()
assert.Equal(t, -1, r)
assert.Equal(t, column, c)
}
func TestLogViewNav(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
buff := dao.NewLogItems()
for i := range 100 {
buff.Add(dao.NewLogItemFromString(fmt.Sprintf("line-%d\n", i)))
}
v.GetModel().Set(buff)
v.toggleAutoScrollCmd(nil)
r, _ := v.Logs().GetScrollOffset()
assert.Equal(t, -1, r)
}
func TestLogViewClear(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/p1",
Container: "blee",
}
v := NewLog(client.PodGVR, &opts)
require.NoError(t, v.Init(makeContext(t)))
v.toggleAutoScrollCmd(nil)
v.Logs().SetText("blee\nblah")
v.Logs().Clear()
assert.Empty(t, v.Logs().GetText(true))
}
func TestLogTimestamp(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/blee",
Container: "c1",
}
l := NewLog(client.NewGVR("test"), &opts)
require.NoError(t, l.Init(makeContext(t)))
ii := dao.NewLogItems()
ii.Add(
&dao.LogItem{
Pod: "fred/blee",
Container: "c1",
Bytes: []byte("ttt Testing 1, 2, 3\n"),
},
)
var list logList
l.GetModel().AddListener(&list)
l.GetModel().Set(ii)
l.SendKeys(ui.KeyT)
l.Logs().Clear()
ll := make([][]byte, ii.Len())
ii.Lines(0, true, ll)
l.Flush(ll)
assert.Equal(t, fmt.Sprintf("%-30s %s", "ttt", "fred/blee c1 Testing 1, 2, 3\n"), l.Logs().GetText(true))
assert.Equal(t, 2, list.change)
assert.Equal(t, 2, list.clear)
assert.Equal(t, 0, list.fail)
}
func TestLogFilter(t *testing.T) {
opts := dao.LogOptions{
Path: "fred/blee",
Container: "c1",
}
l := NewLog(client.NewGVR("test"), &opts)
require.NoError(t, l.Init(makeContext(t)))
buff := dao.NewLogItems()
buff.Add(
dao.NewLogItemFromString("duh"),
dao.NewLogItemFromString("zorg"),
)
var list logList
l.GetModel().AddListener(&list)
l.GetModel().Set(buff)
l.SendKeys(ui.KeySlash)
l.SendStrokes("zorg")
assert.Equal(t, "duhzorg", list.lines)
assert.Equal(t, 1, list.change)
assert.Equal(t, 1, list.clear)
assert.Equal(t, 0, list.fail)
}
// ----------------------------------------------------------------------------
// Helpers...
type logList struct {
change, clear, fail int
lines string
}
func (l *logList) LogChanged(ll [][]byte) {
l.change++
l.lines = ""
for _, line := range ll {
l.lines += string(line)
}
}
func (*logList) LogCanceled() {}
func (*logList) LogStop() {}
func (*logList) LogResume() {}
func (l *logList) LogCleared() { l.clear++ }
func (l *logList) LogFailed(error) { l.fail++ }
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/container.go | internal/view/container.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"fmt"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model1"
"github.com/derailed/k9s/internal/port"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
v1 "k8s.io/api/core/v1"
)
const containerTitle = "Containers"
// Container represents a container view.
type Container struct {
ResourceViewer
}
// NewContainer returns a new container view.
func NewContainer(gvr *client.GVR) ResourceViewer {
c := Container{}
c.ResourceViewer = NewLogsExtender(NewBrowser(gvr), c.logOptions)
c.SetEnvFn(c.k9sEnv)
c.GetTable().SetEnterFn(c.viewLogs)
c.GetTable().SetDecorateFn(c.decorateRows)
c.GetTable().SetSortCol("IDX", true)
c.AddBindKeysFn(c.bindKeys)
c.GetTable().SetDecorateFn(c.portForwardIndicator)
return &c
}
func (c *Container) portForwardIndicator(data *model1.TableData) {
ff := c.App().factory.Forwarders()
col, ok := data.IndexOfHeader("PF")
if !ok {
return
}
data.RowsRange(func(_ int, re model1.RowEvent) bool {
if ff.IsContainerForwarded(c.GetTable().Path, re.Row.ID) {
re.Row.Fields[col] = "[orange::b]Ⓕ"
}
return true
})
}
func (c *Container) decorateRows(data *model1.TableData) {
decorateCpuMemHeaderRows(c.App(), data)
}
// Name returns the component name.
func (*Container) Name() string { return containerTitle }
func (c *Container) bindDangerousKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyS: ui.NewKeyActionWithOpts(
"Shell",
c.shellCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyA: ui.NewKeyActionWithOpts(
"Attach",
c.attachCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
})
}
func (c *Container) bindKeys(aa *ui.KeyActions) {
aa.Delete(tcell.KeyCtrlSpace, ui.KeySpace)
if !c.App().Config.IsReadOnly() {
c.bindDangerousKeys(aa)
}
aa.Bulk(ui.KeyMap{
ui.KeyF: ui.NewKeyAction("Show PortForward", c.showPFCmd, true),
ui.KeyShiftF: ui.NewKeyAction("PortForward", c.portFwdCmd, true),
ui.KeyShiftT: ui.NewKeyAction("Sort Restart", c.GetTable().SortColCmd("RESTARTS", false), false),
ui.KeyShiftI: ui.NewKeyAction("Sort Idx", c.GetTable().SortColCmd("IDX", true), false),
})
aa.Merge(resourceSorters(c.GetTable()))
}
func (c *Container) k9sEnv() Env {
path := c.GetTable().GetSelectedItem()
row := c.GetTable().GetSelectedRow(path)
env := defaultEnv(c.App().Conn().Config(), path, c.GetTable().GetModel().Peek().Header(), row)
env["NAMESPACE"], env["POD"] = client.Namespaced(c.GetTable().Path)
return env
}
func (c *Container) logOptions(prev bool) (*dao.LogOptions, error) {
path := c.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("nothing selected")
}
cfg := c.App().Config.K9s.Logger
opts := dao.LogOptions{
Path: c.GetTable().Path,
Container: path,
Lines: cfg.TailCount,
SinceSeconds: cfg.SinceSeconds,
SingleContainer: true,
ShowTimestamp: cfg.ShowTime,
Previous: prev,
}
return &opts, nil
}
func (c *Container) viewLogs(*App, ui.Tabular, *client.GVR, string) {
c.ResourceViewer.(*LogsExtender).showLogs(c.GetTable().Path, false)
}
// Handlers...
func (c *Container) showPFCmd(evt *tcell.EventKey) *tcell.EventKey {
path := c.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if !c.App().factory.Forwarders().IsContainerForwarded(c.GetTable().Path, path) {
c.App().Flash().Errf("no port-forward defined")
return nil
}
pf := NewPortForward(client.PfGVR)
pf.SetContextFn(c.portForwardContext)
if err := c.App().inject(pf, false); err != nil {
c.App().Flash().Err(err)
}
return nil
}
func (c *Container) portForwardContext(ctx context.Context) context.Context {
if bc := c.App().BenchFile; bc != "" {
ctx = context.WithValue(ctx, internal.KeyBenchCfg, c.App().BenchFile)
}
return context.WithValue(ctx, internal.KeyPath, c.GetTable().Path)
}
func (c *Container) shellCmd(evt *tcell.EventKey) *tcell.EventKey {
path := c.GetTable().GetSelectedItem()
if path == "" {
return evt
}
var err error
c.Stop()
defer func() {
c.Start()
if err != nil {
c.App().QueueUpdate(func() {
if err != nil {
c.App().Flash().Errf("Shell exec failed: %s", err)
}
})
c.App().Flash().Err(err)
}
}()
err = shellIn(c.App(), c.GetTable().Path, path)
return nil
}
func (c *Container) attachCmd(evt *tcell.EventKey) *tcell.EventKey {
sel := c.GetTable().GetSelectedItem()
if sel == "" {
return evt
}
c.Stop()
defer c.Start()
attachIn(c.App(), c.GetTable().Path, sel)
return nil
}
func (c *Container) portFwdCmd(evt *tcell.EventKey) *tcell.EventKey {
path := c.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if _, ok := c.App().factory.ForwarderFor(fwFQN(c.GetTable().Path, path)); ok {
c.App().Flash().Errf("A port-forward already exists on container %s", c.GetTable().Path)
return nil
}
ports, ann, ok := c.listForwardable(path)
if !ok {
return nil
}
ShowPortForwards(c, c.GetTable().Path+"|"+path, ports, ann, startFwdCB)
return nil
}
func checkRunningStatus(co string, ss []v1.ContainerStatus) error {
var cs *v1.ContainerStatus
for i := range ss {
if ss[i].Name == co {
cs = &ss[i]
break
}
}
if cs == nil {
return fmt.Errorf("unable to locate container status for %q", co)
}
if render.ToContainerState(cs.State) != "Running" {
return fmt.Errorf("Container %s is not running?", co)
}
return nil
}
func locateContainer(co string, cc []v1.Container) (*v1.Container, error) {
for i := range cc {
if cc[i].Name == co {
return &cc[i], nil
}
}
return nil, fmt.Errorf("unable to locate container named %q", co)
}
func (c *Container) listForwardable(path string) (port.ContainerPortSpecs, map[string]string, bool) {
po, err := fetchPod(c.App().factory, c.GetTable().Path)
if err != nil {
return nil, nil, false
}
co, err := locateContainer(path, po.Spec.Containers)
if err != nil {
c.App().Flash().Err(err)
return nil, nil, false
}
if err := checkRunningStatus(path, po.Status.ContainerStatuses); err != nil {
c.App().Flash().Err(err)
return nil, nil, false
}
return port.FromContainerPorts(path, co.Ports), po.Annotations, true
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/node.go | internal/view/node.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"time"
"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"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// Node represents a node view.
type Node struct {
ResourceViewer
}
// NewNode returns a new node view.
func NewNode(gvr *client.GVR) ResourceViewer {
n := Node{
ResourceViewer: NewBrowser(gvr),
}
n.AddBindKeysFn(n.bindKeys)
n.GetTable().SetEnterFn(n.showPods)
n.SetContextFn(n.nodeContext)
return &n
}
func (n *Node) nodeContext(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeyPodCounting, !n.App().Config.K9s.DisablePodCounting)
}
func (n *Node) bindDangerousKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyC: ui.NewKeyActionWithOpts(
"Cordon",
n.toggleCordonCmd(true),
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
),
ui.KeyU: ui.NewKeyActionWithOpts(
"Uncordon",
n.toggleCordonCmd(false),
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
),
ui.KeyR: ui.NewKeyActionWithOpts(
"Drain",
n.drainCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
),
})
ct, err := n.App().Config.K9s.ActiveContext()
if err != nil {
slog.Error("No active context located", slogs.Error, err)
return
}
if ct.FeatureGates.NodeShell && n.App().Config.K9s.ShellPod != nil {
aa.Add(ui.KeyS, ui.NewKeyAction("Shell", n.sshCmd, true))
}
}
func (n *Node) bindKeys(aa *ui.KeyActions) {
if !n.App().Config.IsReadOnly() {
n.bindDangerousKeys(aa)
}
aa.Bulk(ui.KeyMap{
ui.KeyY: ui.NewKeyAction(yamlAction, n.yamlCmd, true),
ui.KeyShiftR: ui.NewKeyAction("Sort ROLE", n.GetTable().SortColCmd("ROLE", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort CPU", n.GetTable().SortColCmd(cpuCol, false), false),
ui.KeyShiftM: ui.NewKeyAction("Sort MEM", n.GetTable().SortColCmd(memCol, false), false),
ui.KeyShiftO: ui.NewKeyAction("Sort Pods", n.GetTable().SortColCmd("PODS", false), false),
})
}
func (n *Node) showPods(a *App, _ ui.Tabular, _ *client.GVR, path string) {
showPods(a, n.GetTable().GetSelectedItem(), nil, "spec.nodeName="+path)
}
func (n *Node) drainCmd(evt *tcell.EventKey) *tcell.EventKey {
sels := n.GetTable().GetSelectedItems()
if len(sels) == 0 {
return evt
}
opts := dao.DrainOptions{
GracePeriodSeconds: -1,
Timeout: 5 * time.Second,
}
ShowDrain(n, sels, opts, drainNode)
return nil
}
func drainNode(v ResourceViewer, sels []string, opts dao.DrainOptions) {
res, err := dao.AccessorFor(v.App().factory, v.GVR())
if err != nil {
v.App().Flash().Err(err)
return
}
m, ok := res.(dao.NodeMaintainer)
if !ok {
v.App().Flash().Err(fmt.Errorf("expecting a maintainer for %q", v.GVR()))
return
}
v.Stop()
defer v.Start()
{
d := NewDetails(v.App(), "Drain Progress", "nodes", contentYAML, true)
if err := v.App().inject(d, false); err != nil {
v.App().Flash().Err(err)
}
for _, sel := range sels {
if err := m.Drain(sel, opts, d.GetWriter()); err != nil {
v.App().Flash().Err(err)
}
}
v.Refresh()
}
}
func (n *Node) toggleCordonCmd(cordon bool) func(evt *tcell.EventKey) *tcell.EventKey {
return func(evt *tcell.EventKey) *tcell.EventKey {
sels := n.GetTable().GetSelectedItems()
if len(sels) == 0 {
return evt
}
title, msg := "Confirm ", ""
if cordon {
title, msg = title+"Cordon", "Cordon "
} else {
title, msg = title+"Uncordon", "Uncordon "
}
if len(sels) == 1 {
msg += sels[0] + "?"
} else {
msg += fmt.Sprintf("(%d) marked %s?", len(sels), n.GVR().R())
}
d := n.App().Styles.Dialog()
dialog.ShowConfirm(&d, n.App().Content.Pages, title, msg, func() {
res, err := dao.AccessorFor(n.App().factory, n.GVR())
if err != nil {
n.App().Flash().Err(err)
return
}
m, ok := res.(dao.NodeMaintainer)
if !ok {
n.App().Flash().Err(fmt.Errorf("expecting a maintainer for %q", n.GVR()))
return
}
for _, s := range sels {
if err := m.ToggleCordon(s, cordon); err != nil {
n.App().Flash().Err(err)
}
}
n.Refresh()
}, func() {})
return nil
}
}
func (n *Node) sshCmd(evt *tcell.EventKey) *tcell.EventKey {
path := n.GetTable().GetSelectedItem()
if path == "" {
return evt
}
n.Stop()
defer n.Start()
_, node := client.Namespaced(path)
launchNodeShell(n, n.App(), node)
return nil
}
func (n *Node) yamlCmd(evt *tcell.EventKey) *tcell.EventKey {
path := n.GetTable().GetSelectedItem()
if path == "" {
return evt
}
n.Stop()
defer n.Start()
ctx, cancel := context.WithTimeout(context.Background(), n.App().Conn().Config().CallTimeout())
defer cancel()
sel := n.GetTable().GetSelectedItem()
gvr := n.GVR().GVR()
dial, err := n.App().factory.Client().DynDial()
if err != nil {
n.App().Flash().Err(err)
return nil
}
o, err := dial.Resource(gvr).Get(ctx, sel, metav1.GetOptions{})
if err != nil {
n.App().Flash().Errf("Unable to get resource %q -- %s", n.GVR(), err)
return nil
}
raw, err := dao.ToYAML(o, false)
if err != nil {
n.App().Flash().Errf("Unable to marshal resource %s", err)
return nil
}
details := NewDetails(n.App(), yamlAction, sel, contentYAML, true).Update(raw)
if err := n.App().inject(details, false); err != nil {
n.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/alias.go | internal/view/alias.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"
)
const aliasTitle = "Aliases"
// Alias represents a command alias view.
type Alias struct {
ResourceViewer
}
// NewAlias returns a new alias view.
func NewAlias(gvr *client.GVR) ResourceViewer {
a := Alias{
ResourceViewer: NewBrowser(gvr),
}
a.GetTable().SetBorderFocusColor(tcell.ColorAliceBlue)
a.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorAliceBlue).Attributes(tcell.AttrNone))
a.AddBindKeysFn(a.bindKeys)
a.SetContextFn(a.aliasContext)
return &a
}
// Init initializes the view.
func (a *Alias) Init(ctx context.Context) error {
if err := a.ResourceViewer.Init(ctx); err != nil {
return err
}
a.GetTable().GetModel().SetNamespace(client.NotNamespaced)
return nil
}
func (a *Alias) aliasContext(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeyAliases, a.App().command.alias)
}
func (a *Alias) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, ui.KeyShiftN, tcell.KeyCtrlS, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Delete(tcell.KeyCtrlW, tcell.KeyCtrlL)
aa.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("Goto", a.gotoCmd, true),
ui.KeyShiftR: ui.NewKeyAction("Sort Resource", a.GetTable().SortColCmd("RESOURCE", true), false),
ui.KeyShiftC: ui.NewKeyAction("Sort Command", a.GetTable().SortColCmd("COMMAND", true), false),
ui.KeyShiftA: ui.NewKeyAction("Sort ApiGroup", a.GetTable().SortColCmd("API-GROUP", true), false),
})
}
func (a *Alias) gotoCmd(evt *tcell.EventKey) *tcell.EventKey {
if a.GetTable().CmdBuff().IsActive() {
return a.GetTable().activateCmd(evt)
}
path := a.GetTable().GetSelectedItem()
if path == "" {
return evt
}
a.App().gotoResource(client.NewGVR(path).String(), "", true, true)
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/pf_test.go | internal/view/pf_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 TestPortForwardNew(t *testing.T) {
pf := view.NewPortForward(client.PfGVR)
require.NoError(t, pf.Init(makeCtx(t)))
assert.Equal(t, "PortForwards", pf.Name())
assert.Len(t, pf.Hints(), 11)
}
| 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_test.go | internal/view/pf_dialog_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestExtractPort(t *testing.T) {
uu := map[string]struct {
portSpec, e string
}{
"full": {
portSpec: "co::8000",
e: "8000",
},
"toast": {
portSpec: "co:8000",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
assert.Equal(t, u.e, extractPort(u.portSpec))
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/group.go | internal/view/group.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"
)
// Group presents a RBAC group viewer.
type Group struct {
ResourceViewer
}
// NewGroup returns a new subject viewer.
func NewGroup(gvr *client.GVR) ResourceViewer {
g := Group{ResourceViewer: NewBrowser(gvr)}
g.AddBindKeysFn(g.bindKeys)
g.SetContextFn(g.subjectCtx)
return &g
}
func (g *Group) bindKeys(aa *ui.KeyActions) {
aa.Delete(ui.KeyShiftA, ui.KeyShiftP, tcell.KeyCtrlSpace, ui.KeySpace)
aa.Bulk(ui.KeyMap{
tcell.KeyEnter: ui.NewKeyAction("Rules", g.policyCmd, true),
ui.KeyShiftK: ui.NewKeyAction("Sort Kind", g.GetTable().SortColCmd("KIND", true), false),
})
}
func (*Group) subjectCtx(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeySubjectKind, "Group")
}
func (g *Group) policyCmd(evt *tcell.EventKey) *tcell.EventKey {
path := g.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if err := g.App().inject(NewPolicy(g.App(), "Group", path), false); err != nil {
g.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/types.go | internal/view/types.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/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/view/cmd"
)
const (
ageCol = "AGE"
nameCol = "NAME"
statusCol = "STATUS"
cpuCol = "CPU"
memCol = "MEM"
uptodateCol = "UP-TO-DATE"
readyCol = "READY"
availCol = "AVAILABLE"
)
type (
// EnvFunc represent the current view exposed environment.
EnvFunc func() Env
// BoostActionsFunc extends viewer keyboard actions.
BoostActionsFunc func(ui.KeyActions)
// EnterFunc represents an enter key action.
EnterFunc func(app *App, model ui.Tabular, gvr *client.GVR, path string)
// LogOptionsFunc returns the active log options.
LogOptionsFunc func(bool) (*dao.LogOptions, error)
// ContextFunc enhances a given context.
ContextFunc func(context.Context) context.Context
// BindKeysFunc adds new menu actions.
BindKeysFunc func(*ui.KeyActions)
)
// ActionExtender enhances a given viewer by adding new menu actions.
type ActionExtender interface {
// BindKeys injects new menu actions.
BindKeys(ResourceViewer)
}
// Hinter represents a view that can produce menu hints.
type Hinter interface {
// Hints returns a collection of hints.
Hints() model.MenuHints
}
// Viewer represents a component viewer.
type Viewer interface {
model.Component
// Actions returns active menu bindings.
Actions() *ui.KeyActions
// App returns an app handle.
App() *App
// Refresh updates the viewer
Refresh()
}
// TableViewer represents a tabular viewer.
type TableViewer interface {
Viewer
// GetTable returns a table component.
GetTable() *Table
}
// ResourceViewer represents a generic resource viewer.
type ResourceViewer interface {
TableViewer
// SetEnvFn sets a function to pull viewer env vars for plugins.
SetEnvFn(EnvFunc)
// GVR returns a resource descriptor.
GVR() *client.GVR
// SetContextFn provision a custom context.
SetContextFn(ContextFunc)
// AddBindKeysFn provision additional key bindings.
AddBindKeysFn(BindKeysFunc)
// SetInstance sets a parent FQN
SetInstance(string)
// SetCommand sets the current command.
SetCommand(*cmd.Interpreter)
}
// LogViewer represents a log viewer.
type LogViewer interface {
ResourceViewer
ShowLogs(prev bool)
}
// RestartableViewer represents a viewer with restartable resources.
type RestartableViewer interface {
LogViewer
}
// ScalableViewer represents a viewer with scalable resources.
type ScalableViewer interface {
LogViewer
}
// SubjectViewer represents a policy viewer.
type SubjectViewer interface {
ResourceViewer
// SetSubject sets the active subject.
SetSubject(s string)
}
// ViewerFunc returns a viewer matching a given gvr.
type ViewerFunc func(*client.GVR) ResourceViewer
// MetaViewer represents a registered meta viewer.
type MetaViewer struct {
viewerFn ViewerFunc
enterFn EnterFunc
}
// MetaViewers represents a collection of meta viewers.
type MetaViewers map[*client.GVR]MetaViewer
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/drain_dialog.go | internal/view/drain_dialog.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"strconv"
"time"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tview"
)
const drainKey = "drain"
// DrainFunc represents a drain callback function.
type DrainFunc func(v ResourceViewer, sels []string, opts dao.DrainOptions)
// ShowDrain pops a node drain dialog.
func ShowDrain(view ResourceViewer, sels []string, opts dao.DrainOptions, okFn DrainFunc) {
styles := view.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()).
SetFieldBackgroundColor(styles.BgColor.Color())
f.AddInputField("GracePeriod:", strconv.Itoa(opts.GracePeriodSeconds), 0, nil, func(v string) {
a, err := asIntOpt(v)
if err != nil {
view.App().Flash().Err(err)
return
}
view.App().Flash().Clear()
opts.GracePeriodSeconds = a
})
f.AddInputField("Timeout:", opts.Timeout.String(), 0, nil, func(v string) {
a, err := asDurOpt(v)
if err != nil {
view.App().Flash().Err(err)
return
}
view.App().Flash().Clear()
opts.Timeout = a
})
f.AddCheckbox("Ignore DaemonSets:", opts.IgnoreAllDaemonSets, func(_ string, v bool) {
opts.IgnoreAllDaemonSets = v
})
f.AddCheckbox("Delete EmptyDir Data:", opts.DeleteEmptyDirData, func(_ string, v bool) {
opts.DeleteEmptyDirData = v
})
f.AddCheckbox("Force:", opts.Force, func(_ string, v bool) {
opts.Force = v
})
f.AddCheckbox("Disable Eviction:", opts.DisableEviction, func(_ string, v bool) {
opts.DisableEviction = v
})
pages := view.App().Content.Pages
f.AddButton("Cancel", func() {
DismissDrain(view, pages)
})
f.AddButton("OK", func() {
DismissDrain(view, pages)
okFn(view, sels, opts)
})
modal := tview.NewModalForm("<Drain>", f)
path := "Drain "
if len(sels) == 1 {
path += sels[0]
} else {
path += fmt.Sprintf("(%d) nodes", len(sels))
}
path += "?"
modal.SetText(path)
modal.SetDoneFunc(func(int, string) {
DismissDrain(view, pages)
})
pages.AddPage(drainKey, modal, false, true)
pages.ShowPage(drainKey)
view.App().SetFocus(pages.GetPrimitive(drainKey))
}
// DismissDrain dismiss the port forward dialog.
func DismissDrain(v ResourceViewer, p *ui.Pages) {
p.RemovePage(drainKey)
v.App().SetFocus(p.CurrentPage().Item)
}
// ----------------------------------------------------------------------------
// Helpers...
func asDurOpt(v string) (time.Duration, error) {
d, err := time.ParseDuration(v)
if err != nil {
return 0, err
}
return d, nil
}
func asIntOpt(v string) (int, error) {
i, err := strconv.Atoi(v)
if err != nil {
return 0, err
}
return 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/context_test.go | internal/view/context_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 TestContext(t *testing.T) {
ctx := view.NewContext(client.CtGVR)
require.NoError(t, ctx.Init(makeCtx(t)))
assert.Equal(t, "Contexts", ctx.Name())
assert.Len(t, ctx.Hints(), 7)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/crd.go | internal/view/crd.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"
)
// CRD represents a crd viewer.
type CRD struct {
ResourceViewer
}
// NewCRD returns a new viewer.
func NewCRD(gvr *client.GVR) ResourceViewer {
s := CRD{
ResourceViewer: NewOwnerExtender(NewBrowser(gvr)),
}
s.AddBindKeysFn(s.bindKeys)
s.GetTable().SetEnterFn(s.showCRD)
return &s
}
func (s *CRD) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
ui.KeyShiftV: ui.NewKeyAction("Sort Versions", s.GetTable().SortColCmd("VERSIONS", false), true),
ui.KeyShiftR: ui.NewKeyAction("Sort Group", s.GetTable().SortColCmd("GROUP", true), true),
ui.KeyShiftK: ui.NewKeyAction("Sort Kind", s.GetTable().SortColCmd("KIND", true), true),
})
}
func (*CRD) showCRD(app *App, _ ui.Tabular, _ *client.GVR, path string) {
_, crd := client.Namespaced(path)
app.gotoResource(crd, "", false, true)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/browser.go | internal/view/browser.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"log/slog"
"sort"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/model1"
"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"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
)
// Browser represents a generic resource browser.
type Browser struct {
*Table
namespaces map[int]string
meta *metav1.APIResource
accessor dao.Accessor
contextFn ContextFunc
cancelFn context.CancelFunc
mx sync.RWMutex
updating bool
firstView atomic.Int32
}
// NewBrowser returns a new browser.
func NewBrowser(gvr *client.GVR) ResourceViewer {
return &Browser{
Table: NewTable(gvr),
}
}
func (b *Browser) setUpdating(f bool) {
b.mx.Lock()
defer b.mx.Unlock()
b.updating = f
}
func (b *Browser) getUpdating() bool {
b.mx.RLock()
defer b.mx.RUnlock()
return b.updating
}
// SetCommand sets the current command.
func (b *Browser) SetCommand(i *cmd.Interpreter) {
b.GetTable().SetCommand(i)
}
// Init watches all running pods in given namespace.
func (b *Browser) Init(ctx context.Context) error {
var err error
b.meta, err = dao.MetaAccess.MetaFor(b.GVR())
if err != nil {
return err
}
colorerFn := model1.DefaultColorer
if r, ok := model.Registry[b.GVR()]; ok && r.Renderer != nil {
colorerFn = r.Renderer.ColorerFunc()
}
b.GetTable().SetColorerFn(colorerFn)
if e := b.Table.Init(ctx); e != nil {
return e
}
ns := client.CleanseNamespace(b.app.Config.ActiveNamespace())
if dao.IsK8sMeta(b.meta) && b.app.ConOK() {
if _, e := b.app.factory.CanForResource(ns, b.GVR(), client.ListAccess); e != nil {
return e
}
}
if b.App().IsRunning() {
b.app.CmdBuff().Reset()
}
b.SetReadOnly(b.app.Config.IsReadOnly())
b.SetNoIcon(b.app.Config.K9s.UI.NoIcons)
b.SetFullGVR(b.app.Config.K9s.UI.UseFullGVRTitle)
b.bindKeys(b.Actions())
for _, f := range b.bindKeysFn {
f(b.Actions())
}
b.accessor, err = dao.AccessorFor(b.app.factory, b.GVR())
if err != nil {
return err
}
b.setNamespace(ns)
row, _ := b.GetSelection()
if row == 0 && b.GetRowCount() > 0 {
b.Select(1, 0)
}
b.GetModel().SetRefreshRate(b.App().Config.K9s.RefreshDuration())
b.CmdBuff().SetSuggestionFn(b.suggestFilter())
return nil
}
// InCmdMode checks if prompt is active.
func (b *Browser) InCmdMode() bool {
return b.CmdBuff().InCmdMode()
}
func (b *Browser) suggestFilter() model.SuggestionFunc {
return func(s string) (entries sort.StringSlice) {
if s == "" {
if b.App().filterHistory.Empty() {
return
}
return b.App().filterHistory.List()
}
s = strings.ToLower(s)
for _, h := range b.App().filterHistory.List() {
if s == h {
continue
}
if strings.HasPrefix(h, s) {
entries = append(entries, strings.Replace(h, s, "", 1))
}
}
return
}
}
func (b *Browser) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
tcell.KeyEscape: ui.NewSharedKeyAction("Filter Reset", b.resetCmd, false),
ui.KeyQ: ui.NewSharedKeyAction("Filter Reset", b.resetCmd, false),
tcell.KeyEnter: ui.NewSharedKeyAction("Filter", b.filterCmd, false),
tcell.KeyHelp: ui.NewSharedKeyAction("Help", b.helpCmd, false),
})
}
// SetInstance sets a single instance view.
func (b *Browser) SetInstance(path string) {
b.GetModel().SetInstance(path)
}
// Start initializes browser updates.
func (b *Browser) Start() {
ns := b.app.Config.ActiveNamespace()
if n := b.GetModel().GetNamespace(); !client.IsClusterScoped(n) {
ns = n
}
if err := b.app.switchNS(ns); err != nil {
slog.Error("Unable to switch namespace", slogs.Error, err)
}
b.Stop()
b.firstView.Store(0) // Reset first view counter on each start
b.GetModel().AddListener(b)
b.Table.Start()
b.CmdBuff().AddListener(b)
if err := b.GetModel().Watch(b.prepareContext()); err != nil {
go func() {
time.Sleep(500 * time.Millisecond)
b.app.QueueUpdateDraw(func() {
b.App().Flash().Errf("Watcher failed for %s -- %s", b.GVR(), err)
})
}()
}
}
// Stop terminates browser updates.
func (b *Browser) Stop() {
b.mx.Lock()
if b.cancelFn != nil {
b.cancelFn()
b.cancelFn = nil
}
b.mx.Unlock()
b.GetModel().RemoveListener(b)
b.CmdBuff().RemoveListener(b)
b.Table.Stop()
}
func (b *Browser) SetFilter(s string, wipe bool) {
b.CmdBuff().SetText(s, "", wipe)
}
func (b *Browser) SetLabelSelector(sel labels.Selector, wipe bool) {
if sel != nil {
b.CmdBuff().SetText(sel.String(), "", wipe)
}
b.GetModel().SetLabelSelector(sel)
}
// BufferChanged indicates the buffer was changed.
func (*Browser) BufferChanged(_, _ string) {}
// BufferCompleted indicates input was accepted.
func (b *Browser) BufferCompleted(text, _ string) {
if internal.IsLabelSelector(text) {
if sel, err := ui.ExtractLabelSelector(text); err == nil {
b.GetModel().SetLabelSelector(sel)
}
} else {
b.GetModel().SetLabelSelector(labels.Everything())
}
}
// BufferActive indicates the buff activity changed.
func (b *Browser) BufferActive(state bool, _ model.BufferKind) {
if state {
return
}
if err := b.GetModel().Refresh(b.GetContext()); err != nil {
slog.Error("Model refresh failed",
slogs.GVR, b.GVR(),
slogs.Error, err,
)
}
mdata := b.GetModel().Peek()
cdata := b.Update(mdata, b.App().Conn().HasMetrics())
b.app.QueueUpdateDraw(func() {
if b.getUpdating() {
return
}
b.setUpdating(true)
defer b.setUpdating(false)
b.UpdateUI(cdata, mdata)
if b.GetRowCount() > 1 {
b.App().filterHistory.Push(b.CmdBuff().GetText())
}
})
}
func (b *Browser) prepareContext() context.Context {
ctx := b.defaultContext()
b.mx.Lock()
if b.cancelFn != nil {
b.cancelFn()
}
ctx, b.cancelFn = context.WithCancel(ctx)
b.mx.Unlock()
if b.contextFn != nil {
ctx = b.contextFn(ctx)
}
if path, ok := ctx.Value(internal.KeyPath).(string); ok && path != "" {
b.Path = path
}
b.mx.Lock()
b.SetContext(ctx)
b.mx.Unlock()
return ctx
}
func (b *Browser) refresh() {
b.Start()
}
// Name returns the component name.
func (b *Browser) Name() string { return b.meta.Kind }
// SetContextFn populates a custom context.
func (b *Browser) SetContextFn(f ContextFunc) { b.contextFn = f }
// GetTable returns the underlying table.
func (b *Browser) GetTable() *Table { return b.Table }
// Aliases returns all available aliases.
func (b *Browser) Aliases() sets.Set[string] {
return aliases(b.meta, b.app.command.AliasesFor(client.NewGVRFromMeta(b.meta)))
}
// ----------------------------------------------------------------------------
// Model Protocol...
// TableNoData notifies view no data is available.
func (b *Browser) TableNoData(mdata *model1.TableData) {
var cancel context.CancelFunc
b.mx.RLock()
cancel = b.cancelFn
b.mx.RUnlock()
if !b.app.ConOK() || cancel == nil || !b.app.IsRunning() {
return
}
// Skip warning on first view (likely during initialization)
if b.firstView.Load() == 0 || mdata.HeaderCount() == 0 {
b.firstView.Add(1)
return
}
cdata := b.Update(mdata, b.app.Conn().HasMetrics())
b.app.QueueUpdateDraw(func() {
if b.getUpdating() {
return
}
b.setUpdating(true)
defer b.setUpdating(false)
if b.GetColumnCount() == 0 {
b.app.Flash().Warnf("No resources found for %s in %q namespace", b.GVR(), client.PrintNamespace(b.GetNamespace()))
}
b.refreshActions()
b.UpdateUI(cdata, mdata)
})
}
// TableDataChanged notifies view new data is available.
func (b *Browser) TableDataChanged(mdata *model1.TableData) {
var cancel context.CancelFunc
b.mx.RLock()
cancel = b.cancelFn
b.mx.RUnlock()
if cancel == nil || !b.app.IsRunning() {
return
}
cdata := b.Update(mdata, b.app.Conn().HasMetrics())
b.app.QueueUpdateDraw(func() {
if b.getUpdating() {
return
}
b.setUpdating(true)
defer b.setUpdating(false)
if b.GetColumnCount() == 0 {
if client.IsClusterScoped(b.GetNamespace()) {
b.app.Flash().Infof("Viewing %s...", b.GVR())
} else {
b.app.Flash().Infof("Viewing %s in namespace %s", b.GVR(), client.PrintNamespace(b.GetNamespace()))
}
}
b.refreshActions()
b.UpdateUI(cdata, mdata)
})
}
// TableLoadFailed notifies view something went south.
func (b *Browser) TableLoadFailed(err error) {
b.app.QueueUpdateDraw(func() {
b.app.Flash().Err(err)
b.App().ClearStatus(false)
})
}
// ----------------------------------------------------------------------------
// Actions...
func (b *Browser) nsWarpCmd(*tcell.EventKey) *tcell.EventKey {
path := b.GetTable().GetSelectedItem()
if path == "" {
return nil
}
o, err := b.app.factory.Get(b.GVR(), path, true, nil)
if err != nil {
return nil
}
u, ok := o.(*unstructured.Unstructured)
if !ok {
return nil
}
b.App().gotoResource(b.GVR().String()+" "+u.GetNamespace(), "", true, true)
return nil
}
func (b *Browser) viewCmd(evt *tcell.EventKey) *tcell.EventKey {
path := b.GetSelectedItem()
if path == "" {
return evt
}
v := NewLiveView(b.app, yamlAction, model.NewYAML(b.GVR(), path))
if err := v.app.inject(v, false); err != nil {
v.app.Flash().Err(err)
}
return nil
}
func (b *Browser) helpCmd(evt *tcell.EventKey) *tcell.EventKey {
if b.CmdBuff().InCmdMode() {
return nil
}
return evt
}
func (b *Browser) resetCmd(evt *tcell.EventKey) *tcell.EventKey {
if !b.CmdBuff().InCmdMode() {
hasFilter := !b.CmdBuff().Empty()
b.CmdBuff().ClearText(false)
if hasFilter {
b.GetModel().SetLabelSelector(labels.Everything())
b.Refresh()
}
return b.App().PrevCmd(evt)
}
b.CmdBuff().Reset()
if internal.IsLabelSelector(b.CmdBuff().GetText()) {
b.Start()
}
b.Refresh()
return nil
}
func (b *Browser) filterCmd(evt *tcell.EventKey) *tcell.EventKey {
if !b.CmdBuff().IsActive() {
return evt
}
b.CmdBuff().SetActive(false)
if internal.IsLabelSelector(b.CmdBuff().GetText()) {
b.Start()
return nil
}
b.Refresh()
return nil
}
func (b *Browser) enterCmd(evt *tcell.EventKey) *tcell.EventKey {
path := b.GetSelectedItem()
if b.filterCmd(evt) == nil || path == "" {
return nil
}
f := describeResource
if b.enterFn != nil {
f = b.enterFn
}
f(b.app, b.GetModel(), b.GVR(), path)
return nil
}
func (b *Browser) refreshCmd(*tcell.EventKey) *tcell.EventKey {
b.app.Flash().Info("Refreshing...")
b.refresh()
return nil
}
func (b *Browser) deleteCmd(evt *tcell.EventKey) *tcell.EventKey {
selections := b.GetSelectedItems()
if len(selections) == 0 {
return evt
}
b.Stop()
defer b.Start()
{
msg := fmt.Sprintf("Delete %s %s?", b.GVR().R(), selections[0])
if len(selections) > 1 {
msg = fmt.Sprintf("Delete %d marked %s?", len(selections), b.GVR())
}
if !dao.IsK8sMeta(b.meta) {
b.simpleDelete(selections, msg)
return nil
}
b.resourceDelete(selections, msg)
}
return nil
}
func (b *Browser) describeCmd(evt *tcell.EventKey) *tcell.EventKey {
path := b.GetSelectedItem()
if path == "" {
return evt
}
describeResource(b.app, b.GetModel(), b.GVR(), path)
return nil
}
func (b *Browser) editCmd(evt *tcell.EventKey) *tcell.EventKey {
path := b.GetSelectedItem()
if path == "" {
return evt
}
b.Stop()
defer b.Start()
if err := editRes(b.app, b.GVR(), path); err != nil {
b.App().Flash().Err(err)
}
return nil
}
func editRes(app *App, gvr *client.GVR, path string) error {
if path == "" {
return fmt.Errorf("nothing selected %q", path)
}
ns, n := client.Namespaced(path)
if client.IsClusterScoped(ns) {
ns = client.BlankNamespace
}
if ok, err := app.Conn().CanI(ns, gvr, n, client.PatchAccess); !ok || err != nil {
return fmt.Errorf("current user can't edit resource %s", gvr)
}
args := make([]string, 0, 10)
args = append(args, "edit", gvr.FQN(n))
if ns != client.BlankNamespace {
args = append(args, "-n", ns)
}
if err := runK(app, &shellOpts{clear: true, args: args}); err != nil {
app.Flash().Errf("Edit command failed: %s", err)
}
return nil
}
func (b *Browser) switchNamespaceCmd(evt *tcell.EventKey) *tcell.EventKey {
i, err := strconv.Atoi(string(evt.Rune()))
if err != nil {
slog.Error("Unable to convert keystroke", slogs.Error, err)
return nil
}
ns := b.namespaces[i]
auth, err := b.App().factory.Client().CanI(ns, b.GVR(), "", client.ListAccess)
if !auth {
if err == nil {
err = fmt.Errorf("access denied for user on: %s/%s", ns, b.GVR())
}
b.App().Flash().Err(err)
return nil
}
if err := b.app.switchNS(ns); err != nil {
b.App().Flash().Err(err)
return nil
}
b.setNamespace(ns)
if client.IsClusterScoped(ns) {
b.app.Flash().Infof("Viewing %s...", b.GVR())
} else {
b.app.Flash().Infof("Viewing %s in namespace `%s`...", b.GVR(), client.PrintNamespace(ns))
}
b.refresh()
b.UpdateTitle()
b.SelectRow(1, 0, true)
b.app.CmdBuff().Reset()
if err := b.app.Config.SetActiveNamespace(b.GetModel().GetNamespace()); err != nil {
slog.Error("Unable to set active namespace during ns switch", slogs.Error, err)
}
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func (b *Browser) setNamespace(ns string) {
ns = client.CleanseNamespace(ns)
if b.GetModel().InNamespace(ns) {
return
}
if !b.meta.Namespaced {
ns = client.ClusterScope
}
b.GetModel().SetNamespace(ns)
}
func (b *Browser) defaultContext() context.Context {
ctx := context.WithValue(context.Background(), internal.KeyFactory, b.app.factory)
ctx = context.WithValue(ctx, internal.KeyGVR, b.GVR())
ctx = context.WithValue(ctx, internal.KeyPath, b.Path)
if internal.IsLabelSelector(b.CmdBuff().GetText()) {
if sel, err := ui.ExtractLabelSelector(b.CmdBuff().GetText()); err == nil {
ctx = context.WithValue(ctx, internal.KeyLabels, sel)
}
}
ctx = context.WithValue(ctx, internal.KeyNamespace, client.CleanseNamespace(b.App().Config.ActiveNamespace()))
ctx = context.WithValue(ctx, internal.KeyWithMetrics, b.app.factory.Client().HasMetrics())
return ctx
}
func (b *Browser) refreshActions() {
if top := b.App().Content.Top(); top != nil && top.Name() != b.Name() {
return
}
aa := ui.NewKeyActionsFromMap(ui.KeyMap{
ui.KeyC: ui.NewKeyAction("Copy", b.cpCmd, false),
tcell.KeyEnter: ui.NewKeyAction("View", b.enterCmd, false),
tcell.KeyCtrlR: ui.NewKeyAction("Refresh", b.refreshCmd, false),
})
if b.app.ConOK() {
b.namespaceActions(aa)
if !b.app.Config.IsReadOnly() {
if client.Can(b.meta.Verbs, "edit") {
aa.Add(ui.KeyE, ui.NewKeyActionWithOpts("Edit", b.editCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}))
}
if client.Can(b.meta.Verbs, "delete") {
aa.Add(tcell.KeyCtrlD, ui.NewKeyActionWithOpts("Delete", b.deleteCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}))
}
} else {
b.Actions().ClearDanger()
}
}
if !dao.IsK9sMeta(b.meta) {
aa.Add(ui.KeyY, ui.NewKeyAction(yamlAction, b.viewCmd, true))
aa.Add(ui.KeyD, ui.NewKeyAction("Describe", b.describeCmd, true))
}
for _, f := range b.bindKeysFn {
f(aa)
}
b.Actions().Merge(aa)
if err := pluginActions(b, b.Actions()); err != nil {
slog.Warn("Plugins load failed", slogs.Error, err)
b.app.Logo().Warn("Plugins load failed!")
}
if err := hotKeyActions(b, b.Actions()); err != nil {
slog.Warn("Hotkeys load failed", slogs.Error, err)
b.app.Logo().Warn("HotKeys load failed!")
}
b.app.Menu().HydrateMenu(b.Hints())
}
func (b *Browser) namespaceActions(aa *ui.KeyActions) {
if !b.meta.Namespaced || b.GetTable().Path != "" {
return
}
aa.Add(ui.KeyN, ui.NewKeyAction("Copy Namespace", b.cpNsCmd, false))
if b.meta.Namespaced {
aa.Add(ui.KeyW, ui.NewKeyAction("Warp To Namespace", b.nsWarpCmd, true))
}
b.namespaces = make(map[int]string, data.MaxFavoritesNS)
var index int
if ok, _ := b.app.Conn().CanI(client.NamespaceAll, client.NsGVR, "", client.ListAccess); ok {
aa.Add(ui.Key0, ui.NewKeyAction(client.NamespaceAll, b.switchNamespaceCmd, true))
b.namespaces[0] = client.NamespaceAll
index = 1
}
favNamespaces := b.app.Config.FavNamespaces()
for _, ns := range favNamespaces {
if ns == client.NamespaceAll {
continue
}
if numKey, ok := ui.NumKeys[index]; ok {
aa.Add(numKey, ui.NewKeyAction(ns, b.switchNamespaceCmd, true))
b.namespaces[index] = ns
index++
} else {
slog.Warn("No number key available for favorite namespace. Skipping...",
slogs.Namespace, ns,
slogs.Index, index,
slogs.Max, len(favNamespaces),
)
break
}
}
}
func (b *Browser) simpleDelete(selections []string, msg string) {
d := b.app.Styles.Dialog()
dialog.ShowConfirm(&d, b.app.Content.Pages, "Confirm Delete", msg, func() {
b.ShowDeleted()
if len(selections) > 1 {
b.app.Flash().Infof("Delete %d marked %s", len(selections), b.GVR().R())
} else {
b.app.Flash().Infof("Delete resource %s %s", b.GVR(), selections[0])
}
for _, sel := range selections {
nuker, ok := b.accessor.(dao.Nuker)
if !ok {
b.app.Flash().Errf("Invalid nuker %T", b.accessor)
continue
}
if err := nuker.Delete(context.Background(), sel, nil, dao.DefaultGrace); err != nil {
b.app.Flash().Errf("Delete failed with `%s", err)
} else {
b.app.factory.DeleteForwarder(sel)
}
b.GetTable().DeleteMark(sel)
}
b.refresh()
}, func() {})
}
func (b *Browser) resourceDelete(selections []string, msg string) {
okFn := func(propagation *metav1.DeletionPropagation, force bool) {
b.ShowDeleted()
if len(selections) > 1 {
b.app.Flash().Infof("Delete %d marked %s", len(selections), b.GVR())
} else {
b.app.Flash().Infof("Delete resource %s %s", b.GVR(), selections[0])
}
for _, sel := range selections {
grace := dao.DefaultGrace
if force {
grace = dao.ForceGrace
}
if err := b.GetModel().Delete(b.defaultContext(), sel, propagation, grace); err != nil {
b.app.Flash().Errf("Delete failed with `%s", err)
} else {
b.app.factory.DeleteForwarder(sel)
}
b.GetTable().DeleteMark(sel)
}
b.refresh()
}
d := b.app.Styles.Dialog()
dialog.ShowDelete(&d, b.app.Content.Pages, msg, okFn, func() {})
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/priorityclass_test.go | internal/view/priorityclass_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 TestPriorityClassNew(t *testing.T) {
s := view.NewPriorityClass(client.PcGVR)
require.NoError(t, s.Init(makeCtx(t)))
assert.Equal(t, "PriorityClass", s.Name())
assert.Len(t, s.Hints(), 7)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/log_indicator_test.go | internal/view/log_indicator_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view_test
import (
"testing"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/view"
"github.com/stretchr/testify/assert"
)
func TestLogIndicatorRefresh(t *testing.T) {
defaults := config.NewStyles()
uu := map[string]struct {
li *view.LogIndicator
e string
}{
"all-containers": {
view.NewLogIndicator(config.NewConfig(nil), defaults, true), "[::b]AllContainers:[gray::d]Off[-::] [::b]Autoscroll:[limegreen::b]On[-::] [::b]ColumnLock:[gray::d]Off[-::] [::b]FullScreen:[gray::d]Off[-::] [::b]Timestamps:[gray::d]Off[-::] [::b]Wrap:[gray::d]Off[-::]\n",
},
"plain": {
view.NewLogIndicator(config.NewConfig(nil), defaults, false), "[::b]Autoscroll:[limegreen::b]On[-::] [::b]ColumnLock:[gray::d]Off[-::] [::b]FullScreen:[gray::d]Off[-::] [::b]Timestamps:[gray::d]Off[-::] [::b]Wrap:[gray::d]Off[-::]\n",
},
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
u.li.Refresh()
assert.Equal(t, u.e, u.li.GetText(false))
})
}
}
func BenchmarkLogIndicatorRefresh(b *testing.B) {
defaults := config.NewStyles()
v := view.NewLogIndicator(config.NewConfig(nil), defaults, true)
b.ReportAllocs()
b.ResetTimer()
for range b.N {
v.Refresh()
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/benchmark.go | internal/view/benchmark.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"log/slog"
"os"
"path/filepath"
"strings"
"github.com/derailed/k9s/internal"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/render"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// Benchmark represents a service benchmark results view.
type Benchmark struct {
ResourceViewer
}
// NewBenchmark returns a new viewer.
func NewBenchmark(gvr *client.GVR) ResourceViewer {
b := Benchmark{
ResourceViewer: NewBrowser(gvr),
}
b.GetTable().SetBorderFocusColor(tcell.ColorSeaGreen)
b.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorSeaGreen).Attributes(tcell.AttrNone))
b.GetTable().SetSortCol(ageCol, true)
b.SetContextFn(b.benchContext)
b.GetTable().SetEnterFn(b.viewBench)
return &b
}
func (b *Benchmark) benchContext(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeyDir, benchDir(b.App().Config))
}
func (b *Benchmark) viewBench(app *App, _ ui.Tabular, _ *client.GVR, path string) {
mdata, err := readBenchFile(app.Config, b.benchFile())
if err != nil {
app.Flash().Errf("Unable to load bench file %s", err)
return
}
details := NewDetails(b.App(), "Results", fileToSubject(path), contentYAML, false).Update(mdata)
if err := app.inject(details, false); err != nil {
app.Flash().Err(err)
}
}
func (b *Benchmark) benchFile() string {
r := b.GetTable().GetSelectedRowIndex()
return ui.TrimCell(b.GetTable().SelectTable, r, 7)
}
// ----------------------------------------------------------------------------
// Helpers...
func fileToSubject(path string) string {
tokens := strings.Split(path, "/")
ee := strings.Split(tokens[len(tokens)-1], "_")
return ee[0] + "/" + ee[1]
}
func benchDir(cfg *config.Config) string {
ct, err := cfg.K9s.ActiveContext()
if err != nil {
slog.Error("No active context located", slogs.Error, err)
return render.MissingValue
}
return filepath.Join(
config.AppBenchmarksDir,
data.SanitizeFileName(ct.ClusterName),
data.SanitizeFileName(cfg.K9s.ActiveContextName()),
)
}
func readBenchFile(cfg *config.Config, n string) (string, error) {
bb, err := os.ReadFile(filepath.Join(benchDir(cfg), n))
if err != nil {
return "", err
}
return string(bb), nil
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pod.go | internal/view/pod.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"errors"
"fmt"
"io/fs"
"log/slog"
"os"
"strings"
"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/model1"
"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/fatih/color"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/cli-runtime/pkg/genericclioptions"
)
const (
windowsOS = "windows"
powerShell = "powershell"
osSelector = "kubernetes.io/os"
osBetaSelector = "beta." + osSelector
trUpload = "Upload"
trDownload = "Download"
pfIndicator = "[orange::b]Ⓕ"
defaultTxRetries = 999
magicPrompt = "Yes Please!"
)
// Pod represents a pod viewer.
type Pod struct {
ResourceViewer
}
// NewPod returns a new viewer.
func NewPod(gvr *client.GVR) ResourceViewer {
var p Pod
p.ResourceViewer = NewPortForwardExtender(
NewOwnerExtender(
NewVulnerabilityExtender(
NewImageExtender(
NewLogsExtender(NewBrowser(gvr), p.logOptions),
),
),
),
)
p.AddBindKeysFn(p.bindKeys)
p.GetTable().SetEnterFn(p.showContainers)
p.GetTable().SetDecorateFn(p.portForwardIndicator)
return &p
}
func (p *Pod) portForwardIndicator(data *model1.TableData) {
ff := p.App().factory.Forwarders()
defer decorateCpuMemHeaderRows(p.App(), data)
idx, ok := data.IndexOfHeader("PF")
if !ok {
return
}
data.RowsRange(func(_ int, re model1.RowEvent) bool {
if ff.IsPodForwarded(re.Row.ID) {
re.Row.Fields[idx] = pfIndicator
}
return true
})
}
func (p *Pod) bindDangerousKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
tcell.KeyCtrlK: ui.NewKeyActionWithOpts(
"Kill",
p.killCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyS: ui.NewKeyActionWithOpts(
"Shell",
p.shellCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyA: ui.NewKeyActionWithOpts(
"Attach",
p.attachCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyT: ui.NewKeyActionWithOpts(
"Transfer",
p.transferCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
ui.KeyZ: ui.NewKeyActionWithOpts(
"Sanitize",
p.sanitizeCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
}),
})
}
func (p *Pod) bindKeys(aa *ui.KeyActions) {
if !p.App().Config.IsReadOnly() {
p.bindDangerousKeys(aa)
}
aa.Bulk(ui.KeyMap{
ui.KeyO: ui.NewKeyAction("Show Node", p.showNode, true),
ui.KeyShiftR: ui.NewKeyAction("Sort Ready", p.GetTable().SortColCmd(readyCol, true), false),
ui.KeyShiftT: ui.NewKeyAction("Sort Restart", p.GetTable().SortColCmd("RESTARTS", false), false),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", p.GetTable().SortColCmd(statusCol, true), false),
ui.KeyShiftI: ui.NewKeyAction("Sort IP", p.GetTable().SortColCmd("IP", true), false),
ui.KeyShiftO: ui.NewKeyAction("Sort Node", p.GetTable().SortColCmd("NODE", true), false),
})
aa.Merge(resourceSorters(p.GetTable()))
}
func (p *Pod) logOptions(prev bool) (*dao.LogOptions, error) {
path := p.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("you must provide a selection")
}
pod, err := fetchPod(p.App().factory, path)
if err != nil {
return nil, err
}
return podLogOptions(p.App(), path, prev, &pod.ObjectMeta, &pod.Spec), nil
}
func (p *Pod) showContainers(app *App, _ ui.Tabular, _ *client.GVR, _ string) {
co := NewContainer(client.CoGVR)
co.SetContextFn(p.coContext)
if err := app.inject(co, false); err != nil {
app.Flash().Err(err)
}
}
func (p *Pod) coContext(ctx context.Context) context.Context {
return context.WithValue(ctx, internal.KeyPath, p.GetTable().GetSelectedItem())
}
// Handlers...
func (p *Pod) showNode(evt *tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return evt
}
pod, err := fetchPod(p.App().factory, path)
if err != nil {
p.App().Flash().Err(err)
return nil
}
if pod.Spec.NodeName == "" {
p.App().Flash().Err(errors.New("no node assigned"))
return nil
}
no := NewNode(client.NodeGVR)
no.SetInstance(pod.Spec.NodeName)
if err := p.App().inject(no, false); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *Pod) killCmd(evt *tcell.EventKey) *tcell.EventKey {
selections := p.GetTable().GetSelectedItems()
if len(selections) == 0 {
return evt
}
res, err := dao.AccessorFor(p.App().factory, p.GVR())
if err != nil {
p.App().Flash().Err(err)
return nil
}
nuker, ok := res.(dao.Nuker)
if !ok {
p.App().Flash().Err(fmt.Errorf("expecting a nuker for %q", p.GVR()))
return nil
}
if len(selections) > 1 {
p.App().Flash().Infof("Delete %d marked %s", len(selections), p.GVR())
} else {
p.App().Flash().Infof("Delete resource %s %s", p.GVR(), selections[0])
}
p.GetTable().ShowDeleted()
for _, path := range selections {
if err := nuker.Delete(context.Background(), path, nil, dao.NowGrace); err != nil {
p.App().Flash().Errf("Delete failed with %s", err)
} else {
p.App().factory.DeleteForwarder(path)
}
p.GetTable().DeleteMark(path)
}
p.Refresh()
return nil
}
func (p *Pod) shellCmd(evt *tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if !podIsRunning(p.App().factory, path) {
p.App().Flash().Errf("%s is not in a running state", path)
return nil
}
if err := containerShellIn(p.App(), p, path, ""); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *Pod) attachCmd(evt *tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return evt
}
if !podIsRunning(p.App().factory, path) {
p.App().Flash().Errf("%s is not in a happy state", path)
return nil
}
if err := containerAttachIn(p.App(), p, path, ""); err != nil {
p.App().Flash().Err(err)
}
return nil
}
func (p *Pod) sanitizeCmd(*tcell.EventKey) *tcell.EventKey {
res, err := dao.AccessorFor(p.App().factory, p.GVR())
if err != nil {
p.App().Flash().Err(err)
return nil
}
s, ok := res.(dao.Sanitizer)
if !ok {
p.App().Flash().Err(fmt.Errorf("expecting a sanitizer for %q", p.GVR()))
return nil
}
msg := fmt.Sprintf("Sanitize deletes all pods in completed/error state\nPlease enter [orange::b]%s[-::-] to proceed.", magicPrompt)
dialog.ShowConfirmAck(p.App().App, p.App().Content.Pages, magicPrompt, true, "Sanitize", msg, func() {
ctx, cancel := context.WithTimeout(context.Background(), 5*p.App().Conn().Config().CallTimeout())
defer cancel()
total, err := s.Sanitize(ctx, p.GetTable().GetModel().GetNamespace())
if err != nil {
p.App().Flash().Err(err)
return
}
p.App().Flash().Infof("Sanitized %d %s", total, p.GVR())
p.Refresh()
}, func() {})
return nil
}
func (p *Pod) transferCmd(*tcell.EventKey) *tcell.EventKey {
path := p.GetTable().GetSelectedItem()
if path == "" {
return nil
}
ns, n := client.Namespaced(path)
ack := func(args dialog.TransferArgs) bool {
local := args.To
if !args.Download {
local = args.From
}
if _, err := os.Stat(local); !args.Download && errors.Is(err, fs.ErrNotExist) {
p.App().Flash().Err(err)
return false
}
opts := make([]string, 0, 10)
opts = append(opts,
"cp",
strings.TrimSpace(args.From),
strings.TrimSpace(args.To),
fmt.Sprintf("--no-preserve=%t", args.NoPreserve),
fmt.Sprintf("--retries=%d", args.Retries),
)
if args.CO != "" {
opts = append(opts, "-c="+args.CO)
}
opts = append(opts, fmt.Sprintf("--retries=%d", args.Retries))
cliOpts := shellOpts{
background: true,
args: opts,
}
op := trUpload
if args.Download {
op = trDownload
}
fqn := path + ":" + args.CO
if err := runK(p.App(), &cliOpts); err != nil {
p.App().cowCmd(err.Error())
} else {
p.App().Flash().Infof("%s successful on %s!", op, fqn)
}
return true
}
pod, err := fetchPod(p.App().factory, path)
if err != nil {
p.App().Flash().Err(err)
return nil
}
opts := dialog.TransferDialogOpts{
Title: "Transfer",
Containers: fetchContainers(&pod.ObjectMeta, &pod.Spec, false),
Message: "Download Files",
Pod: fmt.Sprintf("%s/%s:", ns, n),
Ack: ack,
Retries: defaultTxRetries,
Cancel: func() {},
}
d := p.App().Styles.Dialog()
dialog.ShowUploads(&d, p.App().Content.Pages, &opts)
return nil
}
// ----------------------------------------------------------------------------
// Helpers...
func containerShellIn(a *App, comp model.Component, path, co string) error {
if co != "" {
resumeShellIn(a, comp, path, co)
return nil
}
pod, err := fetchPod(a.factory, path)
if err != nil {
return err
}
if dco, ok := dao.GetDefaultContainer(&pod.ObjectMeta, &pod.Spec); ok {
resumeShellIn(a, comp, path, dco)
return nil
}
cc := fetchContainers(&pod.ObjectMeta, &pod.Spec, false)
if len(cc) == 1 {
resumeShellIn(a, comp, path, cc[0])
return nil
}
picker := NewPicker()
picker.populate(cc)
picker.SetSelectedFunc(func(_ int, co, _ string, _ rune) {
resumeShellIn(a, comp, path, co)
})
return a.inject(picker, false)
}
func resumeShellIn(a *App, c model.Component, path, co string) {
var err error
c.Stop()
defer func() {
c.Start()
a.QueueUpdate(func() {
if err != nil {
a.Flash().Errf("Shell exec failed: %s", err)
}
})
}()
err = shellIn(a, path, co)
}
func shellIn(a *App, fqn, co string) error {
platform, err := getPodOS(a.factory, fqn)
if err != nil {
slog.Warn("OS detection failed (assuming linux)", slogs.Error, err)
platform = "linux"
}
args := computeShellArgs(fqn, co, a.Conn().Config().Flags(), platform)
c := color.New(color.BgGreen).Add(color.FgBlack).Add(color.Bold)
return runK(a, &shellOpts{
clear: true,
banner: c.Sprintf(bannerFmt, fqn, co),
args: args},
)
}
func containerAttachIn(a *App, comp model.Component, path, co string) error {
if co != "" {
resumeAttachIn(a, comp, path, co)
return nil
}
pod, err := fetchPod(a.factory, path)
if err != nil {
return err
}
cc := fetchContainers(&pod.ObjectMeta, &pod.Spec, false)
if len(cc) == 1 {
resumeAttachIn(a, comp, path, cc[0])
return nil
}
picker := NewPicker()
picker.populate(cc)
picker.SetSelectedFunc(func(_ int, co, _ string, _ rune) {
resumeAttachIn(a, comp, path, co)
})
if err := a.inject(picker, false); err != nil {
return err
}
return nil
}
func resumeAttachIn(a *App, c model.Component, path, co string) {
c.Stop()
defer c.Start()
attachIn(a, path, co)
}
func attachIn(a *App, path, co string) {
args := buildShellArgs("attach", path, co, a.Conn().Config().Flags())
c := color.New(color.BgGreen).Add(color.FgBlack).Add(color.Bold)
if err := runK(a, &shellOpts{clear: true, banner: c.Sprintf(bannerFmt, path, co), args: args}); err != nil {
a.Flash().Errf("Attach exec failed: %s", err)
}
}
func computeShellArgs(path, co string, flags *genericclioptions.ConfigFlags, platform string) []string {
args := buildShellArgs("exec", path, co, flags)
if platform == windowsOS {
return append(args, "--", powerShell)
}
return append(args, "--", "sh", "-c", shellCheck)
}
func isFlagSet(flag *string) (string, bool) {
if flag == nil || *flag == "" {
return "", false
}
return *flag, true
}
func buildShellArgs(cmd, path, co string, flags *genericclioptions.ConfigFlags) []string {
args := make([]string, 0, 15)
args = append(args, cmd, "-it")
ns, po := client.Namespaced(path)
if ns != client.BlankNamespace {
args = append(args, "-n", ns)
}
args = append(args, po)
if flags != nil {
if v, ok := isFlagSet(flags.KubeConfig); ok {
args = append(args, "--kubeconfig", v)
}
if v, ok := isFlagSet(flags.Context); ok {
args = append(args, "--context", v)
}
if v, ok := isFlagSet(flags.BearerToken); ok {
args = append(args, "--token", v)
}
}
if co != "" {
args = append(args, "-c", co)
}
return args
}
func fetchContainers(meta *metav1.ObjectMeta, spec *v1.PodSpec, allContainers bool) []string {
nn := make([]string, 0, len(spec.Containers)+len(spec.EphemeralContainers)+len(spec.InitContainers))
// put the default container as the first entry
defaultContainer, ok := dao.GetDefaultContainer(meta, spec)
if ok {
nn = append(nn, defaultContainer)
}
for i := range spec.Containers {
if spec.Containers[i].Name != defaultContainer {
nn = append(nn, spec.Containers[i].Name)
}
}
for i := range spec.InitContainers {
isSidecar := spec.InitContainers[i].RestartPolicy != nil && *spec.InitContainers[i].RestartPolicy == v1.ContainerRestartPolicyAlways
if allContainers || isSidecar {
nn = append(nn, spec.InitContainers[i].Name)
}
}
for i := range spec.EphemeralContainers {
nn = append(nn, spec.EphemeralContainers[i].Name)
}
return nn
}
func fetchPod(f dao.Factory, path string) (*v1.Pod, error) {
o, err := f.Get(client.PodGVR, path, true, labels.Everything())
if err != nil {
return nil, err
}
var pod v1.Pod
err = runtime.DefaultUnstructuredConverter.FromUnstructured(o.(*unstructured.Unstructured).Object, &pod)
if err != nil {
return nil, err
}
return &pod, nil
}
func podIsRunning(f dao.Factory, fqn string) bool {
po, err := fetchPod(f, fqn)
if err != nil {
slog.Error("Unable to fetch pod",
slogs.FQN, fqn,
slogs.Error, err,
)
return false
}
var re render.Pod
return re.Phase(po.DeletionTimestamp, &po.Spec, &po.Status) == render.Running
}
func getPodOS(f dao.Factory, fqn string) (string, error) {
po, err := fetchPod(f, fqn)
if err != nil {
return "", err
}
if podOS, ok := osFromSelector(po.Spec.NodeSelector); ok {
return podOS, nil
}
node, err := dao.FetchNode(context.Background(), f, po.Spec.NodeName)
if err == nil {
if nodeOS, ok := osFromSelector(node.Labels); ok {
return nodeOS, nil
}
}
return "", errors.New("no os information available")
}
func osFromSelector(s map[string]string) (string, bool) {
if platform, ok := s[osBetaSelector]; ok {
return platform, ok
}
platform, ok := s[osSelector]
return platform, ok
}
func resourceSorters(t *Table) *ui.KeyActions {
return ui.NewKeyActionsFromMap(ui.KeyMap{
ui.KeyShiftC: ui.NewKeyAction("Sort CPU", t.SortColCmd(cpuCol, false), false),
ui.KeyShiftM: ui.NewKeyAction("Sort MEM", t.SortColCmd(memCol, false), false),
ui.KeyShiftX: ui.NewKeyAction("Sort CPU/R", t.SortColCmd("%CPU/R", false), false),
ui.KeyShiftZ: ui.NewKeyAction("Sort MEM/R", t.SortColCmd("%MEM/R", false), false),
tcell.KeyCtrlX: ui.NewKeyAction("Sort CPU/L", t.SortColCmd("%CPU/L", false), false),
tcell.KeyCtrlQ: ui.NewKeyAction("Sort MEM/L", t.SortColCmd("%MEM/L", false), false),
})
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/log_indicator.go | internal/view/log_indicator.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"sync/atomic"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/tview"
)
const spacer = " "
// LogIndicator represents a log view indicator.
type LogIndicator struct {
*tview.TextView
styles *config.Styles
scrollStatus int32
indicator []byte
fullScreen bool
textWrap bool
showTime bool
allContainers bool
shouldDisplayAllContainers bool
columnLock bool
}
// NewLogIndicator returns a new indicator.
func NewLogIndicator(cfg *config.Config, styles *config.Styles, allContainers bool) *LogIndicator {
l := LogIndicator{
styles: styles,
TextView: tview.NewTextView(),
indicator: make([]byte, 0, 100),
scrollStatus: 1,
fullScreen: cfg.K9s.UI.DefaultsToFullScreen,
textWrap: cfg.K9s.Logger.TextWrap,
showTime: cfg.K9s.Logger.ShowTime,
shouldDisplayAllContainers: allContainers,
columnLock: cfg.K9s.Logger.ColumnLock,
}
if cfg.K9s.Logger.DisableAutoscroll {
l.scrollStatus = 0
}
l.StylesChanged(styles)
styles.AddListener(&l)
l.SetTextAlign(tview.AlignCenter)
l.SetDynamicColors(true)
return &l
}
// StylesChanged notifies listener the skin changed.
func (l *LogIndicator) StylesChanged(styles *config.Styles) {
l.SetBackgroundColor(styles.K9s.Views.Log.Indicator.BgColor.Color())
l.SetTextColor(styles.K9s.Views.Log.Indicator.FgColor.Color())
l.Refresh()
}
// AutoScroll reports the current scrolling status.
func (l *LogIndicator) AutoScroll() bool {
return atomic.LoadInt32(&l.scrollStatus) == 1
}
// ColumnLock reports the current column lock mode.
func (l *LogIndicator) ColumnLock() bool {
return l.columnLock
}
// Timestamp reports the current timestamp mode.
func (l *LogIndicator) Timestamp() bool {
return l.showTime
}
// TextWrap reports the current wrap mode.
func (l *LogIndicator) TextWrap() bool {
return l.textWrap
}
// FullScreen reports the current screen mode.
func (l *LogIndicator) FullScreen() bool {
return l.fullScreen
}
// ToggleColumnLock toggles the current column lock mode.
func (l *LogIndicator) ToggleColumnLock() {
l.columnLock = !l.columnLock
}
// ToggleTimestamp toggles the current timestamp mode.
func (l *LogIndicator) ToggleTimestamp() {
l.showTime = !l.showTime
}
// ToggleFullScreen toggles the screen mode.
func (l *LogIndicator) ToggleFullScreen() {
l.fullScreen = !l.fullScreen
l.Refresh()
}
// ToggleTextWrap toggles the wrap mode.
func (l *LogIndicator) ToggleTextWrap() {
l.textWrap = !l.textWrap
l.Refresh()
}
// ToggleAutoScroll toggles the scroll mode.
func (l *LogIndicator) ToggleAutoScroll() {
var val int32 = 1
if l.AutoScroll() {
val = 0
}
atomic.StoreInt32(&l.scrollStatus, val)
l.Refresh()
}
// ToggleAllContainers toggles the all-containers mode.
func (l *LogIndicator) ToggleAllContainers() {
l.allContainers = !l.allContainers
l.Refresh()
}
func (l *LogIndicator) reset() {
l.Clear()
l.indicator = l.indicator[:0]
}
// Refresh updates the view.
func (l *LogIndicator) Refresh() {
l.reset()
var (
toggleFmt = "[::b]%s:["
toggleOnFmt = toggleFmt + string(l.styles.K9s.Views.Log.Indicator.ToggleOnColor) + "::b]On[-::] %s"
toggleOffFmt = toggleFmt + string(l.styles.K9s.Views.Log.Indicator.ToggleOffColor) + "::d]Off[-::]%s"
)
if l.shouldDisplayAllContainers {
if l.allContainers {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "AllContainers", spacer)...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "AllContainers", spacer)...)
}
}
if l.AutoScroll() {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "Autoscroll", spacer)...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "Autoscroll", spacer)...)
}
if l.ColumnLock() {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "ColumnLock", spacer)...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "ColumnLock", spacer)...)
}
if l.FullScreen() {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "FullScreen", spacer)...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "FullScreen", spacer)...)
}
if l.Timestamp() {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "Timestamps", spacer)...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "Timestamps", spacer)...)
}
if l.TextWrap() {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOnFmt, "Wrap", "")...)
} else {
l.indicator = append(l.indicator, fmt.Sprintf(toggleOffFmt, "Wrap", "")...)
}
_, _ = l.Write(l.indicator)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/container_test.go | internal/view/container_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 TestContainerNew(t *testing.T) {
c := view.NewContainer(client.CoGVR)
require.NoError(t, c.Init(makeCtx(t)))
assert.Equal(t, "Containers", c.Name())
assert.Len(t, c.Hints(), 20)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/yaml_test.go | internal/view/yaml_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"testing"
"github.com/derailed/k9s/internal/config"
"github.com/stretchr/testify/assert"
)
func TestYaml(t *testing.T) {
uu := []struct {
s, e string
}{
{
`api: fred
version: v1`,
`[#4682b4::b]api[#ffffff::-]: [#ffefd5::]fred
[#4682b4::b]version[#ffffff::-]: [#ffefd5::]v1`,
},
{
`api: <<<"search_0">>>fred<<<"">>>
version: v1`,
`[#4682b4::b]api[#ffffff::-]: [#ffefd5::]["search_0"]fred[""]
[#4682b4::b]version[#ffffff::-]: [#ffefd5::]v1`,
},
{
`api:
version: v1`,
`[#4682b4::b]api[#ffffff::-]:
[#4682b4::b]version[#ffffff::-]: [#ffefd5::]v1`,
},
{
" fred:blee",
"[#ffefd5::] fred:blee",
},
{
"fred blee: blee",
"[#4682b4::b]fred blee[#ffffff::-]: [#ffefd5::]blee",
},
{
"Node-Selectors: <none>",
"[#4682b4::b]Node-Selectors[#ffffff::-]: [#ffefd5::] <none>",
},
{
"fred.blee: <none>",
"[#4682b4::b]fred.blee[#ffffff::-]: [#ffefd5::] <none>",
},
{
"certmanager.k8s.io/cluster-issuer: nameOfClusterIssuer",
"[#4682b4::b]certmanager.k8s.io/cluster-issuer[#ffffff::-]: [#ffefd5::]nameOfClusterIssuer",
},
{
"Message: Pod The node was low on resource: [DiskPressure].",
"[#4682b4::b]Message[#ffffff::-]: [#ffefd5::]Pod The node was low on resource: [DiskPressure[].",
},
{
`data: "<<<"`,
`[#4682b4::b]data[#ffffff::-]: [#ffefd5::]"<<<"`,
},
}
s := config.NewStyles()
for _, u := range uu {
assert.Equal(t, u.e, colorizeYAML(s.Views().Yaml, 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_test.go | internal/view/ns_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 TestNSCleanser(t *testing.T) {
ns := view.NewNamespace(client.NsGVR)
require.NoError(t, ns.Init(makeCtx(t)))
assert.Equal(t, "Namespaces", ns.Name())
assert.Len(t, ns.Hints(), 7)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/dp.go | internal/view/dp.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"
"github.com/derailed/tcell/v2"
appsv1 "k8s.io/api/apps/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
const scaleDialogKey = "scale"
// Deploy represents a deployment view.
type Deploy struct {
ResourceViewer
}
// NewDeploy returns a new deployment view.
func NewDeploy(gvr *client.GVR) ResourceViewer {
var d Deploy
d.ResourceViewer = NewPortForwardExtender(
NewVulnerabilityExtender(
NewRestartExtender(
NewScaleExtender(
NewImageExtender(
NewOwnerExtender(
NewLogsExtender(NewBrowser(gvr), d.logOptions),
),
),
),
),
),
)
d.AddBindKeysFn(d.bindKeys)
d.GetTable().SetEnterFn(d.showPods)
return &d
}
func (d *Deploy) bindKeys(aa *ui.KeyActions) {
aa.Bulk(ui.KeyMap{
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),
ui.KeyZ: ui.NewKeyAction("ReplicaSets", d.replicaSetsCmd, true),
})
}
func (d *Deploy) logOptions(prev bool) (*dao.LogOptions, error) {
path := d.GetTable().GetSelectedItem()
if path == "" {
return nil, errors.New("you must provide a selection")
}
dp, err := d.getInstance(path)
if err != nil {
return nil, err
}
return podLogOptions(d.App(), path, prev, &dp.ObjectMeta, &dp.Spec.Template.Spec), nil
}
func (d *Deploy) replicaSetsCmd(evt *tcell.EventKey) *tcell.EventKey {
dName := d.GetTable().GetSelectedItem()
if dName == "" {
return evt
}
dp, err := d.getInstance(dName)
if err != nil {
d.App().Flash().Err(err)
return nil
}
showReplicasetsFromSelector(d.App(), dName, dp.Spec.Selector)
return nil
}
func (d *Deploy) showPods(app *App, _ ui.Tabular, _ *client.GVR, fqn string) {
dp, err := d.getInstance(fqn)
if err != nil {
app.Flash().Err(err)
return
}
showPodsFromSelector(app, fqn, dp.Spec.Selector)
}
func (d *Deploy) getInstance(fqn string) (*appsv1.Deployment, error) {
var dp dao.Deployment
dp.Init(d.App().factory, d.GVR())
return dp.GetInstance(fqn)
}
// ----------------------------------------------------------------------------
// Helpers...
func showPodsFromSelector(app *App, path string, sel *metav1.LabelSelector) {
l, err := metav1.LabelSelectorAsSelector(sel)
if err != nil {
app.Flash().Err(err)
return
}
showPods(app, path, l, "")
}
func showReplicasetsFromSelector(app *App, path string, sel *metav1.LabelSelector) {
l, err := metav1.LabelSelectorAsSelector(sel)
if err != nil {
app.Flash().Err(err)
return
}
showReplicasets(app, path, l, "")
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/pvc_test.go | internal/view/pvc_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 TestPVCNew(t *testing.T) {
v := view.NewPersistentVolumeClaim(client.PvcGVR)
require.NoError(t, v.Init(makeCtx(t)))
assert.Equal(t, "PersistentVolumeClaims", v.Name())
assert.Len(t, v.Hints(), 11)
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/env_test.go | internal/view/env_test.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestEnvReplace(t *testing.T) {
uu := map[string]struct {
arg string
err error
e string
}{
"no-args": {arg: "blee blah", e: "blee blah"},
"simple": {arg: "$A", e: "10"},
"substring": {arg: "$A and $AA", e: "10 and 20"},
"with-text": {arg: "Something $A", e: "Something 10"},
"noMatch": {arg: "blah blah and $BLEE", e: "blah blah and $BLEE"},
"lower": {arg: "And then $b happened", e: "And then blee happened"},
"dash": {arg: "$col0", e: "fred"},
"underline": {arg: "$RESOURCE_GROUP", e: "foo"},
"mix": {arg: "$col0 and then $a but $B", e: "fred and then 10 but blee"},
"subs": {arg: `{"spec" : {"suspend" : $COL0 }}`, e: `{"spec" : {"suspend" : fred }}`},
"boolean": {arg: "$COL-BOOL", e: "false"},
"invert": {arg: "$!COL-BOOL", e: "true"},
"simple_braces": {arg: "${A}", e: "10"},
"embed_braces": {arg: "blabla${A}blabla", e: "blabla10blabla"},
"open_braces": {arg: "${A", e: "${A"},
"closed_braces": {arg: "$A}", e: "10}"},
"substring_braces": {arg: "${A} and ${AA}", e: "10 and 20"},
"with-text_braces": {arg: "Something ${A}", e: "Something 10"},
"noMatch_braces": {arg: "blah blah and ${BLEE}", e: "blah blah and ${BLEE}"},
"lower_braces": {arg: "And then ${b} happened", e: "And then blee happened"},
"dash_braces": {arg: "${col0}", e: "fred"},
"underline_braces": {arg: "${RESOURCE_GROUP}", e: "foo"},
"mix_braces": {arg: "${col0} and then ${a} but ${B}", e: "fred and then 10 but blee"},
"subs_braces": {arg: `{"spec" : {"suspend" : ${COL0} }}`, e: `{"spec" : {"suspend" : fred }}`},
"boolean_braces": {arg: "${COL-BOOL}", e: "false"},
"invert_braces": {arg: "${!COL-BOOL}", e: "true"},
"special_braces": {arg: "${COL-%CPU/L}/${COL-MEM/R:L}", e: "10/32:32"},
"space_braces": {arg: "${READINESS GATES}", e: "bar"},
}
e := Env{
"A": "10",
"AA": "20",
"B": "blee",
"COL0": "fred",
"FRED": "fred",
"COL-NAME": "zorg",
"COL-BOOL": "false",
"COL-%CPU/L": "10",
"COL-MEM/R:L": "32:32",
"RESOURCE_GROUP": "foo",
"READINESS GATES": "bar",
}
for k := range uu {
u := uu[k]
t.Run(k, func(t *testing.T) {
a, err := e.Substitute(u.arg)
assert.Equal(t, u.err, err)
assert.Equal(t, u.e, a)
})
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/helm_history.go | internal/view/helm_history.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"context"
"fmt"
"strings"
"github.com/derailed/k9s/internal/client"
"github.com/derailed/k9s/internal/dao"
"github.com/derailed/k9s/internal/model"
"github.com/derailed/k9s/internal/render/helm"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/k9s/internal/ui/dialog"
"github.com/derailed/tcell/v2"
)
// History represents a helm History view.
type History struct {
ResourceViewer
Values *model.RevValues
}
// NewHistory returns a new helm-history view.
func NewHistory(gvr *client.GVR) ResourceViewer {
h := History{
ResourceViewer: NewValueExtender(NewBrowser(gvr)),
}
h.GetTable().SetColorerFn(helm.History{}.ColorerFunc())
h.GetTable().SetBorderFocusColor(tcell.ColorMediumSpringGreen)
h.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorMediumSpringGreen).Attributes(tcell.AttrNone))
h.AddBindKeysFn(h.bindKeys)
h.SetContextFn(h.HistoryContext)
h.GetTable().SetEnterFn(h.getValsCmd)
return &h
}
// Init initializes the view
func (h *History) Init(ctx context.Context) error {
if err := h.ResourceViewer.Init(ctx); err != nil {
return err
}
h.GetTable().SetSortCol("REVISION", false)
return nil
}
func (*History) HistoryContext(ctx context.Context) context.Context {
return ctx
}
func (h *History) bindKeys(aa *ui.KeyActions) {
if !h.App().Config.IsReadOnly() {
h.bindDangerousKeys(aa)
}
aa.Delete(ui.KeyShiftA, ui.KeyShiftN, tcell.KeyCtrlS, tcell.KeyCtrlSpace, ui.KeySpace, tcell.KeyCtrlD)
aa.Bulk(ui.KeyMap{
ui.KeyShiftN: ui.NewKeyAction("Sort Revision", h.GetTable().SortColCmd("REVISION", true), false),
ui.KeyShiftS: ui.NewKeyAction("Sort Status", h.GetTable().SortColCmd("STATUS", true), false),
ui.KeyShiftA: ui.NewKeyAction("Sort Age", h.GetTable().SortColCmd("AGE", true), false),
})
}
func (h *History) getValsCmd(app *App, _ ui.Tabular, _ *client.GVR, path string) {
ns, n := client.Namespaced(path)
tt := strings.Split(n, ":")
if len(tt) < 2 {
app.Flash().Err(fmt.Errorf("unable to parse version in %q", path))
return
}
name, rev := tt[0], tt[1]
h.Values = model.NewRevValues(h.GVR(), client.FQN(ns, name), rev)
v := NewLiveView(h.App(), "Values", h.Values)
if err := v.app.inject(v, false); err != nil {
v.app.Flash().Err(err)
}
}
func (h *History) bindDangerousKeys(aa *ui.KeyActions) {
aa.Add(ui.KeyR, ui.NewKeyActionWithOpts("RollBackTo...", h.rollbackCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
))
}
func (h *History) rollbackCmd(evt *tcell.EventKey) *tcell.EventKey {
path := h.GetTable().GetSelectedItem()
if path == "" {
return evt
}
ns, nrev := client.Namespaced(path)
tt := strings.Split(nrev, ":")
n, rev := nrev, ""
if len(tt) == 2 {
n, rev = tt[0], tt[1]
}
h.Stop()
defer h.Start()
msg := fmt.Sprintf("RollingBack chart [yellow::b]%s[-::-] to release <[orangered::b]%s[-::-]>?", n, rev)
dialog.ShowConfirmAck(h.App().App, h.App().Content.Pages, n, false, "Confirm Rollback", msg, func() {
ctx, cancel := context.WithTimeout(context.Background(), h.App().Conn().Config().CallTimeout())
defer cancel()
if err := h.rollback(ctx, client.FQN(ns, n), rev); err != nil {
h.App().Flash().Err(err)
} else {
h.App().Flash().Infof("Rollout restart in progress for char `%s...", n)
}
}, func() {})
return nil
}
func (h *History) rollback(ctx context.Context, path, rev string) error {
var hm dao.HelmHistory
hm.Init(h.App().factory, h.GVR())
if err := hm.Rollback(ctx, path, rev); err != nil {
return err
}
h.Refresh()
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/yaml.go | internal/view/yaml.go | // SPDX-License-Identifier: Apache-2.0
// Copyright Authors of K9s
package view
import (
"fmt"
"log/slog"
"os"
"path/filepath"
"regexp"
"strings"
"time"
"github.com/derailed/k9s/internal/config"
"github.com/derailed/k9s/internal/config/data"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/tview"
)
var (
keyValRX = regexp.MustCompile(`\A(\s*)([\w\-./\s]+):\s(.+)\z`)
keyRX = regexp.MustCompile(`\A(\s*)([\w\-./\s]+):\s*\z`)
searchRX = regexp.MustCompile(`<<<("search_\d+")>>>(.+)<<<"">>>`)
)
const (
yamlFullFmt = "%s[key::b]%s[colon::-]: [val::]%s"
yamlKeyFmt = "%s[key::b]%s[colon::-]:"
yamlValueFmt = "[val::]%s"
)
func colorizeYAML(style config.Yaml, raw string) string {
lines := strings.Split(tview.Escape(raw), "\n")
fullFmt := strings.Replace(yamlFullFmt, "[key", "["+style.KeyColor.String(), 1)
fullFmt = strings.Replace(fullFmt, "[colon", "["+style.ColonColor.String(), 1)
fullFmt = strings.Replace(fullFmt, "[val", "["+style.ValueColor.String(), 1)
keyFmt := strings.Replace(yamlKeyFmt, "[key", "["+style.KeyColor.String(), 1)
keyFmt = strings.Replace(keyFmt, "[colon", "["+style.ColonColor.String(), 1)
valFmt := strings.Replace(yamlValueFmt, "[val", "["+style.ValueColor.String(), 1)
buff := make([]string, 0, len(lines))
for _, l := range lines {
res := keyValRX.FindStringSubmatch(l)
if len(res) == 4 {
buff = append(buff, enableRegion(fmt.Sprintf(fullFmt, res[1], res[2], res[3])))
continue
}
res = keyRX.FindStringSubmatch(l)
if len(res) == 3 {
buff = append(buff, enableRegion(fmt.Sprintf(keyFmt, res[1], res[2])))
continue
}
buff = append(buff, enableRegion(fmt.Sprintf(valFmt, l)))
}
return strings.Join(buff, "\n")
}
func enableRegion(s string) string {
if searchRX.MatchString(s) {
return strings.ReplaceAll(strings.ReplaceAll(s, "<<<", "["), ">>>", "]")
}
return s
}
func saveYAML(dir, name, raw string) (string, error) {
if err := ensureDir(dir); err != nil {
return "", err
}
fName := fmt.Sprintf("%s--%d.yaml", data.SanitizeFileName(name), time.Now().Unix())
fpath := filepath.Join(dir, fName)
mod := os.O_CREATE | os.O_WRONLY
file, err := os.OpenFile(fpath, mod, 0600)
if err != nil {
slog.Error("Unable to open YAML file",
slogs.Path, fpath,
slogs.Error, err,
)
return "", nil
}
defer func() {
if err := file.Close(); err != nil {
slog.Error("Closing yaml file failed",
slogs.Path, fpath,
slogs.Error, err,
)
}
}()
if _, err := file.WriteString(raw); 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/screen_dump.go | internal/view/screen_dump.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/config/data"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
)
// ScreenDump presents a directory listing viewer.
type ScreenDump struct {
ResourceViewer
}
// NewScreenDump returns a new viewer.
func NewScreenDump(gvr *client.GVR) ResourceViewer {
s := ScreenDump{
ResourceViewer: NewBrowser(gvr),
}
s.GetTable().SetBorderFocusColor(tcell.ColorSteelBlue)
s.GetTable().SetSelectedStyle(tcell.StyleDefault.Foreground(tcell.ColorWhite).Background(tcell.ColorRoyalBlue).Attributes(tcell.AttrNone))
s.GetTable().SetSortCol(ageCol, true)
s.GetTable().SelectRow(1, 0, true)
s.GetTable().SetEnterFn(s.edit)
s.SetContextFn(s.dirContext)
return &s
}
func (s *ScreenDump) dirContext(ctx context.Context) context.Context {
dir := s.App().Config.K9s.ContextScreenDumpDir()
if err := data.EnsureFullPath(dir, data.DefaultDirMod); err != nil {
s.App().Flash().Err(err)
return ctx
}
return context.WithValue(ctx, internal.KeyDir, dir)
}
func (s *ScreenDump) edit(app *App, _ ui.Tabular, _ *client.GVR, path string) {
slog.Debug("ScreenDump selection", slogs.FQN, path)
s.Stop()
defer s.Start()
if !edit(app, &shellOpts{clear: true, args: []string{path}}) {
app.Flash().Errf("Failed to launch editor")
}
}
| go | Apache-2.0 | 3784c12ae74593e8aca597c3c347e8714ad3d6b7 | 2026-01-07T08:36:21.587988Z | false |
derailed/k9s | https://github.com/derailed/k9s/blob/3784c12ae74593e8aca597c3c347e8714ad3d6b7/internal/view/scale_extender.go | internal/view/scale_extender.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/dao"
"github.com/derailed/k9s/internal/slogs"
"github.com/derailed/k9s/internal/ui"
"github.com/derailed/tcell/v2"
"github.com/derailed/tview"
)
// ScaleExtender adds scaling extensions.
type ScaleExtender struct {
ResourceViewer
}
// NewScaleExtender returns a new extender.
func NewScaleExtender(r ResourceViewer) ResourceViewer {
s := ScaleExtender{ResourceViewer: r}
s.AddBindKeysFn(s.bindKeys)
return &s
}
func (s *ScaleExtender) bindKeys(aa *ui.KeyActions) {
if s.App().Config.IsReadOnly() {
return
}
meta, err := dao.MetaAccess.MetaFor(s.GVR())
if err != nil {
slog.Error("No meta information found",
slogs.GVR, s.GVR(),
slogs.Error, err,
)
return
}
if dao.IsScalable(meta) {
aa.Add(ui.KeyS, ui.NewKeyActionWithOpts("Scale", s.scaleCmd,
ui.ActionOpts{
Visible: true,
Dangerous: true,
},
))
}
}
func (s *ScaleExtender) scaleCmd(*tcell.EventKey) *tcell.EventKey {
paths := s.GetTable().GetSelectedItems()
if len(paths) == 0 {
return nil
}
s.Stop()
defer s.Start()
s.showScaleDialog(paths)
return nil
}
func (s *ScaleExtender) showScaleDialog(paths []string) {
form, err := s.makeScaleForm(paths)
if err != nil {
s.App().Flash().Err(err)
return
}
confirm := tview.NewModalForm("<Scale>", form)
msg := fmt.Sprintf("Scale %s %s?", singularize(s.GVR().R()), paths[0])
if len(paths) > 1 {
msg = fmt.Sprintf("Scale [%d] %s?", len(paths), s.GVR().R())
}
confirm.SetText(msg)
confirm.SetDoneFunc(func(int, string) {
s.dismissDialog()
})
s.App().Content.AddPage(scaleDialogKey, confirm, false, false)
s.App().Content.ShowPage(scaleDialogKey)
}
func (s *ScaleExtender) valueOf(col string) (string, error) {
colIdx, ok := s.GetTable().HeaderIndex(col)
if !ok {
return "", fmt.Errorf("no column index for %s", col)
}
return s.GetTable().GetSelectedCell(colIdx), nil
}
func (s *ScaleExtender) replicasFromReady(_ string) (string, error) {
replicas, err := s.valueOf("READY")
if err != nil {
return "", err
}
tokens := strings.Split(replicas, "/")
if len(tokens) < 2 {
return "", fmt.Errorf("unable to locate replicas from %s", replicas)
}
return strings.TrimRight(tokens[1], ui.DeltaSign), nil
}
func (s *ScaleExtender) replicasFromScaleSubresource(sel string) (string, error) {
res, err := dao.AccessorFor(s.App().factory, s.GVR())
if err != nil {
return "", err
}
replicasGetter, ok := res.(dao.ReplicasGetter)
if !ok {
return "", fmt.Errorf("expecting a replicasGetter resource for %q", s.GVR())
}
ctx, cancel := context.WithTimeout(context.Background(), s.App().Conn().Config().CallTimeout())
defer cancel()
replicas, err := replicasGetter.Replicas(ctx, sel)
if err != nil {
return "", err
}
return strconv.Itoa(int(replicas)), nil
}
func (s *ScaleExtender) makeScaleForm(fqns []string) (*tview.Form, error) {
factor := "0"
if len(fqns) == 1 {
// If the CRD resource supports scaling, then first try to
// read the replicas directly from the CRD.
if meta, _ := dao.MetaAccess.MetaFor(s.GVR()); dao.IsScalable(meta) {
replicas, err := s.replicasFromScaleSubresource(fqns[0])
if err == nil && replicas != "" {
factor = replicas
}
}
// For built-in resources or cases where we can't get the replicas from the CRD, we can
// only try to get the number of copies from the READY field.
if factor == "0" {
replicas, err := s.replicasFromReady(fqns[0])
if err != nil {
return nil, err
}
factor = replicas
}
}
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())
f.AddInputField("Replicas:", factor, 4, func(textToCheck string, _ rune) bool {
_, err := strconv.Atoi(textToCheck)
return err == nil
}, func(changed string) {
factor = changed
})
f.AddButton("OK", func() {
defer s.dismissDialog()
count, err := strconv.Atoi(factor)
if err != nil {
s.App().Flash().Err(err)
return
}
ctx, cancel := context.WithTimeout(context.Background(), s.App().Conn().Config().CallTimeout())
defer cancel()
for _, fqn := range fqns {
if err := s.scale(ctx, fqn, int32(count)); err != nil {
slog.Error("Unable to scale resource", slogs.FQN, fqn)
s.App().Flash().Err(err)
return
}
}
if len(fqns) != 1 {
s.App().Flash().Infof("[%d] %s scaled successfully", len(fqns), singularize(s.GVR().R()))
} else {
s.App().Flash().Infof("%s %s scaled successfully", s.GVR().R(), fqns[0])
}
})
f.AddButton("Cancel", func() {
s.dismissDialog()
})
for i := range 2 {
if b := f.GetButton(i); b != nil {
b.SetBackgroundColorActivated(styles.ButtonFocusBgColor.Color())
b.SetLabelColorActivated(styles.ButtonFocusFgColor.Color())
}
}
for i := range f.GetButtonCount() {
f.GetButton(i).
SetBackgroundColorActivated(styles.ButtonFocusBgColor.Color()).
SetLabelColorActivated(styles.ButtonFocusFgColor.Color())
}
return f, nil
}
func (s *ScaleExtender) dismissDialog() {
s.App().Content.RemovePage(scaleDialogKey)
}
func (s *ScaleExtender) scale(ctx context.Context, path string, replicas int32) error {
res, err := dao.AccessorFor(s.App().factory, s.GVR())
if err != nil {
return err
}
scaler, ok := res.(dao.Scalable)
if !ok {
return fmt.Errorf("expecting a scalable resource for %q", s.GVR())
}
return scaler.Scale(ctx, path, replicas)
}
| 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.