Add defaults

Author: jakubno

packages/api/internal/handlers/sandboxes_list.go

@@ -86,7 +86,7 @@ func (a *APIStore) GetSandboxes(c *gin.Context, params api.GetSandboxesParams) {
 		return
 	}
 
-	sandboxes := a.orchestrator.GetSandboxes(ctx, sandbox.WithTeamID(team.ID), sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false))
+	sandboxes := a.orchestrator.GetSandboxes(ctx, sandbox.WithTeamID(team.ID), sandbox.WithState(sandbox.StateRunning))
 	runningSandboxes := getRunningSandboxes(sandboxes, metadataFilter)
 
 	// Sort sandboxes by start time descending

packages/api/internal/metrics/team.go

@@ -77,7 +77,7 @@ func (so *TeamObserver) Start(cache sandbox.Store) (err error) {
 	// Register callbacks for team sandbox metrics
 	so.registration, err = so.meter.RegisterCallback(
 		func(ctx context.Context, obs metric.Observer) error {
-			sbxs := cache.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false))
+			sbxs := cache.Items(sandbox.WithAllTeams())
 			sbxsPerTeam := make(map[string]int64)
 			for _, sbx := range sbxs {
 				teamID := sbx.TeamID.String()

packages/api/internal/orchestrator/admin.go

@@ -39,7 +39,7 @@ func (o *Orchestrator) AdminNodes() []*api.Node {
 		}
 	}
 
-	for _, sbx := range o.sandboxStore.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false)) {
+	for _, sbx := range o.sandboxStore.Items(sandbox.WithAllTeams()) {
 		n, ok := apiNodes[sbx.NodeID]
 		if !ok {
 			zap.L().Error("node for sandbox wasn't found", logger.WithNodeID(sbx.NodeID), logger.WithSandboxID(sbx.SandboxID))
@@ -84,7 +84,7 @@ func (o *Orchestrator) AdminNodeDetail(clusterID uuid.UUID, nodeIDOrNomadNodeSho
 		Metrics:         metrics,
 	}
 
-	for _, sbx := range o.sandboxStore.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false)) {
+	for _, sbx := range o.sandboxStore.Items(sandbox.WithAllTeams()) {
 		if sbx.NodeID == n.ID && sbx.ClusterID == n.ClusterID {
 			var metadata *api.SandboxMetadata
 			if sbx.Metadata != nil {

packages/api/internal/orchestrator/analytics.go

@@ -35,7 +35,7 @@ func (o *Orchestrator) reportLongRunningSandboxes(ctx context.Context) {
 			zap.L().Info("Stopping node analytics reporting due to context cancellation")
 			return
 		case <-ticker.C:
-			sandboxes := o.sandboxStore.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false))
+			sandboxes := o.sandboxStore.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithAllTeams())
 			longRunningSandboxes := make([]sandbox.Sandbox, 0, len(sandboxes))
 			for _, sandbox := range sandboxes {
 				if time.Since(sandbox.StartTime) > oldSandboxThreshold {

packages/api/internal/orchestrator/evictor/evict.go

@@ -31,7 +31,7 @@ func (e *Evictor) Start(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case <-time.After(50 * time.Millisecond):
-			for _, item := range e.store.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(true)) {
+			for _, item := range e.store.Items(sandbox.WithAllTeams(), sandbox.WithOnlyExpired(true)) {
 				go func() {
 					stateAction := sandbox.StateActionKill
 					if item.AutoPause {

packages/api/internal/orchestrator/orchestrator.go

@@ -198,7 +198,7 @@ func (o *Orchestrator) startStatusLogging(ctx context.Context) {
 			}
 
 			zap.L().Info("API internal status",
-				zap.Int("sandboxes_count", len(o.sandboxStore.Items(sandbox.WithState(sandbox.StateRunning), sandbox.WithIsExpired(false)))),
+				zap.Int("sandboxes_count", len(o.sandboxStore.Items(sandbox.WithAllTeams()))),
 				zap.Int("nodes_count", o.nodes.Count()),
 				zap.Any("nodes", connectedNodes),
 			)

packages/api/internal/sandbox/store.go

@@ -12,9 +12,18 @@ type (
 )
 
 type ItemsFilter struct {
-	TeamID    *uuid.UUID
-	States    *[]State
-	IsExpired *bool
+	TeamID      *uuid.UUID
+	States      []State
+	OnlyExpired bool
+}
+
+func NewItemsFilter() *ItemsFilter {
+	// Defaults to prevent accidental full scans
+	return &ItemsFilter{
+		States:      nil,
+		TeamID:      &uuid.Nil,
+		OnlyExpired: false,
+	}
 }
 
 type Store interface {
@@ -36,20 +45,31 @@ func WithTeamID(teamID uuid.UUID) ItemsOption {
 	}
 }
 
+func WithAllTeams() ItemsOption {
+	return func(f *ItemsFilter) {
+		f.TeamID = nil
+	}
+}
+
 func WithState(state State) ItemsOption {
 	return func(f *ItemsFilter) {
-		f.States = &[]State{state}
+		f.States = []State{state}
 	}
 }
 
 func WithStates(states ...State) ItemsOption {
 	return func(f *ItemsFilter) {
-		f.States = &states
+		if len(states) == 0 {
+			f.States = nil
+			return
+		}
+
+		f.States = states
 	}
 }
 
-func WithIsExpired(isExpired bool) ItemsOption {
+func WithOnlyExpired(isExpired bool) ItemsOption {
 	return func(f *ItemsFilter) {
-		f.IsExpired = &isExpired
+		f.OnlyExpired = isExpired
 	}
 }

packages/api/internal/sandbox/store/memory/filters.go

@@ -11,10 +11,10 @@ func applyFilter(sbx sandbox.Sandbox, filter *sandbox.ItemsFilter) bool {
 	if filter.TeamID != nil && sbx.TeamID != *filter.TeamID {
 		return false
 	}
-	if filter.States != nil && !slices.Contains(*filter.States, sbx.State) {
+	if filter.States != nil && !slices.Contains(filter.States, sbx.State) {
 		return false
 	}
-	if filter.IsExpired != nil && sbx.IsExpired() != *filter.IsExpired {
+	if sbx.IsExpired() != filter.OnlyExpired {
 		return false
 	}
 	return true

packages/api/internal/sandbox/store/memory/operations.go

@@ -79,7 +79,7 @@ func (s *Store) Remove(sandboxID string) {
 }
 
 func (s *Store) Items(options ...sandbox.ItemsOption) []sandbox.Sandbox {
-	filter := &sandbox.ItemsFilter{}
+	filter := sandbox.NewItemsFilter()
 	for _, opt := range options {
 		opt(filter)
 	}