tmp refactoring

evgeniy-scherbina · evgeniy-scherbina · commit 00d30bd04a2c · 2025-03-19T10:27:32.000-04:00
diff --git a/coderd/prebuilds/state.go b/coderd/prebuilds/state.go
@@ -11,6 +11,119 @@ import (
 )
 
 func (p PresetState) CalculateActions(clock quartz.Clock, backoffInterval time.Duration) (*ReconciliationActions, error) {
+
+	switch {
+	//case inBackoffPeriod():
+	//	return handleBackoff()
+	//case isDeprecated():
+	//	return handleDeprecatedTemplateVersion()
+	case p.Preset.UsingActiveVersion:
+		handleActiveTemplateVersion()
+		//case x:
+		//	handleInactiveTemplateVersion()
+	}
+}
+
+func (p PresetState) handleActiveTemplateVersion() (*ReconciliationActions, error) {
+	var (
+		actual                       int32 // Running prebuilds for active version.
+		desired                      int32 // Active template version's desired instances as defined in preset.
+		eligible                     int32 // Prebuilds which can be claimed.
+		outdated                     int32 // Prebuilds which no longer match the active template version.
+		extraneous                   int32 // Extra running prebuilds for active version (somehow).
+		starting, stopping, deleting int32 // Prebuilds currently being provisioned up or down.
+	)
+
+	actual = int32(len(p.Running))
+	desired = p.Preset.DesiredInstances
+	extraneous = max(actual-p.Preset.DesiredInstances, 0)
+
+	for _, prebuild := range p.Running {
+		if prebuild.Ready {
+			eligible++
+		}
+	}
+
+	// In-progress builds are common across all presets belonging to a given template.
+	// In other words: these values will be identical across all presets belonging to this template.
+	// TODO: put in a helper method?
+	for _, progress := range p.InProgress {
+		num := progress.Count
+		switch progress.Transition {
+		case database.WorkspaceTransitionStart:
+			starting += num
+		case database.WorkspaceTransitionStop:
+			stopping += num
+		case database.WorkspaceTransitionDelete:
+			deleting += num
+		}
+	}
+
+	var (
+		toCreate = int(math.Max(0, float64(
+			desired-(actual+starting)), // The number of prebuilds currently being stopped (should be 0)
+		))
+		//toDelete = int(math.Max(0, float64(
+		//	outdated- // The number of prebuilds running above the desired count for active version
+		//		deleting), // The number of prebuilds currently being deleted
+		//))
+
+		actions = &ReconciliationActions{
+			Actual:     actual,
+			Desired:    desired,
+			Eligible:   eligible,
+			Outdated:   outdated,
+			Extraneous: extraneous,
+			Starting:   starting,
+			Stopping:   stopping,
+			Deleting:   deleting,
+		}
+	)
+
+	// It's possible that an operator could stop/start prebuilds which interfere with the reconciliation loop, so
+	// we check if there are somehow more prebuilds than we expect, and then pick random victims to be deleted.
+	if extraneous > 0 {
+		// Sort running IDs by creation time so we always delete the oldest prebuilds.
+		// In general, we want fresher prebuilds (imagine a mono-repo is cloned; newer is better).
+		slices.SortFunc(p.Running, func(a, b database.GetRunningPrebuildsRow) int {
+			if a.CreatedAt.Before(b.CreatedAt) {
+				return -1
+			}
+			if a.CreatedAt.After(b.CreatedAt) {
+				return 1
+			}
+
+			return 0
+		})
+
+		for i := 0; i < int(extraneous); i++ {
+			if i >= len(p.Running) {
+				// This should never happen.
+				// TODO: move up
+				// c.logger.Warn(ctx, "unexpected reconciliation state; extraneous count exceeds running prebuilds count!",
+				//	slog.F("running_count", len(p.Running)),
+				//	slog.F("extraneous", extraneous))
+				continue
+			}
+
+			actions.DeleteIDs = append(actions.DeleteIDs, p.Running[i].WorkspaceID)
+		}
+
+		// TODO: move up
+		// c.logger.Warn(ctx, "found extra prebuilds running, picking random victim(s)",
+		//	slog.F("template_id", p.Preset.TemplateID.String()), slog.F("desired", desired), slog.F("actual", actual), slog.F("extra", extraneous),
+		//	slog.F("victims", victims))
+
+		// Prevent the rest of the reconciliation from completing
+		return actions, nil
+	}
+
+	actions.Create = int32(toCreate)
+
+	return actions, nil
+}
+
+func (p PresetState) CalculateActionsV0(clock quartz.Clock, backoffInterval time.Duration) (*ReconciliationActions, error) {
 	// TODO: align workspace states with how we represent them on the FE and the CLI
 	//	     right now there's some slight differences which can lead to additional prebuilds being created
 
