[v2.13] #53604 - VAI: Pod restart field returns stale value (#1035)

* Draft

* added unit test to ParseRestarts

* added integration tests

* added tests and more fixes

* removed unecessary comment

---------

Co-authored-by: Tom Lebreux <tom.lebreux@suse.com>

Author: gehrkefc

pkg/resources/formatters/formatter.go

@@ -5,7 +5,9 @@ import (
 	"compress/gzip"
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"io"
+	"time"
 
 	// helm v2 is long since deprecated
 	// Unlike helm v3, it uses Protobuf encoding, so we can't use generic decoding without the message descriptors.
@@ -16,8 +18,10 @@ import (
 	"github.com/pkg/errors"
 	"github.com/rancher/apiserver/pkg/types"
 	"github.com/rancher/norman/types/convert"
+	rescommon "github.com/rancher/steve/pkg/resources/common"
 	"github.com/rancher/wrangler/v3/pkg/data"
 	"github.com/sirupsen/logrus"
+	"k8s.io/apimachinery/pkg/util/duration"
 )
 
 var (
@@ -61,11 +65,82 @@ func HandleHelmData(request *types.APIRequest, resource *types.RawResource) {
 }
 
 func Pod(_ *types.APIRequest, resource *types.RawResource) {
-	data := resource.APIObject.Data()
-	fields := data.StringSlice("metadata", "fields")
+	objData := resource.APIObject.Data()
+	fields := objData.StringSlice("metadata", "fields")
 	if len(fields) > 2 {
-		data.SetNested(convert.LowerTitle(fields[2]), "metadata", "state", "name")
+		objData.SetNested(convert.LowerTitle(fields[2]), "metadata", "state", "name")
+	}
+
+	if resource.Schema == nil {
+		return
 	}
+
+	cols := rescommon.GetColumnDefinitions(resource.Schema)
+	for _, col := range cols {
+		if col.Name != "Restarts" {
+			continue
+		}
+
+		index := rescommon.GetIndexValueFromString(col.Field)
+		if index == -1 {
+			continue
+		}
+
+		rawFieldsRaw, ok := data.GetValue(objData, "metadata", "fields")
+		if !ok {
+			continue
+		}
+
+		rawFields, ok := rawFieldsRaw.([]interface{})
+		if !ok || index >= len(rawFields) {
+			continue
+		}
+
+		valMap, ok := rawFields[index].(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		rawFields[index] = FormatRestarts(valMap)
+		objData.SetNested(rawFields, "metadata", "fields")
+	}
+}
+
+// FormatRestarts formats a restart map as a display string.
+func FormatRestarts(valMap map[string]interface{}) string {
+	var count int64
+	var timestamp int64
+
+	if c, ok := valMap["count"]; ok {
+		switch v := c.(type) {
+		case int64:
+			count = v
+		case int:
+			count = int64(v)
+		case float64:
+			count = int64(v)
+		}
+	}
+
+	if t, ok := valMap["timestamp"]; ok {
+		switch v := t.(type) {
+		case int64:
+			timestamp = v
+		case int:
+			timestamp = int64(v)
+		case float64:
+			timestamp = int64(v)
+		}
+	}
+
+	if timestamp == 0 {
+		return fmt.Sprintf("%d", count)
+	}
+
+	t := time.UnixMilli(timestamp)
+	dur := time.Since(t)
+	humanDur := duration.HumanDuration(dur)
+	return fmt.Sprintf("%d (%s ago)", count, humanDur)
 }
 
 // decodeHelm3 receives a helm3 release data string, decodes the string data using the standard base64 library

pkg/resources/virtual/virtual.go

@@ -4,7 +4,9 @@ package virtual
 
 import (
 	"fmt"
+	"regexp"
 	"slices"
+	"strconv"
 	"time"
 
 	rescommon "github.com/rancher/steve/pkg/resources/common"
@@ -20,6 +22,27 @@ import (
 
 var now = time.Now
 
+var restartsPattern = regexp.MustCompile(`^(\d+)(?:\s+\((.+?)\s+ago\))?`)
+
+// ParseRestarts parses pod restart values like "4 (3h38m ago)" into a map
+func ParseRestarts(value string) (map[string]any, error) {
+	matches := restartsPattern.FindStringSubmatch(value)
+	if matches == nil {
+		return nil, fmt.Errorf("invalid restarts format: %q", value)
+	}
+	count, _ := strconv.ParseInt(matches[1], 10, 64)
+	var timestamp int64
+	if matches[2] != "" {
+		dur, err := rescommon.ParseTimestampOrHumanReadableDuration(matches[2])
+		if err != nil {
+			logrus.Errorf("failed to parse restart duration %q: %v", matches[2], err)
+		} else {
+			timestamp = now().Add(-dur).UnixMilli()
+		}
+	}
+	return map[string]any{"count": count, "timestamp": timestamp}, nil
+}
+
 // TransformBuilder builds transform functions for specified GVKs through GetTransformFunc
 type TransformBuilder struct {
 	defaultFields *common.DefaultFields
@@ -43,6 +66,40 @@ func (t *TransformBuilder) GetTransformFunc(gvk schema.GroupVersionKind, columns
 		converters = append(converters, clusters.TransformManagedCluster)
 	}
 
+	// Pod Logic
+	if gvk.Kind == "Pod" && gvk.Version == "v1" {
+		for _, col := range columns {
+			if col.Name == "Restarts" {
+				converters = append(converters, func(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+					index := rescommon.GetIndexValueFromString(col.Field)
+					if index == -1 {
+						return obj, nil
+					}
+
+					fields, found, err := unstructured.NestedSlice(obj.Object, "metadata", "fields")
+					if err != nil || !found || index >= len(fields) {
+						return obj, nil
+					}
+
+					val, ok := fields[index].(string)
+					if !ok {
+						return obj, nil
+					}
+
+					parsed, err := ParseRestarts(val)
+					if err != nil {
+						logrus.Warnf("Failed to parse restarts: %v", err)
+						return obj, nil
+					}
+
+					fields[index] = parsed
+					unstructured.SetNestedSlice(obj.Object, fields, "metadata", "fields")
+					return obj, nil
+				})
+			}
+		}
+	}
+
 	// Detecting if we need to convert date fields
 	for _, col := range columns {
 		gvkDateFields, gvkFound := rescommon.DateFieldsByGVK[gvk]

pkg/resources/virtual/virtual_test.go

@@ -10,12 +10,77 @@ import (
 	"github.com/rancher/steve/pkg/resources/virtual/common"
 	"github.com/rancher/steve/pkg/summarycache"
 	"github.com/rancher/wrangler/v3/pkg/summary"
+	"github.com/stretchr/testify/assert"
 	"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/schema"
 )
 
+func TestParseRestarts(t *testing.T) {
+	// Mock Now for deterministic tests
+	fixedNow := time.Unix(1737462000, 0) // 2026-01-21 13:00:00 UTC
+	now = func() time.Time {
+		return fixedNow
+	}
+	defer func() { now = time.Now }()
+
+	tests := []struct {
+		name          string
+		input         string
+		wantCount     int
+		wantTimestamp int64 // nil means no timestamp expected
+		wantErr       bool
+	}{
+		{
+			name:          "no restarts",
+			input:         "0",
+			wantCount:     0,
+			wantTimestamp: 0,
+		},
+		{
+			name:          "single restart with time (3h37m ago)",
+			input:         "1 (3h37m ago)",
+			wantCount:     1,
+			wantTimestamp: fixedNow.Add(-3*time.Hour - 37*time.Minute).UnixMilli(),
+		},
+		{
+			name:          "multiple restarts with time (3h38m ago)",
+			input:         "4 (3h38m ago)",
+			wantCount:     4,
+			wantTimestamp: fixedNow.Add(-3*time.Hour - 38*time.Minute).UnixMilli(),
+		},
+		{
+			name:    "invalid format",
+			input:   "invalid",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ParseRestarts(tt.input)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+			require.Len(t, result, 2)
+
+			count, ok := result["count"].(int64)
+			require.True(t, ok)
+			assert.Equal(t, int64(tt.wantCount), count)
+
+			require.NotNil(t, result["timestamp"])
+			timestamp, ok := result["timestamp"].(int64)
+			require.True(t, ok)
+			assert.Equal(t, tt.wantTimestamp, timestamp)
+		})
+	}
+}
+
 func TestTransformChain(t *testing.T) {
 	now = func() time.Time { return time.Date(1992, 9, 2, 0, 0, 0, 0, time.UTC) }
 	noColumns := []rescommon.ColumnDefinition{}

pkg/sqlcache/informer/listoption_indexer.go

@@ -418,7 +418,6 @@ func (l *ListOptionIndexer) decryptScanEvent(rows db.Rows, into runtime.Object)
 	}
 	if err := l.Deserialize(serialized, into); err != nil {
 		return watch.Error, err
-
 	}
 	return watch.EventType(typ), nil
 }
@@ -630,6 +629,31 @@ func (l *ListOptionIndexer) addIndexFields(key string, obj any, tx db.TxClient)
 			args = append(args, fmt.Sprint(typedValue))
 		case []string:
 			args = append(args, strings.Join(typedValue, "|"))
+		case map[string]any:
+			isPod := false
+			if u, ok := obj.(*unstructured.Unstructured); ok {
+				isPod = u.GroupVersionKind().Kind == "Pod"
+			}
+			if isPod {
+				// The pod restart transform func will split pod restart column (eg: `X (D ago)`)
+				// into two fields. We want to sort / filter on count.
+				if count, ok := typedValue["count"]; ok {
+					switch c := count.(type) {
+					case int64:
+						args = append(args, c)
+					case int:
+						args = append(args, fmt.Sprint(c))
+					case float64:
+						args = append(args, fmt.Sprint(int64(c)))
+					default:
+						args = append(args, "")
+					}
+				} else {
+					args = append(args, "")
+				}
+			} else {
+				args = append(args, "")
+			}
 		default:
 			err2 := fmt.Errorf("field %v has a non-supported type value: %v", field, value)
 			return err2

pkg/stores/sqlproxy/proxy_store.go

@@ -925,6 +925,9 @@ var TypeGuidanceTable = map[schema.GroupVersionKind]map[string]string{
 		"status.requested.memoryRaw":   "REAL",
 		"status.requested.pods":        "INT",
 	},
+	schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Pod"}: {
+		"metadata.fields[3]": "INT", // name: Restarts
+	},
 	schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Secret"}: {
 		"metadata.fields[2]": "INT", // name: Data
 	},