Choose most appropriate backup for recovery target

Author: l00ptr

internal/pgbackrest/pgbackrest.go

@@ -13,7 +13,9 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"sort"
 	"sync"
+	"time"
 
 	pgbackrestapi "github.com/dalibo/cnpg-i-pgbackrest/internal/pgbackrest/api"
 	"github.com/dalibo/cnpg-i-pgbackrest/internal/utils"
@@ -272,3 +274,69 @@ func (p *PgBackrest) Restore(ctx context.Context) <-chan error {
 	env = append(env, "PGBACKREST_ARCHIVE_CHECK=n")
 	return p.runBackgroundTask(ctx, []string{"restore"}, env)
 }
+
+func SelectBestBackup(
+	backups []pgbackrestapi.BackupInfo,
+	opts RestoreOptions,
+) (*pgbackrestapi.BackupInfo, error) {
+	if len(backups) == 0 {
+		return nil, fmt.Errorf("no backups available")
+	}
+
+	// First sort backups from newest  to oldest, that way we will
+	// always match the newest backup
+	sort.Slice(backups, func(i, j int) bool {
+		return backups[i].Timestamp.Stop > backups[j].Timestamp.Stop
+	})
+
+	switch opts.Type {
+	case "name":
+		for _, b := range backups {
+			if b.Label == opts.Target {
+				return &b, nil
+			}
+		}
+		return nil, fmt.Errorf("backup with label %q not found", opts.Target)
+
+	case "time":
+		targetTime, err := time.Parse(time.RFC3339, opts.Target)
+		if err != nil {
+			return nil, fmt.Errorf("invalid target time %q: %w", opts.Target, err)
+		}
+		targetTS := targetTime.Unix()
+
+		for _, b := range backups {
+			if b.Timestamp.Stop <= targetTS {
+				return &b, nil
+			}
+		}
+		return nil, fmt.Errorf("no backup found before target time %s", opts.Target)
+
+	case "lsn":
+		targetLSN, err := utils.ParseLSN(opts.Target)
+		if err != nil {
+			return nil, fmt.Errorf("invalid target LSN %q: %w", opts.Target, err)
+		}
+
+		for _, b := range backups {
+			stopLSN, err := utils.ParseLSN(b.Lsn.Stop)
+			if err != nil {
+				continue
+			}
+			if stopLSN <= targetLSN {
+				return &b, nil
+			}
+		}
+		return nil, fmt.Errorf(
+			"no backup found before target LSN %s",
+			opts.Target,
+		)
+
+	// decide what to do here
+	//case "xid":
+	//		return nil, nil
+
+	default:
+		return LatestBackup(backups), nil
+	}
+}

internal/pgbackrest/pgbackrest_test.go

@@ -420,3 +420,87 @@ func TestRestoreOptionToEnv(t *testing.T) {
 		t.Run(tc.desc, f)
 	}
 }
+
+func TestSelectBestBackupForRestore(t *testing.T) {
+	backups := []pgbackrestapi.BackupInfo{
+		{
+			Label: "b1",
+			Lsn:   pgbackrestapi.Lsn{Stop: "0/1000"},
+			Timestamp: pgbackrestapi.Timestamp{
+				Stop: 1000,
+			},
+		},
+		{
+			Label: "b2",
+			Lsn:   pgbackrestapi.Lsn{Stop: "0/2000"},
+			Timestamp: pgbackrestapi.Timestamp{
+				Stop: 2000,
+			},
+		},
+		{
+			Label: "b3",
+			Lsn:   pgbackrestapi.Lsn{Stop: "0/3000"},
+			Timestamp: pgbackrestapi.Timestamp{
+				Stop: 3000,
+			},
+		},
+	}
+
+	tests := []struct {
+		name      string
+		opts      RestoreOptions
+		wantLabel string
+		expectErr bool
+	}{
+		{
+			name: "select by name",
+			opts: RestoreOptions{
+				Type:   "name",
+				Target: "b2",
+			},
+			wantLabel: "b2",
+		},
+		{
+			name: "select by time before b3",
+			opts: RestoreOptions{
+				Type:   "time",
+				Target: time.Unix(2500, 0).Format(time.RFC3339),
+			},
+			wantLabel: "b2",
+		},
+		{
+			name: "select by time exactly b3",
+			opts: RestoreOptions{
+				Type:   "time",
+				Target: time.Unix(3000, 0).Format(time.RFC3339),
+			},
+			wantLabel: "b3",
+		},
+		{
+			name: "select by LSN <= 0/2500",
+			opts: RestoreOptions{
+				Type:   "lsn",
+				Target: "0/2500",
+			},
+			wantLabel: "b2",
+		},
+		{
+			name:      "select latest backup by default",
+			opts:      RestoreOptions{},
+			wantLabel: "b3",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := SelectBestBackup(backups, tt.opts)
+			if err != nil {
+				t.Error(err)
+			}
+			if got.Label != tt.wantLabel {
+				t.Errorf("error, got: %v, want: %v", got.Label, tt.wantLabel)
+
+			}
+		})
+	}
+}

internal/restore/restore.go

@@ -114,6 +114,13 @@ func (impl JobHookImpl) Restore(
 	}
 	env = append(env, recovEnv...)
 	pgb := pgbackrest.NewPgBackrest(env)
+	backupInfo, err := pgb.GetBackupInfo()
+	choosenBackup, err := pgbackrest.SelectBestBackup(backupInfo, recovOption)
+	if err != nil {
+		return nil, err
+	}
+	env = append(env, fmt.Sprintf("PGBACKREST_REPO=%d", choosenBackup.Database.RepoKey))
+	env = append(env, fmt.Sprintf("PGBACKREST_SET=%s", choosenBackup.Label))
 	errCh := pgb.Restore(ctx)
 	if err := <-errCh; err != nil {
 		return nil, err