feat: kv wildcard list

Author: amirhnajafiz

internal/components/sessions/sessions.go

@@ -16,6 +16,10 @@ type SessionStore interface {
 	// Returns ErrNotFound when absent.
 	GetSession(id, dockerdId string) (*models.Session, error)
 
+	// GetSessionById retrieves a session by id regardless of dockerd namespace.
+	// Returns ErrNotFound when absent.
+	GetSessionById(id string) (*models.Session, error)
+
 	// ListSessions returns the raw bytes of every stored session across all daemons.
 	ListSessions() ([]*models.Session, error)
 

internal/components/sessions/sessions_test.go

@@ -76,6 +76,33 @@ func TestSessionStore_Get_WrongDockerdId(t *testing.T) {
 	}
 }
 
+// The following test covers id-only retrieval across daemon namespaces.
+func TestSessionStore_GetById(t *testing.T) {
+	s := newTestSessionStore()
+
+	_ = s.SaveSession(&models.Session{Id: "s1", DockerDId: "d1", Spec: models.Spec{Image: "a"}})
+	_ = s.SaveSession(&models.Session{Id: "s2", DockerDId: "d2", Spec: models.Spec{Image: "b"}})
+
+	got, err := s.GetSessionById("s2")
+	if err != nil {
+		t.Fatalf("GetSessionById: %v", err)
+	}
+
+	if got.Id != "s2" || got.DockerDId != "d2" {
+		t.Errorf("GetSessionById: got (%s,%s), want (s2,d2)", got.Id, got.DockerDId)
+	}
+}
+
+// The following test covers id-only retrieval for unknown ids.
+func TestSessionStore_GetById_NotFound(t *testing.T) {
+	s := newTestSessionStore()
+
+	_, err := s.GetSessionById("missing")
+	if !errors.Is(err, xerrors.StorageErrNotFound) {
+		t.Errorf("GetSessionById missing: got %v, want xerrors.StorageErrNotFound", err)
+	}
+}
+
 // The following test covers the overwrite behavior of SaveSession,
 // ensuring that saving a session with the same id and dockerdId updates the existing entry rather than creating a duplicate.
 func TestSessionStore_Save_Overwrite(t *testing.T) {

internal/components/sessions/store.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/amirhnajafiz/bedrock-api/internal/storage"
 	"github.com/amirhnajafiz/bedrock-api/pkg/models"
+	"github.com/amirhnajafiz/bedrock-api/pkg/xerrors"
 )
 
 // sessionPrefix namespaces all session keys inside the shared KVStorage backend.
@@ -52,6 +53,25 @@ func (s *sessionStore) GetSession(id, dockerdId string) (*models.Session, error)
 	return session, nil
 }
 
+// GetSessionById retrieves the session by scanning all daemon namespaces.
+func (s *sessionStore) GetSessionById(id string) (*models.Session, error) {
+	bytes, err := s.backend.List(sessionPrefix + "*/" + id)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(bytes) == 0 {
+		return nil, xerrors.StorageErrNotFound
+	}
+
+	var session *models.Session
+	if err := json.Unmarshal(bytes[0], &session); err != nil {
+		return nil, err
+	}
+
+	return session, nil
+}
+
 // ListSessions returns the raw bytes of every stored session across all daemons.
 func (s *sessionStore) ListSessions() ([]*models.Session, error) {
 	bytes, err := s.backend.List(sessionPrefix)

internal/storage/gocache/backend.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"path"
 	"strings"
 	"time"
 
@@ -63,18 +64,33 @@ func (b *Backend) Delete(key string) error {
 	return b.cache.Delete(context.Background(), key)
 }
 
-// List returns the values of all entries whose keys start with prefix.
-// An empty prefix returns every value currently in the store.
+// List returns the values of all entries whose keys match wildcard.
+// If wildcard contains no glob tokens, it is treated as a key prefix.
+// If wildcard contains glob tokens ('*', '?', '['), path.Match is used.
+// An empty wildcard returns every value currently in the store.
 // The returned slice is a snapshot; mutations to it do not affect the cache.
 // eko/gocache does not expose a scan API, so this method accesses the
 // underlying go-cache client directly via Items().
-func (b *Backend) List(prefix string) ([][]byte, error) {
+func (b *Backend) List(wildcard string) ([][]byte, error) {
 	items := b.client.Items()
 	var result [][]byte
+	hasGlob := strings.ContainsAny(wildcard, "*?[")
+	if hasGlob {
+		if _, err := path.Match(wildcard, ""); err != nil {
+			return nil, fmt.Errorf("gocache: invalid wildcard %q: %w", wildcard, err)
+		}
+	}
 
 	for k, item := range items {
-		if !strings.HasPrefix(k, prefix) {
-			continue
+		if wildcard != "" {
+			if hasGlob {
+				matched, _ := path.Match(wildcard, k)
+				if !matched {
+					continue
+				}
+			} else if !strings.HasPrefix(k, wildcard) {
+				continue
+			}
 		}
 
 		data, ok := item.Object.([]byte)

internal/storage/gocache/backend_test.go

@@ -134,3 +134,36 @@ func TestBackend_List_NoMatch(t *testing.T) {
 		t.Errorf("List no-match: got %d entries, want 0", len(result))
 	}
 }
+
+func TestBackend_List_WithWildcard(t *testing.T) {
+	b := newTestBackend()
+
+	_ = b.Set("sessions/d1/s1", []byte("d1s1"))
+	_ = b.Set("sessions/d2/s1", []byte("d2s1"))
+	_ = b.Set("sessions/d2/s2", []byte("d2s2"))
+
+	result, err := b.List("sessions/*/s1")
+	if err != nil {
+		t.Fatalf("List wildcard: unexpected error: %v", err)
+	}
+
+	if len(result) != 2 {
+		t.Errorf("List sessions/*/s1: got %d entries, want 2", len(result))
+	}
+
+	want := map[string]bool{"d1s1": true, "d2s1": true}
+	for _, v := range result {
+		if !want[string(v)] {
+			t.Errorf("List wildcard returned unexpected value %q", v)
+		}
+	}
+}
+
+func TestBackend_List_InvalidWildcard(t *testing.T) {
+	b := newTestBackend()
+
+	_, err := b.List("sessions/[*/s1")
+	if err == nil {
+		t.Errorf("List invalid wildcard: expected error, got nil")
+	}
+}

internal/storage/storage.go

@@ -20,7 +20,8 @@ type KVStorage interface {
 	Get(key string) ([]byte, error)
 	// Delete removes the entry for key. It is a no-op when the key does not exist.
 	Delete(key string) error
-	// List retrieves the values for a matching wildcard with the key.
+	// List retrieves the values for keys matching wildcard.
+	// When wildcard has no glob tokens, implementations may treat it as a prefix.
 	List(wildcard string) ([][]byte, error)
 }