Merge branch '365-walg-sort' into 'master'

fix: get the name of the latest WAL-G backup (#365)

Closes #365

See merge request postgres-ai/database-lab!540

Author: agneum

engine/go.mod

@@ -66,6 +66,7 @@ require (
 	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
 	github.com/stretchr/objx v0.2.0 // indirect
+	golang.org/x/mod v0.5.1 // indirect
 	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f // indirect
 	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
 	golang.org/x/text v0.3.7 // indirect

engine/go.sum

@@ -779,6 +779,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
+golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=

engine/internal/retrieval/engine/postgres/physical/custom.go

@@ -5,6 +5,8 @@
 package physical
 
 import (
+	"context"
+
 	"gitlab.com/postgres-ai/database-lab/v3/internal/retrieval/engine/postgres/tools/defaults"
 )
 
@@ -46,3 +48,8 @@ func (c *custom) GetRecoveryConfig(pgVersion float64) map[string]string {
 
 	return recoveryCfg
 }
+
+// Init initialize custom recovery tool to work in provided container.
+func (c *custom) Init(ctx context.Context, containerID string) error {
+	return nil
+}

engine/internal/retrieval/engine/postgres/physical/pgbackrest.go

@@ -5,6 +5,7 @@
 package physical
 
 import (
+	"context"
 	"fmt"
 
 	"gitlab.com/postgres-ai/database-lab/v3/internal/retrieval/engine/postgres/tools/defaults"
@@ -54,3 +55,8 @@ func (p *pgbackrest) GetRecoveryConfig(pgVersion float64) map[string]string {
 
 	return recoveryCfg
 }
+
+// Init initialize pgbackrest tool.
+func (p *pgbackrest) Init(ctx context.Context, containerID string) error {
+	return nil
+}

engine/internal/retrieval/engine/postgres/physical/physical.go

@@ -93,6 +93,10 @@ type HealthCheck struct {
 
 // restorer describes the interface of tools for physical restore.
 type restorer interface {
+
+	// Init initialize restore tooling inside of container.
+	Init(ctx context.Context, containerID string) error
+
 	// GetRestoreCommand returns a command to restore data.
 	GetRestoreCommand() string
 
@@ -115,7 +119,7 @@ func NewJob(cfg config.JobConfig, global *global.Config, engineProps global.Engi
 		return nil, errors.Wrap(err, "failed to unmarshal configuration options")
 	}
 
-	restorer, err := physicalJob.getRestorer(physicalJob.Tool)
+	restorer, err := physicalJob.getRestorer(cfg.Docker, physicalJob.Tool)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to init restorer")
 	}
@@ -126,10 +130,10 @@ func NewJob(cfg config.JobConfig, global *global.Config, engineProps global.Engi
 }
 
 // getRestorer builds a tool to perform physical restoring.
-func (r *RestoreJob) getRestorer(tool string) (restorer, error) {
+func (r *RestoreJob) getRestorer(client *client.Client, tool string) (restorer, error) {
 	switch tool {
 	case walgTool:
-		return newWALG(r.fsPool.DataDir(), r.WALG), nil
+		return newWALG(client, r.fsPool.DataDir(), r.WALG), nil
 
 	case pgbackrestTool:
 		return newPgBackRest(r.PgBackRest), nil
@@ -215,6 +219,10 @@ func (r *RestoreJob) Run(ctx context.Context) (err error) {
 		return errors.Wrapf(err, "failed to start container: %v", contID)
 	}
 
+	if err := r.restorer.Init(ctx, contID); err != nil {
+		return fmt.Errorf("failed to initialize restorer: %w", err)
+	}
+
 	log.Msg("Running restore command: ", r.restorer.GetRestoreCommand())
 	log.Msg(fmt.Sprintf("View logs using the command: %s %s", tools.ViewLogsCmd, r.restoreContainerName()))
 

engine/internal/retrieval/engine/postgres/physical/wal_g.go

@@ -5,35 +5,52 @@
 package physical
 
 import (
+	"context"
 	"fmt"
+	"strings"
 
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"golang.org/x/mod/semver"
+
+	"gitlab.com/postgres-ai/database-lab/v3/internal/retrieval/engine/postgres/tools"
 	"gitlab.com/postgres-ai/database-lab/v3/internal/retrieval/engine/postgres/tools/defaults"
+	"gitlab.com/postgres-ai/database-lab/v3/pkg/log"
 )
 
 const (
-	walgTool = "walg"
+	walgTool       = "walg"
+	walgSplitCount = 3
+	walg11Version  = "v1.1"
+	latestBackup   = "LATEST"
 )
 
 // walg defines a WAL-G as an archival restoration tool.
 type walg struct {
-	pgDataDir string
-	options   walgOptions
+	dockerClient     *client.Client
+	pgDataDir        string
+	parsedBackupName string
+	options          walgOptions
 }
 
 type walgOptions struct {
 	BackupName string `yaml:"backupName"`
 }
 
-func newWALG(pgDataDir string, options walgOptions) *walg {
-	return &walg{
-		pgDataDir: pgDataDir,
-		options:   options,
+func newWALG(dockerClient *client.Client, pgDataDir string, options walgOptions) *walg {
+	walg := &walg{
+		dockerClient:     dockerClient,
+		pgDataDir:        pgDataDir,
+		options:          options,
+		parsedBackupName: options.BackupName,
 	}
+
+	return walg
 }
 
 // GetRestoreCommand returns a command to restore data.
 func (w *walg) GetRestoreCommand() string {
-	return fmt.Sprintf("wal-g backup-fetch %s %s", w.pgDataDir, w.options.BackupName)
+	return fmt.Sprintf("wal-g backup-fetch %s %s", w.pgDataDir, w.parsedBackupName)
 }
 
 // GetRecoveryConfig returns a recovery config to restore data.
@@ -48,3 +65,104 @@ func (w *walg) GetRecoveryConfig(pgVersion float64) map[string]string {
 
 	return recoveryCfg
 }
+
+// Init initializes the wal-g tool to run in the provided container.
+func (w *walg) Init(ctx context.Context, containerID string) error {
+	if strings.ToUpper(w.options.BackupName) != latestBackup {
+		return nil
+	}
+	// workaround for issue with identification of last backup
+	// https://gitlab.com/postgres-ai/database-lab/-/issues/365
+	name, err := getLastBackupName(ctx, w.dockerClient, containerID)
+
+	if err != nil {
+		return err
+	}
+
+	if name != "" {
+		w.parsedBackupName = name
+		return nil
+	}
+
+	return fmt.Errorf("failed to fetch last backup name from wal-g")
+}
+
+// getLastBackupName returns the name of the latest backup from the wal-g backup list.
+func getLastBackupName(ctx context.Context, dockerClient *client.Client, containerID string) (string, error) {
+	walgVersion, err := getWalgVersion(ctx, dockerClient, containerID)
+
+	if err != nil {
+		return "", err
+	}
+
+	result := semver.Compare(walgVersion, walg11Version)
+
+	// Try to fetch the latest backup with the details command for WAL-G 1.1 and higher
+	if result >= 0 {
+		output, err := parseLastBackupFromDetails(ctx, dockerClient, containerID)
+
+		if err == nil {
+			return output, err
+		}
+
+		// fallback to fetching last backup from list
+		log.Err("Failed to parse last backup from wal-g details", err)
+	}
+
+	return parseLastBackupFromList(ctx, dockerClient, containerID)
+}
+
+// parseLastBackupFromList parses the name of the latest backup from "wal-g backup-list" output.
+func parseLastBackupFromList(ctx context.Context, dockerClient *client.Client, containerID string) (string, error) {
+	output, err := tools.ExecCommandWithOutput(ctx, dockerClient, containerID, types.ExecConfig{
+		Cmd: []string{"bash", "-c", "wal-g backup-list | grep base | sort -nk1 | tail -1 | awk '{print $1}'"},
+	})
+	if err != nil {
+		return "", err
+	}
+
+	log.Dbg("The latest WAL-G backup from the list", output)
+
+	return output, nil
+}
+
+// parseLastBackupFromDetails parses the name of the latest backup from "wal-g backup-list --detail" output.
+func parseLastBackupFromDetails(ctx context.Context, dockerClient *client.Client, containerID string) (string, error) {
+	output, err := tools.ExecCommandWithOutput(ctx, dockerClient, containerID, types.ExecConfig{
+		Cmd: []string{"bash", "-c", "wal-g backup-list --detail | tail -1 | awk '{print $1}'"},
+	})
+	if err != nil {
+		return "", err
+	}
+
+	log.Dbg("The latest WAL-G backup from list details", output)
+
+	return output, nil
+}
+
+// getWalgVersion fetches the WAL-G version installed in the provided container.
+func getWalgVersion(ctx context.Context, dockerClient *client.Client, containerID string) (string, error) {
+	output, err := tools.ExecCommandWithOutput(ctx, dockerClient, containerID, types.ExecConfig{
+		Cmd: []string{"bash", "-c", "wal-g --version"},
+	})
+	if err != nil {
+		return "", err
+	}
+
+	log.Dbg(output)
+
+	return parseWalGVersion(output)
+}
+
+// parseWalGVersion extracts the version from the 'wal-g --version' output.
+// For example, "wal-g version v2.0.0	1eb88a5	2022.05.20_10:45:57	PostgreSQL".
+func parseWalGVersion(output string) (string, error) {
+	walgVersion := strings.Split(output, "\t")
+	versionParts := strings.Split(walgVersion[0], " ")
+
+	if len(versionParts) < walgSplitCount {
+		return "", fmt.Errorf("failed to extract wal-g version number")
+	}
+
+	return versionParts[walgSplitCount-1], nil
+}

engine/internal/retrieval/engine/postgres/physical/wal_g_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestWALGRecoveryConfig(t *testing.T) {
-	walg := newWALG("dataDir", walgOptions{})
+	walg := newWALG(nil, "dataDir", walgOptions{})
 
 	recoveryConfig := walg.GetRecoveryConfig(11.7)
 	expectedResponse11 := map[string]string{
@@ -22,3 +22,10 @@ func TestWALGRecoveryConfig(t *testing.T) {
 	}
 	assert.Equal(t, expectedResponse12, recoveryConfig)
 }
+
+func TestWALGVersionParse(t *testing.T) {
+	version, err := parseWalGVersion("wal-g version v2.0.0\t1eb88a5\t2022.05.20_10:45:57\tPostgreSQL")
+	assert.NoError(t, err)
+	assert.NotEmpty(t, version)
+	assert.Equal(t, "v2.0.0", version)
+}