Adds configurable custom columns to table view

internal/config/models.go

@@ -0,0 +1,98 @@
+package config
+
+import (
+	"io/ioutil"
+	"path/filepath"
+
+	"gopkg.in/yaml.v2"
+)
+
+// K9sModelConfigFile represents the location for the models configuration.
+var K9sModelConfigFile = filepath.Join(K9sHome(), "models.yml")
+
+// ModelConfigListener represents a view config listener.
+type ModelConfigListener interface {
+	// ModelSettingsChanged notifies listener the model configuration changed.
+	ModelSettingsChanged(ModelSetting)
+}
+
+// ModelSetting represents a model configuration.
+type ModelSetting struct {
+	Columns []ModelColumn `yaml:"columns"`
+}
+
+// ModelSetting represents a model configuration for a single column.
+type ModelColumn struct {
+	Name      string `yaml:"name"`
+	FieldPath string `yaml:"path"`
+}
+
+// ModelSettings represent a collection of model configurations.
+type ModelSettings struct {
+	Models map[string]ModelSetting `yaml:"models"`
+}
+
+// NewModelSettings returns a new configuration.
+func NewModelSettings() ModelSettings {
+	return ModelSettings{
+		Models: make(map[string]ModelSetting),
+	}
+}
+
+// CustomModel represents a collection of view customization.
+type CustomModel struct {
+	K9s       ModelSettings `yaml:"k9s"`
+	listeners map[string]ModelConfigListener
+}
+
+// NewCustomView returns a views configuration.
+func NewCustomModel() *CustomModel {
+	return &CustomModel{
+		K9s:       NewModelSettings(),
+		listeners: make(map[string]ModelConfigListener),
+	}
+}
+
+// Reset clears out configurations.
+func (v *CustomModel) Reset() {
+	for k := range v.K9s.Models {
+		delete(v.K9s.Models, k)
+	}
+}
+
+// Load loads view configurations.
+func (v *CustomModel) Load(path string) error {
+	raw, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	var in CustomModel
+	if err := yaml.Unmarshal(raw, &in); err != nil {
+		return err
+	}
+	v.K9s = in.K9s
+	v.fireConfigChanged()
+
+	return nil
+}
+
+// AddListener registers a new listener.
+func (v *CustomModel) AddListener(gvr string, l ModelConfigListener) {
+	v.listeners[gvr] = l
+	v.fireConfigChanged()
+}
+
+// RemoveListener unregister a listener.
+func (v *CustomModel) RemoveListener(gvr string) {
+	delete(v.listeners, gvr)
+
+}
+
+func (v *CustomModel) fireConfigChanged() {
+	for gvr, list := range v.listeners {
+		if v, ok := v.K9s.Models[gvr]; ok {
+			list.ModelSettingsChanged(v)
+		}
+	}
+}

internal/config/models_test.go

@@ -0,0 +1,18 @@
+package config_test
+
+import (
+	"testing"
+
+	"github.com/derailed/k9s/internal/config"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestModelSettingsLoad(t *testing.T) {
+	cfg := config.NewCustomModel()
+
+	assert.Nil(t, cfg.Load("testdata/model_settings.yml"))
+	assert.Equal(t, 1, len(cfg.K9s.Models))
+	assert.Equal(t, 1, len(cfg.K9s.Models["v1/nodes"].Columns))
+
+	assert.Equal(t, "metadata.labels['failure-domain.beta.kubernetes.io/zone']", cfg.K9s.Models["v1/nodes"].Columns[0].FieldPath)
+}

internal/config/testdata/model_settings.yml

@@ -0,0 +1,6 @@
+k9s:
+  models:
+    v1/nodes:
+      columns:
+        - name: ZONE
+          path: metadata.labels['failure-domain.beta.kubernetes.io/zone']

internal/keys.go

@@ -29,5 +29,6 @@ const (
 	KeyToast       ContextKey = "toast"
 	KeyWithMetrics ContextKey = "withMetrics"
 	KeyViewConfig  ContextKey = "viewConfig"
+	KeyModelConfig ContextKey = "modelConfig"
 	KeyWait        ContextKey = "wait"
 )

internal/model/table.go

@@ -3,6 +3,9 @@ package model
 import (
 	"context"
 	"fmt"
+	"github.com/derailed/k9s/internal/config"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/kubectl/pkg/util/fieldpath"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -29,15 +32,16 @@ type TableListener interface {
 
 // Table represents a table model.
 type Table struct {
-	gvr         client.GVR
-	namespace   string
-	data        *render.TableData
-	listeners   []TableListener
-	inUpdate    int32
-	refreshRate time.Duration
-	instance    string
-	mx          sync.RWMutex
-	labelFilter string
+	gvr          client.GVR
+	namespace    string
+	data         *render.TableData
+	listeners    []TableListener
+	inUpdate     int32
+	refreshRate  time.Duration
+	instance     string
+	mx           sync.RWMutex
+	labelFilter  string
+	modelSetting *config.ModelSetting
 }
 
 // NewTable returns a new table model.
@@ -250,6 +254,9 @@ func (t *Table) reconcile(ctx context.Context) error {
 		return err
 	}
 
+	currentModelSetting := t.modelSetting
+	header := customizeHeader(meta.Renderer.Header(t.namespace), currentModelSetting)
+
 	var rows render.Rows
 	if len(oo) > 0 {
 		if _, ok := meta.Renderer.(*render.Generic); ok {
@@ -258,12 +265,12 @@ func (t *Table) reconcile(ctx context.Context) error {
 				return fmt.Errorf("expecting a meta table but got %T", oo[0])
 			}
 			rows = make(render.Rows, len(table.Rows))
-			if err := genericHydrate(t.namespace, table, rows, meta.Renderer); err != nil {
+			if err := genericHydrate(t.namespace, table, rows, meta.Renderer, currentModelSetting); err != nil {
 				return err
 			}
 		} else {
 			rows = make(render.Rows, len(oo))
-			if err := hydrate(t.namespace, oo, rows, meta.Renderer); err != nil {
+			if err := hydrate(t.namespace, oo, rows, meta.Renderer, currentModelSetting); err != nil {
 				return err
 			}
 		}
@@ -277,7 +284,7 @@ func (t *Table) reconcile(ctx context.Context) error {
 		t.data.Clear()
 	}
 	t.data.Update(rows)
-	t.data.SetHeader(t.namespace, meta.Renderer.Header(t.namespace))
+	t.data.SetHeader(t.namespace, header)
 
 	if len(t.data.Header) == 0 {
 		return fmt.Errorf("fail to list resource %s", t.gvr)
@@ -286,6 +293,20 @@ func (t *Table) reconcile(ctx context.Context) error {
 	return nil
 }
 
+func customizeHeader(header render.Header, setting *config.ModelSetting) render.Header {
+	if setting == nil {
+		return header
+	}
+
+	for _, col := range setting.Columns {
+		header = append(header, render.HeaderColumn{
+			Name: col.Name,
+			// BOZO fill the rest of the settings
+		})
+	}
+	return header
+}
+
 func (t *Table) getMeta(ctx context.Context) (ResourceMeta, error) {
 	meta := t.resourceMeta()
 	factory, ok := ctx.Value(internal.KeyFactory).(dao.Factory)
@@ -327,20 +348,74 @@ func (t *Table) fireTableLoadFailed(err error) {
 	}
 }
 
+func (t *Table) Init(ctx context.Context) {
+	if cfg, ok := ctx.Value(internal.KeyModelConfig).(*config.CustomModel); ok && cfg != nil {
+		cfg.AddListener(t.gvr.String(), t)
+	}
+}
+
+func (t *Table) ModelSettingsChanged(newSetting config.ModelSetting) {
+	t.modelSetting = &newSetting
+	// BOZO should tell model to reload, but missing proper context for that
+}
+
 // ----------------------------------------------------------------------------
 // Helpers...
 
-func hydrate(ns string, oo []runtime.Object, rr render.Rows, re Renderer) error {
+func hydrate(ns string, oo []runtime.Object, rr render.Rows, re Renderer, setting *config.ModelSetting) error {
 	for i, o := range oo {
 		if err := re.Render(o, ns, &rr[i]); err != nil {
 			return err
 		}
+		customizeRow(setting, o, &rr[i])
 	}
 
 	return nil
 }
 
-func genericHydrate(ns string, table *metav1beta1.Table, rr render.Rows, re Renderer) error {
+func customizeRow(setting *config.ModelSetting, o interface{}, row *render.Row) {
+	if setting == nil {
+		return
+	}
+
+	if u, ok := tryExtractObject(o); ok {
+		for _, customColumn := range setting.Columns {
+			row.Fields = append(row.Fields, extractFieldOrErrorMsg(u, customColumn.FieldPath))
+		}
+	} else {
+		for range setting.Columns {
+			row.Fields = append(row.Fields, "<unsupported type>")
+		}
+	}
+}
+
+func tryExtractObject(o interface{}) (v1.Object, bool) {
+	switch oo := o.(type) {
+	case v1.Object:
+		return oo, true
+	case render.RenderableRaw:
+		return oo.Object(), true
+	case v1.TableRow:
+		// TODO find a way to test this
+		if ooo, ok := oo.Object.Object.(v1.Object); ok {
+			return ooo, true
+		} else {
+			return nil, false
+		}
+	default:
+		return nil, false
+	}
+}
+
+func extractFieldOrErrorMsg(obj v1.Object, fieldPath string) string {
+	fieldValue, err := fieldpath.ExtractFieldPathAsString(obj, fieldPath)
+	if err != nil {
+		return fmt.Sprintf("err: %s", err.Error())
+	}
+	return fieldValue
+}
+
+func genericHydrate(ns string, table *metav1beta1.Table, rr render.Rows, re Renderer, setting *config.ModelSetting) error {
 	gr, ok := re.(*render.Generic)
 	if !ok {
 		return fmt.Errorf("expecting generic renderer but got %T", re)
@@ -350,6 +425,7 @@ func genericHydrate(ns string, table *metav1beta1.Table, rr render.Rows, re Rend
 		if err := gr.Render(row, ns, &rr[i]); err != nil {
 			return err
 		}
+		customizeRow(setting, row, &rr[i])
 	}
 
 	return nil

internal/model/table_int_test.go

@@ -104,7 +104,7 @@ func TestTableHydrate(t *testing.T) {
 	}
 	rr := make([]render.Row, 1)
 
-	assert.Nil(t, hydrate("blee", oo, rr, render.Pod{}))
+	assert.Nil(t, hydrate("blee", oo, rr, render.Pod{}, nil))
 	assert.Equal(t, 1, len(rr))
 	assert.Equal(t, 18, len(rr[0].Fields))
 }
@@ -131,7 +131,7 @@ func TestTableGenericHydrate(t *testing.T) {
 	re := render.Generic{}
 	re.SetTable(&tt)
 
-	assert.Nil(t, genericHydrate("blee", &tt, rr, &re))
+	assert.Nil(t, genericHydrate("blee", &tt, rr, &re, nil))
 	assert.Equal(t, 2, len(rr))
 	assert.Equal(t, 3, len(rr[0].Fields))
 }

internal/render/helpers.go

@@ -16,6 +16,11 @@ import (
 	"k8s.io/apimachinery/pkg/util/duration"
 )
 
+// RenderableRaw is used for rendering custom columns from CustomModels
+type RenderableRaw interface {
+	Object() metav1.Object
+}
+
 var durationRx = regexp.MustCompile(`\A(\d*d)*?(\d*h)*?(\d*m)*?(\d*s)*?\z`)
 
 func durationToSeconds(duration string) string {

internal/render/node.go

@@ -3,6 +3,7 @@ package render
 import (
 	"errors"
 	"fmt"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sort"
 	"strconv"
 	"strings"
@@ -141,6 +142,11 @@ type NodeWithMetrics struct {
 	PodCount int
 }
 
+// Object returns a k8s Object
+func (n *NodeWithMetrics) Object() metav1.Object {
+	return n.Raw
+}
+
 // GetObjectKind returns a schema object.
 func (n *NodeWithMetrics) GetObjectKind() schema.ObjectKind {
 	return nil