Choose most appropriate backup for recovery target

Author: l00ptr

internal/restore/restore.go

@@ -6,12 +6,16 @@ package restore
 import (
 	"context"
 	"fmt"
+	"sort"
+	"time"
 
 	cnpgv1 "github.com/cloudnative-pg/cloudnative-pg/api/v1"
 	"github.com/cloudnative-pg/cloudnative-pg/pkg/postgres"
 	restore "github.com/cloudnative-pg/cnpg-i/pkg/restore/job"
+	"github.com/cloudnative-pg/machinery/pkg/types"
 	"github.com/dalibo/cnpg-i-pgbackrest/internal/operator"
 	"github.com/dalibo/cnpg-i-pgbackrest/internal/pgbackrest"
+	pgbackrestapi "github.com/dalibo/cnpg-i-pgbackrest/internal/pgbackrest/api"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
@@ -111,6 +115,20 @@ func (impl JobHookImpl) Restore(
 	}
 	env = append(env, recovEnv...)
 	pgb := pgbackrest.NewPgBackrest(env)
+	backupInfo, err := pgb.GetBackupInfo()
+	if err != nil {
+		return nil, err
+	}
+	choosenBackup, err := selectBestBackup(backupInfo, recovOption)
+	if err != nil {
+		return nil, err
+	}
+	env = append(
+		env,
+		fmt.Sprintf("PGBACKREST_REPO=%d", choosenBackup.Database.RepoKey),
+		fmt.Sprintf("PGBACKREST_SET=%s", choosenBackup.Label),
+	)
+	pgb = pgbackrest.NewPgBackrest(env)
 	errCh := pgb.Restore(ctx)
 	if err := <-errCh; err != nil {
 		return nil, err
@@ -128,3 +146,65 @@ func (impl JobHookImpl) Restore(
 		Envs:          nil,
 	}, nil
 }
+
+func selectBestBackup(
+	backups []pgbackrestapi.BackupInfo,
+	opts pgbackrest.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 {
+	// then try to find the most appropriate backup for the type of target
+	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 := types.LSN(opts.Target)
+
+		for _, b := range backups {
+			stopLSN := types.LSN(b.Lsn.Stop)
+			if stopLSN.Less(targetLSN) || 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
+	// by default, fallback to the latest backup, may be we should return nothing and
+	// let pgbackrest do the job by itself
+	default:
+		return pgbackrest.LatestBackup(backups), nil
+	}
+}

internal/restore/restore_test.go

@@ -5,9 +5,11 @@ package restore
 
 import (
 	"testing"
+	"time"
 
 	cnpgv1 "github.com/cloudnative-pg/cloudnative-pg/api/v1"
 	"github.com/dalibo/cnpg-i-pgbackrest/internal/pgbackrest"
+	pgbackrestapi "github.com/dalibo/cnpg-i-pgbackrest/internal/pgbackrest/api"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -105,3 +107,87 @@ func TestRecoveryTargetToRestoreOption(t *testing.T) {
 		})
 	}
 }
+
+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      pgbackrest.RestoreOptions
+		wantLabel string
+		expectErr bool
+	}{
+		{
+			name: "select by name",
+			opts: pgbackrest.RestoreOptions{
+				Type:   "name",
+				Target: "b2",
+			},
+			wantLabel: "b2",
+		},
+		{
+			name: "select by time before b3",
+			opts: pgbackrest.RestoreOptions{
+				Type:   "time",
+				Target: time.Unix(2500, 0).Format(time.RFC3339),
+			},
+			wantLabel: "b2",
+		},
+		{
+			name: "select by time exactly b3",
+			opts: pgbackrest.RestoreOptions{
+				Type:   "time",
+				Target: time.Unix(3000, 0).Format(time.RFC3339),
+			},
+			wantLabel: "b3",
+		},
+		{
+			name: "select by LSN <= 0/2500",
+			opts: pgbackrest.RestoreOptions{
+				Type:   "lsn",
+				Target: "0/2500",
+			},
+			wantLabel: "b2",
+		},
+		{
+			name:      "select latest backup by default",
+			opts:      pgbackrest.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)
+
+			}
+		})
+	}
+}