refactor: change signature of calc-desired-instances

coder · evgeniy-scherbina · Jun 19, 2025 · May 29, 2025 · Jun 13, 2025 · Jun 13, 2025
commit 396d08006e28847eccace914c54f952a8502ca38
diff --git a/coderd/prebuilds/preset_snapshot.go b/coderd/prebuilds/preset_snapshot.go
@@ -129,10 +129,10 @@ func MatchesCron(cronExpression string, at time.Time) (bool, error) {
 // CalculateDesiredInstances returns the number of desired instances based on the provided time.
 // If the time matches any defined autoscaling schedule, the corresponding number of instances is returned.
 // Otherwise, it falls back to the default number of instances specified in the prebuild configuration.
-func (p PresetSnapshot) CalculateDesiredInstances(at time.Time) (int32, error) {
+func (p PresetSnapshot) CalculateDesiredInstances(at time.Time) int32 {
 	if len(p.PrebuildSchedules) == 0 {
 		// If no schedules are defined, fall back to the default desired instance count
-		return p.Preset.DesiredInstances.Int32, nil
+		return p.Preset.DesiredInstances.Int32
 	}
 
 	// Validate that the provided timezone is valid
@@ -144,7 +144,7 @@ func (p PresetSnapshot) CalculateDesiredInstances(at time.Time) (int32, error) {
 			slog.Error(err))
 
 		// If timezone is invalid, fall back to the default desired instance count
-		return p.Preset.DesiredInstances.Int32, nil
+		return p.Preset.DesiredInstances.Int32
 	}
 
 	// Look for a schedule whose cron expression matches the provided time
@@ -160,12 +160,12 @@ func (p PresetSnapshot) CalculateDesiredInstances(at time.Time) (int32, error) {
 			continue
 		}
 		if matches {
-			return schedule.Instances, nil
+			return schedule.Instances
 		}
 	}
 
 	// If no schedule matches, fall back to the default desired instance count
-	return p.Preset.DesiredInstances.Int32, nil
+	return p.Preset.DesiredInstances.Int32
 }
 
 // CalculateState computes the current state of prebuilds for a preset, including:
@@ -180,7 +180,7 @@ func (p PresetSnapshot) CalculateDesiredInstances(at time.Time) (int32, error) {
 // and calculates appropriate counts based on the current state of running prebuilds and
 // in-progress transitions. This state information is used to determine what reconciliation
 // actions are needed to reach the desired state.
-func (p PresetSnapshot) CalculateState() (*ReconciliationState, error) {
+func (p PresetSnapshot) CalculateState() *ReconciliationState {
 	var (
 		actual     int32
 		desired    int32
@@ -196,11 +196,7 @@ func (p PresetSnapshot) CalculateState() (*ReconciliationState, error) {
 	expired = int32(len(p.Expired))
 
 	if p.isActive() {
-		var err error
-		desired, err = p.CalculateDesiredInstances(p.clock.Now())
-		if err != nil {
-			return nil, xerrors.Errorf("failed to calculate number of desired instances: %w", err)
-		}
+		desired = p.CalculateDesiredInstances(p.clock.Now())
 		eligible = p.countEligible()
 		extraneous = max(actual-expired-desired, 0)
 	}
@@ -217,7 +213,7 @@ func (p PresetSnapshot) CalculateState() (*ReconciliationState, error) {
 		Starting: starting,
 		Stopping: stopping,
 		Deleting: deleting,
-	}, nil
+	}
 }
 
 // CalculateActions determines what actions are needed to reconcile the current state with the desired state.
@@ -272,10 +268,7 @@ func (p PresetSnapshot) isActive() bool {
 //
 // The function returns a list of actions to be executed to achieve the desired state.
 func (p PresetSnapshot) handleActiveTemplateVersion() (actions []*ReconciliationActions, err error) {
-	state, err := p.CalculateState()
-	if err != nil {
-		return nil, xerrors.Errorf("failed to calculate state: %w", err)
-	}
+	state := p.CalculateState()
 
 	// If we have expired prebuilds, delete them
 	if state.Expired > 0 {

diff --git a/coderd/prebuilds/preset_snapshot_test.go b/coderd/prebuilds/preset_snapshot_test.go
@@ -90,8 +90,7 @@ func TestNoPrebuilds(t *testing.T) {
 	ps, err := snapshot.FilterByPreset(current.presetID)
 	require.NoError(t, err)
 
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 
@@ -113,8 +112,7 @@ func TestNetNew(t *testing.T) {
 	ps, err := snapshot.FilterByPreset(current.presetID)
 	require.NoError(t, err)
 
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 
@@ -157,8 +155,7 @@ func TestOutdatedPrebuilds(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: we should identify that this prebuild is outdated and needs to be deleted.
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -176,8 +173,7 @@ func TestOutdatedPrebuilds(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: we should not be blocked from creating a new prebuild while the outdate one deletes.
-	state, err = ps.CalculateState()
-	require.NoError(t, err)
+	state = ps.CalculateState()
 	actions, err = ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{Desired: 1}, *state)
@@ -226,8 +222,7 @@ func TestDeleteOutdatedPrebuilds(t *testing.T) {
 
 	// THEN: we should identify that this prebuild is outdated and needs to be deleted.
 	// Despite the fact that deletion of another outdated prebuild is already in progress.
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -471,8 +466,7 @@ func TestInProgressActions(t *testing.T) {
 			require.NoError(t, err)
 
 			// THEN: we should identify that this prebuild is in progress.
-			state, err := ps.CalculateState()
-			require.NoError(t, err)
+			state := ps.CalculateState()
 			actions, err := ps.CalculateActions(clock, backoffInterval)
 			require.NoError(t, err)
 			tc.checkFn(*state, actions)
@@ -515,8 +509,7 @@ func TestExtraneous(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: an extraneous prebuild is detected and marked for deletion.
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -697,8 +690,7 @@ func TestExpiredPrebuilds(t *testing.T) {
 			require.NoError(t, err)
 
 			// THEN: we should identify that this prebuild is expired.
-			state, err := ps.CalculateState()
-			require.NoError(t, err)
+			state := ps.CalculateState()
 			actions, err := ps.CalculateActions(clock, backoffInterval)
 			require.NoError(t, err)
 			tc.checkFn(running, *state, actions)
@@ -734,8 +726,7 @@ func TestDeprecated(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: all running prebuilds should be deleted because the template is deprecated.
-	state, err := ps.CalculateState()
-	require.NoError(t, err)
+	state := ps.CalculateState()
 	actions, err := ps.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -788,8 +779,7 @@ func TestLatestBuildFailed(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: reconciliation should backoff.
-	state, err := psCurrent.CalculateState()
-	require.NoError(t, err)
+	state := psCurrent.CalculateState()
 	actions, err := psCurrent.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -807,8 +797,7 @@ func TestLatestBuildFailed(t *testing.T) {
 	require.NoError(t, err)
 
 	// THEN: it should NOT be in backoff because all is OK.
-	state, err = psOther.CalculateState()
-	require.NoError(t, err)
+	state = psOther.CalculateState()
 	actions, err = psOther.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -822,8 +811,7 @@ func TestLatestBuildFailed(t *testing.T) {
 	// THEN: a new prebuild should be created.
 	psCurrent, err = snapshot.FilterByPreset(current.presetID)
 	require.NoError(t, err)
-	state, err = psCurrent.CalculateState()
-	require.NoError(t, err)
+	state = psCurrent.CalculateState()
 	actions, err = psCurrent.CalculateActions(clock, backoffInterval)
 	require.NoError(t, err)
 	validateState(t, prebuilds.ReconciliationState{
@@ -886,8 +874,7 @@ func TestMultiplePresetsPerTemplateVersion(t *testing.T) {
 		ps, err := snapshot.FilterByPreset(presetOpts1.presetID)
 		require.NoError(t, err)
 
-		state, err := ps.CalculateState()
-		require.NoError(t, err)
+		state := ps.CalculateState()
 		actions, err := ps.CalculateActions(clock, backoffInterval)
 		require.NoError(t, err)
 
@@ -903,8 +890,7 @@ func TestMultiplePresetsPerTemplateVersion(t *testing.T) {
 		ps, err := snapshot.FilterByPreset(presetOpts2.presetID)
 		require.NoError(t, err)
 
-		state, err := ps.CalculateState()
-		require.NoError(t, err)
+		state := ps.CalculateState()
 		actions, err := ps.CalculateActions(clock, backoffInterval)
 		require.NoError(t, err)
 
@@ -1008,8 +994,7 @@ func TestPrebuildAutoscaling(t *testing.T) {
 				ps, err := snapshot.FilterByPreset(presetOpts1.presetID)
 				require.NoError(t, err)
 
-				state, err := ps.CalculateState()
-				require.NoError(t, err)
+				state := ps.CalculateState()
 				actions, err := ps.CalculateActions(clock, backoffInterval)
 				require.NoError(t, err)
 
@@ -1030,8 +1015,7 @@ func TestPrebuildAutoscaling(t *testing.T) {
 				ps, err := snapshot.FilterByPreset(presetOpts2.presetID)
 				require.NoError(t, err)
 
-				state, err := ps.CalculateState()
-				require.NoError(t, err)
+				state := ps.CalculateState()
 				actions, err := ps.CalculateActions(clock, backoffInterval)
 				require.NoError(t, err)
 
@@ -1402,8 +1386,7 @@ func TestCalculateDesiredInstances(t *testing.T) {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
-			desiredInstances, err := tc.snapshot.CalculateDesiredInstances(tc.at)
-			require.NoError(t, err)
+			desiredInstances := tc.snapshot.CalculateDesiredInstances(tc.at)
 			require.Equal(t, tc.expectedCalculatedInstances, desiredInstances)
 		})
 	}

diff --git a/enterprise/coderd/prebuilds/metricscollector.go b/enterprise/coderd/prebuilds/metricscollector.go
@@ -179,11 +179,7 @@ func (mc *MetricsCollector) Collect(metricsCh chan<- prometheus.Metric) {
 			mc.logger.Error(context.Background(), "failed to filter by preset", slog.Error(err))
 			continue
 		}
-		state, err := presetSnapshot.CalculateState()
-		if err != nil {
-			mc.logger.Error(context.Background(), "failed to calculate state for preset", slog.Error(err))
-			continue
-		}
+		state := presetSnapshot.CalculateState()
 
 		metricsCh <- prometheus.MustNewConstMetric(desiredPrebuildsDesc, prometheus.GaugeValue, float64(state.Desired), preset.TemplateName, preset.Name, preset.OrganizationName)
 		metricsCh <- prometheus.MustNewConstMetric(runningPrebuildsDesc, prometheus.GaugeValue, float64(state.Actual), preset.TemplateName, preset.Name, preset.OrganizationName)

diff --git a/enterprise/coderd/prebuilds/reconcile.go b/enterprise/coderd/prebuilds/reconcile.go
@@ -442,11 +442,7 @@ func (c *StoreReconciler) ReconcilePreset(ctx context.Context, ps prebuilds.Pres
 		}
 	}
 
-	state, err := ps.CalculateState()
-	if err != nil {
-		logger.Error(ctx, "failed to calculate state for preset", slog.Error(err))
-		return err
-	}
+	state := ps.CalculateState()
 	actions, err := c.CalculateActions(ctx, ps)
 	if err != nil {
 		logger.Error(ctx, "failed to calculate actions for preset", slog.Error(err))
@@ -620,10 +616,7 @@ func (c *StoreReconciler) executeReconciliationAction(ctx context.Context, logge
 		// Unexpected things happen (i.e. bugs or bitflips); let's defend against disastrous outcomes.
 		// See https://blog.robertelder.org/causes-of-bit-flips-in-computer-memory/.
 		// This is obviously not comprehensive protection against this sort of problem, but this is one essential check.
-		desired, err := ps.CalculateDesiredInstances(c.clock.Now())
-		if err != nil {
-			return xerrors.Errorf("failed to calculate desired instances: %w", err)
-		}
+		desired := ps.CalculateDesiredInstances(c.clock.Now())
 
 		if action.Create > desired {
 			logger.Critical(ctx, "determined excessive count of prebuilds to create; clamping to desired count",

diff --git a/enterprise/coderd/prebuilds/reconcile_test.go b/enterprise/coderd/prebuilds/reconcile_test.go
@@ -1368,8 +1368,7 @@ func TestFailedBuildBackoff(t *testing.T) {
 	require.Len(t, snapshot.Presets, 1)
 	presetState, err := snapshot.FilterByPreset(preset.ID)
 	require.NoError(t, err)
-	state, err := presetState.CalculateState()
-	require.NoError(t, err)
+	state := presetState.CalculateState()
 	actions, err := reconciler.CalculateActions(ctx, *presetState)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(actions))
@@ -1393,8 +1392,7 @@ func TestFailedBuildBackoff(t *testing.T) {
 	require.NoError(t, err)
 	presetState, err = snapshot.FilterByPreset(preset.ID)
 	require.NoError(t, err)
-	newState, err := presetState.CalculateState()
-	require.NoError(t, err)
+	newState := presetState.CalculateState()
 	newActions, err := reconciler.CalculateActions(ctx, *presetState)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(newActions))
@@ -1412,8 +1410,7 @@ func TestFailedBuildBackoff(t *testing.T) {
 	require.NoError(t, err)
 	presetState, err = snapshot.FilterByPreset(preset.ID)
 	require.NoError(t, err)
-	state, err = presetState.CalculateState()
-	require.NoError(t, err)
+	state = presetState.CalculateState()
 	actions, err = reconciler.CalculateActions(ctx, *presetState)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(actions))
@@ -1436,8 +1433,7 @@ func TestFailedBuildBackoff(t *testing.T) {
 	require.NoError(t, err)
 	presetState, err = snapshot.FilterByPreset(preset.ID)
 	require.NoError(t, err)
-	state, err = presetState.CalculateState()
-	require.NoError(t, err)
+	state = presetState.CalculateState()
 	actions, err = reconciler.CalculateActions(ctx, *presetState)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(actions))