feat(lifecycle): add support for profile-specific backup retention policies

Summary of changes:
- Extended the communication layer to allow PBM configuration profiles
  to carry nested 'lifecycle' configuration blocks.
- Fixed a bug in the lifecycle evaluation engine where the 'minKeep'
  safety threshold was not correctly rescuing the last successful backups
  from the purge list.
- Updated the engine to respect 'Enabled: false' states instantly,
  preventing accidental purges when the policy is disabled.

Key Technical Modifications:
- pbm/ctrl/cmd.go: Added Lifecycle struct to ProfileCmd payload.
- pbm/ctrl/send.go: Updated SendAddConfigProfile to accept lifecycle data.
- sdk/impl.go: Modified AddConfigProfile to pass lifecycle pointers from
  the parsed YAML configuration.
- pbm-agent/profile.go: Updated handleAddConfigProfile to map received
  lifecycle metadata back into the MongoDB profile documents.
- pbm/lifecycle/manager.go: Re-engineered Evaluate() to correctly enforce
  MinKeep logic and handle disabled policies via early exit.
- pbm/lifecycle/manager_test.go: Updated unit tests to reflect and
  verify the corrected safety behavior for in-progress and last-base backups.

Validated in a sharded lab environment with physical and logical storage
profiles, verifying that retention rules are applied correctly per-profile.

Author: daniel-percona

cmd/pbm-agent/profile.go

@@ -111,6 +111,9 @@ func (a *Agent) handleAddConfigProfile(
 		IsProfile: true,
 		Storage:   cmd.Storage,
 	}
+	if cmd.Lifecycle != nil {
+		profile.Lifecycle = *cmd.Lifecycle
+	}
 	err = config.AddProfile(ctx, a.leadConn, profile)
 	if err != nil {
 		err = errors.Wrap(err, "add profile config")

pbm/config/util.go

@@ -35,6 +35,7 @@ func GetProfiledConfig(ctx context.Context, conn connect.Client, profile string)
 		cfg.Storage = custom.Storage
 		cfg.Name = custom.Name
 		cfg.IsProfile = true
+		cfg.Lifecycle = custom.Lifecycle
 	}
 
 	if storage.ParseType(string(cfg.Storage.Type)) == storage.Undefined {

pbm/ctrl/cmd.go

@@ -115,9 +115,10 @@ func (c Cmd) String() string {
 }
 
 type ProfileCmd struct {
-	Name      string             `bson:"name"`
-	IsProfile bool               `bson:"profile"`
-	Storage   config.StorageConf `bson:"storage"`
+	Name      string                `bson:"name"`
+	IsProfile bool                  `bson:"profile"`
+	Storage   config.StorageConf    `bson:"storage"`
+	Lifecycle *config.LifecycleConf `bson:"lifecycle,omitempty"`
 }
 
 type ResyncCmd struct {

pbm/ctrl/send.go

@@ -75,13 +75,15 @@ func SendAddConfigProfile(
 	m connect.Client,
 	name string,
 	storage config.StorageConf,
+	lifecycle *config.LifecycleConf,
 ) (OPID, error) {
 	cmd := Cmd{
 		Cmd: CmdAddConfigProfile,
 		Profile: &ProfileCmd{
 			Name:      name,
 			IsProfile: true,
 			Storage:   storage,
+			Lifecycle: lifecycle,
 		},
 	}
 	return sendCommand(ctx, m, cmd)

pbm/lifecycle/manager.go

@@ -3,6 +3,7 @@ package lifecycle
 import (
 	"fmt"
 	"math"
+	"slices"
 	"strings"
 	"time"
 
@@ -61,7 +62,7 @@ func (r *Report) String() string {
 	return res
 }
 
-// Evaluate determines which backups to keep and which to purge based on the config.
+// Replace the Evaluate function (~ line 50) with this:
 func Evaluate(cfg config.LifecycleConf, backups []backup.BackupMeta, dryRun bool, now time.Time) *Report {
 	report := &Report{
 		DryRun:      dryRun,
@@ -70,12 +71,20 @@ func Evaluate(cfg config.LifecycleConf, backups []backup.BackupMeta, dryRun bool
 		BackupTypes: make(map[string]string),
 	}
 
-	if !cfg.Enabled && !dryRun {
+	// BUG FIX: If Disabled, go to sleep. Keep everything.
+	if !cfg.Enabled {
+		for _, bcp := range backups {
+			if bcp.Status.IsRunning() {
+				continue
+			}
+			report.BackupTypes[bcp.Name] = string(bcp.Type)
+			report.BackupsKept = append(report.BackupsKept, bcp.Name)
+			report.KeepReasons[bcp.Name] = []string{"Lifecycle Disabled"}
+		}
 		return report
 	}
 
 	isCalendar := strings.ToLower(cfg.Strategy) == "calendar"
-
 	keepMap := make(map[string][]string)
 
 	addReason := func(name, reason string) {
@@ -161,10 +170,9 @@ func Evaluate(cfg config.LifecycleConf, backups []backup.BackupMeta, dryRun bool
 	// 3. Finalize Lists
 	for _, bcp := range backups {
 		if bcp.Status.IsRunning() {
-			continue // Hide in-progress backups from the Keep/Purge report
+			continue
 		}
 
-		// Capture the type for every completed backup evaluated
 		report.BackupTypes[bcp.Name] = string(bcp.Type)
 
 		if len(keepMap[bcp.Name]) > 0 {
@@ -175,6 +183,45 @@ func Evaluate(cfg config.LifecycleConf, backups []backup.BackupMeta, dryRun bool
 		}
 	}
 
+	// BUG FIX: 4. Enforce Min Keep (Rescue backups from PURGE)
+	minKeep := 1
+	if cfg.MinKeep != nil {
+		minKeep = *cfg.MinKeep
+	}
+
+	if minKeep > 0 && len(report.BackupsKept) < minKeep {
+		var rescue []backup.BackupMeta
+		for _, bcp := range backups {
+			if bcp.Status == defs.StatusDone && len(keepMap[bcp.Name]) == 0 {
+				rescue = append(rescue, bcp)
+			}
+		}
+
+		// Sort newest first to rescue the most recent ones
+		slices.SortFunc(rescue, func(a, b backup.BackupMeta) int {
+			if a.StartTS > b.StartTS {
+				return -1
+			}
+			if a.StartTS < b.StartTS {
+				return 1
+			}
+			return 0
+		})
+
+		for _, bcp := range rescue {
+			if len(report.BackupsKept) >= minKeep {
+				break
+			}
+			report.BackupsKept = append(report.BackupsKept, bcp.Name)
+			report.KeepReasons[bcp.Name] = []string{"Min Keep"}
+
+			// Remove from Purged list safely
+			report.BackupsPurged = slices.DeleteFunc(report.BackupsPurged, func(name string) bool {
+				return name == bcp.Name
+			})
+		}
+	}
+
 	return report
 }
 

pbm/lifecycle/manager_test.go

@@ -39,7 +39,7 @@ func TestEvaluate(t *testing.T) {
 	}{
 		// --- STANDARD DATE SCENARIOS ---
 		{
-			name: "Feature Disabled BUT Dry Run is True (Bypass enabled flag)",
+			name: "Feature Disabled (Dry run or not, it sleeps)",
 			cfg: config.LifecycleConf{
 				Enabled:        false,
 				DailyRetention: 1,
@@ -50,8 +50,8 @@ func TestEvaluate(t *testing.T) {
 				mockBcp("bcp-old", 10, standardDate, defs.StatusDone),
 			},
 			dryRun:         true,
-			expectedKept:   []string{"bcp-today"},
-			expectedPurged: []string{"bcp-old"},
+			expectedKept:   []string{"bcp-today", "bcp-old"},
+			expectedPurged: []string{},
 		},
 		{
 			name: "Rolling Strategy - Basic GFS (7 Daily, 4 Weekly)",
@@ -133,19 +133,21 @@ func TestEvaluate(t *testing.T) {
 
 		// --- STATE HANDLING SCENARIOS ---
 		{
-			name: "In-Progress Backups are ALWAYS protected",
+			name: "In-Progress Backups are ALWAYS protected (and MinKeep rescues the last safe base)",
 			cfg: config.LifecycleConf{
 				Enabled:        true,
 				DailyRetention: 1,
 			},
 			mockNow: standardDate,
 			backups: []backup.BackupMeta{
-				mockBcp("bcp-running", 50, standardDate, defs.StatusRunning),
-				mockBcp("bcp-done-old", 50, standardDate, defs.StatusDone),
+				mockBcp("bcp-running", 0, standardDate, defs.StatusRunning), // In-progress today
+				mockBcp("bcp-done-old", 50, standardDate, defs.StatusDone),  // 50 days old, normally purged
 			},
-			dryRun:         false,
-			expectedKept:   nil,
-			expectedPurged: []string{"bcp-done-old"},
+			dryRun: false,
+			// bcp-running is implicitly protected (hidden from purge).
+			// bcp-done-old is expired, but rescued because MinKeep defaults to 1 and the running backup doesn't count yet!
+			expectedKept:   []string{"bcp-done-old"},
+			expectedPurged: []string{},
 		},
 		{
 			name: "Failed Backups - PurgeFailed is TRUE",

sdk/impl.go

@@ -91,7 +91,7 @@ func (c *Client) GetConfigProfile(ctx context.Context, name string) (*config.Con
 }
 
 func (c *Client) AddConfigProfile(ctx context.Context, name string, cfg *Config) (CommandID, error) {
-	opid, err := ctrl.SendAddConfigProfile(ctx, c.conn, name, cfg.Storage)
+	opid, err := ctrl.SendAddConfigProfile(ctx, c.conn, name, cfg.Storage, &cfg.Lifecycle)
 	return CommandID(opid.String()), err
 }