Index more sqlite cache fields

main.go

@@ -35,7 +35,7 @@ func main() {
 func run(_ *cli.Context) error {
 	ctx := signals.SetupSignalContext()
 	debugconfig.MustSetupDebug()
-	s, err := config.ToServer(ctx, false)
+	s, err := config.ToServer(ctx, debugconfig.SQLCache)
 	if err != nil {
 		return err
 	}

pkg/debug/cli.go

@@ -13,6 +13,7 @@ import (
 type Config struct {
 	Debug      bool
 	DebugLevel int
+	SQLCache   bool
 }
 
 func (c *Config) MustSetupDebug() {
@@ -54,6 +55,10 @@ func Flags(config *Config) []cli.Flag {
 			Value:       7,
 			Destination: &config.DebugLevel,
 		},
+		cli.BoolFlag{
+			Name:        "sql-cache",
+			Destination: &config.SQLCache,
+		},
 	}
 }
 
@@ -68,5 +73,9 @@ func FlagsV2(config *Config) []cliv2.Flag {
 			Value:       7,
 			Destination: &config.DebugLevel,
 		},
+		&cliv2.BoolFlag{
+			Name:        "sql-cache",
+			Destination: &config.SQLCache,
+		},
 	}
 }

pkg/resources/virtual/common/common.go

@@ -10,7 +10,6 @@ import (
 	wranglerSummary "github.com/rancher/wrangler/v3/pkg/summary"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/tools/cache"
 )
 
 // SummaryCache provides an interface to get a summary/relationships for an object. Implemented by the summaryCache
@@ -24,26 +23,14 @@ type DefaultFields struct {
 	Cache SummaryCache
 }
 
-// GetTransform produces the default transformation func
-func (d *DefaultFields) GetTransform() cache.TransformFunc {
-	return d.transform
-}
-
-// transform implements virtual.VirtualTransformFunc, and adds reserved fields/summary
-func (d *DefaultFields) transform(obj any) (any, error) {
-	raw, isSignal, err := getUnstructured(obj)
-	if isSignal {
-		return obj, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	raw = addIDField(raw)
-	raw, err = addSummaryFields(raw, d.Cache)
+// TransformCommon implements virtual.VirtualTransformFunc, and adds reserved fields/summary
+func (d *DefaultFields) TransformCommon(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	obj = addIDField(obj)
+	obj, err := addSummaryFields(obj, d.Cache)
 	if err != nil {
 		return nil, fmt.Errorf("unable to add summary fields: %w", err)
 	}
-	return raw, nil
+	return obj, nil
 }
 
 // addSummaryFields adds the virtual fields for object state.

pkg/resources/virtual/common/common_test.go

@@ -9,11 +9,10 @@ import (
 	"github.com/stretchr/testify/require"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/tools/cache"
 )
 
-func TestTransform(t *testing.T) {
+func TestTransformCommonObjects(t *testing.T) {
 	tests := []struct {
 		name             string
 		input            any
@@ -160,29 +159,29 @@ func TestTransform(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			fakeCache := fakeSummaryCache{
-				summarizedObject: test.hasSummary,
-				relationships:    test.hasRelationships,
+			fakeCache := common.FakeSummaryCache{
+				SummarizedObject: test.hasSummary,
+				Relationships:    test.hasRelationships,
 			}
 			df := common.DefaultFields{
 				Cache: &fakeCache,
 			}
-			output, err := df.GetTransform()(test.input)
-			require.Equal(t, test.wantOutput, output)
+			raw, isSignal, err := common.GetUnstructured(test.input)
+			if err != nil {
+				require.True(t, test.wantError)
+				return
+			}
+			if isSignal {
+				require.Equal(t, test.input, test.wantOutput)
+				return
+			}
+			output, err := df.TransformCommon(raw)
 			if test.wantError {
 				require.Error(t, err)
 			} else {
+				require.Equal(t, test.wantOutput, output)
 				require.NoError(t, err)
 			}
 		})
 	}
 }
-
-type fakeSummaryCache struct {
-	summarizedObject *summary.SummarizedObject
-	relationships    []summarycache.Relationship
-}
-
-func (f *fakeSummaryCache) SummaryAndRelationship(runtime.Object) (*summary.SummarizedObject, []summarycache.Relationship) {
-	return f.summarizedObject, f.relationships
-}

pkg/resources/virtual/common/testutil.go

@@ -0,0 +1,16 @@
+package common
+
+import (
+	"github.com/rancher/steve/pkg/summarycache"
+	"github.com/rancher/wrangler/v3/pkg/summary"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+type FakeSummaryCache struct {
+	SummarizedObject *summary.SummarizedObject
+	Relationships    []summarycache.Relationship
+}
+
+func (f *FakeSummaryCache) SummaryAndRelationship(runtime.Object) (*summary.SummarizedObject, []summarycache.Relationship) {
+	return f.SummarizedObject, f.Relationships
+}

pkg/resources/virtual/common/util.go

@@ -11,7 +11,7 @@ import (
 // GetUnstructured retrieves an unstructured object from the provided input. If this is a signal
 // object (like cache.DeletedFinalStateUnknown), returns true, indicating that this wasn't an
 // unstructured object, but doesn't need to be processed by our transform function
-func getUnstructured(obj any) (*unstructured.Unstructured, bool, error) {
+func GetUnstructured(obj any) (*unstructured.Unstructured, bool, error) {
 	raw, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		_, isFinalUnknown := obj.(cache.DeletedFinalStateUnknown)

pkg/resources/virtual/events/events.go

@@ -0,0 +1,16 @@
+// Package common provides cache.TransformFunc's for /v1 Event objects
+package events
+
+import (
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// TransformEventObject does special-case handling on event objects
+// 1. (only one so far): replaces the _type field with the contents of the field named "type", if it exists
+func TransformEventObject(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	currentTypeValue, ok := obj.Object["type"]
+	if ok {
+		obj.Object["_type"] = currentTypeValue
+	}
+	return obj, nil
+}

pkg/resources/virtual/events/events_test.go

@@ -0,0 +1,93 @@
+package events_test
+
+import (
+	"testing"
+
+	"github.com/rancher/steve/pkg/resources/virtual/events"
+	"github.com/stretchr/testify/require"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+func TestTransformEvents(t *testing.T) {
+	tests := []struct {
+		name       string
+		input      any
+		wantOutput any
+		wantError  bool
+	}{
+		{
+			name: "fix event fields",
+			input: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "/v1",
+					"kind":       "Event",
+					"metadata": map[string]interface{}{
+						"name":      "gregsFarm",
+						"namespace": "gregsNamespace",
+					},
+					"id":   "eventTest1id",
+					"type": "Gorniplatz",
+				},
+			},
+			wantOutput: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "/v1",
+					"kind":       "Event",
+					"metadata": map[string]interface{}{
+						"name":      "gregsFarm",
+						"namespace": "gregsNamespace",
+					},
+					"id":    "eventTest1id",
+					"type":  "Gorniplatz",
+					"_type": "Gorniplatz",
+				},
+			},
+		},
+		{
+			name: "don't fix non-default-group event fields",
+			input: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "palau.io/v1",
+					"kind":       "Event",
+					"metadata": map[string]interface{}{
+						"name":      "gregsFarm",
+						"namespace": "gregsNamespace",
+					},
+					"id":   "eventTest1id",
+					"type": "Gorniplatz",
+				},
+			},
+			wantOutput: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "palau.io/v1",
+					"kind":       "Event",
+					"metadata": map[string]interface{}{
+						"name":      "gregsFarm",
+						"namespace": "gregsNamespace",
+					},
+					"id":   "eventTest1id",
+					"type": "Gorniplatz",
+				},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var output interface{}
+			var err error
+			raw, ok := test.input.(*unstructured.Unstructured)
+			if ok && raw.GetKind() == "Event" && raw.GetAPIVersion() == "/v1" {
+				output, err = events.TransformEventObject(raw)
+			} else {
+				output = raw
+				err = nil
+			}
+			require.Equal(t, test.wantOutput, output)
+			if test.wantError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

pkg/resources/virtual/virtual.go

@@ -3,7 +3,11 @@
 package virtual
 
 import (
+	"fmt"
+
 	"github.com/rancher/steve/pkg/resources/virtual/common"
+	"github.com/rancher/steve/pkg/resources/virtual/events"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/tools/cache"
 )
@@ -16,13 +20,36 @@ type TransformBuilder struct {
 // NewTransformBuilder returns a TransformBuilder using the given summary cache
 func NewTransformBuilder(cache common.SummaryCache) *TransformBuilder {
 	return &TransformBuilder{
-		&common.DefaultFields{
+		defaultFields: &common.DefaultFields{
 			Cache: cache,
 		},
 	}
 }
 
-// GetTransformFunc retrieves a TransformFunc for a given GVK. Currently only returns a transformFunc for defaultFields
-func (t *TransformBuilder) GetTransformFunc(_ schema.GroupVersionKind) cache.TransformFunc {
-	return t.defaultFields.GetTransform()
+// GetTransformFunc returns the func to transform a raw object into a fixed object, if needed
+func (t *TransformBuilder) GetTransformFunc(gvk schema.GroupVersionKind) cache.TransformFunc {
+	converters := make([]func(*unstructured.Unstructured) (*unstructured.Unstructured, error), 0)
+	if gvk.Kind == "Event" && gvk.Group == "" && gvk.Version == "v1" {
+		converters = append(converters, events.TransformEventObject)
+	}
+	converters = append(converters, t.defaultFields.TransformCommon)
+
+	return func(raw interface{}) (interface{}, error) {
+		obj, isSignal, err := common.GetUnstructured(raw)
+		if isSignal {
+			// isSignal= true overrides any error
+			return raw, err
+		}
+		if err != nil {
+			return nil, fmt.Errorf("GetUnstructured: failed to get underlying object: %w", err)
+		}
+		// Conversions are run in this loop:
+		for _, f := range converters {
+			obj, err = f(obj)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return obj, nil
+	}
 }