wip

Signed-off-by: Renan Rangel <rrangel@slack-corp.com>

go/test/endtoend/backup/vtctlbackup/backup_test.go

@@ -17,12 +17,16 @@ limitations under the License.
 package vtctlbackup
 
 import (
+	"encoding/json"
+	"io"
+	"os"
+	"path"
+	"strings"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/require"
+
 	"vitess.io/vitess/go/test/endtoend/cluster"
-	"vitess.io/vitess/go/vt/log"
 	"vitess.io/vitess/go/vt/mysqlctl"
 )
 
@@ -79,7 +83,8 @@ func TestBackupEngineSelector(t *testing.T) {
 	defer setDefaultCompressionFlag()
 	defer cluster.PanicHandler(t)
 
-	code, err := LaunchCluster(BuiltinBackup, "xbstream", 0, &CompressionDetails{CompressorEngineName: "pgzip"})
+	// launch the custer with xtrabackup as the default engine
+	code, err := LaunchCluster(XtraBackup, "xbstream", 0, &CompressionDetails{CompressorEngineName: "pgzip"})
 	require.Nilf(t, err, "setup failed with status code %d", code)
 
 	defer TearDownCluster()
@@ -90,10 +95,46 @@ func TestBackupEngineSelector(t *testing.T) {
 	}()
 	verifyInitialReplication(t)
 
+	// first try to backup with an alternative engine (builtin)
+	err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", "--allow-primary", "--backup-engine=builtin", primary.Alias)
+	require.NoError(t, err)
+	engineUsed := getBackupEngineOfLastBackup(t)
+	require.Equal(t, "builtin", engineUsed)
+
+	// then try to backup specifying the xtrabackup engine
 	err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", "--allow-primary", "--backup-engine=xtrabackup", primary.Alias)
 	require.NoError(t, err)
+	engineUsed = getBackupEngineOfLastBackup(t)
+	require.Equal(t, "xtrabackup", engineUsed)
+
+	// check that by default we still use the xtrabackup engine if not specified
+	err = localCluster.VtctldClientProcess.ExecuteCommand("Backup", "--allow-primary", primary.Alias)
+	require.NoError(t, err)
+	engineUsed = getBackupEngineOfLastBackup(t)
+	require.Equal(t, "xtrabackup", engineUsed)
+}
+
+// fetch the backup engine used on the last backup triggered by the end-to-end tests.
+func getBackupEngineOfLastBackup(t *testing.T) string {
+	output, err := localCluster.VtctldClientProcess.ExecuteCommandWithOutput("GetBackups", shardKsName)
 
-	log.Errorf("backup done: %v", localCluster.CurrentVTDATAROOT)
+	// split the backups response into a slice of strings
+	backups := strings.Split(strings.TrimSpace(output), "\n")
+
+	// open the Manifest and retrieve the backup engine that was used
+	f, err := os.Open(path.Join(localCluster.CurrentVTDATAROOT,
+		"backups", keyspaceName, shardName,
+		backups[len(backups)-1], "MANIFEST",
+	))
+	require.NoError(t, err)
+	defer f.Close()
+
+	data, err := io.ReadAll(f)
+	require.NoError(t, err)
+
+	var manifest mysqlctl.BackupManifest
+	err = json.Unmarshal(data, &manifest)
+	require.NoError(t, err)
 
-	time.Sleep(time.Second * 60)
+	return manifest.BackupMethod
 }

go/vt/mysqlctl/backup.go

@@ -169,6 +169,8 @@ func Backup(ctx context.Context, params BackupParams) error {
 		}
 	}
 
+	params.Logger.Infof("Using backup engine %q", be.Name())
+
 	// Take the backup, and either AbortBackup or EndBackup.
 	backupResult, err := be.ExecuteBackup(ctx, beParams, bh)
 	logger := params.Logger

go/vt/mysqlctl/backup_test.go

@@ -498,7 +498,7 @@ func TestRestoreManifestMySQLVersionValidation(t *testing.T) {
 
 			manifest := BackupManifest{
 				BackupTime:   time.Now().Add(-1 * time.Hour).Format(time.RFC3339),
-				BackupMethod: "fake",
+				BackupMethod: fakeBackupEngineName,
 				Keyspace:     "test",
 				Shard:        "-",
 				MySQLVersion: tc.fromVersion,
@@ -599,7 +599,7 @@ func createFakeBackupRestoreEnv(t *testing.T) *fakeBackupRestoreEnv {
 
 	manifest := BackupManifest{
 		BackupTime:   FormatRFC3339(time.Now().Add(-1 * time.Hour)),
-		BackupMethod: "fake",
+		BackupMethod: fakeBackupEngineName,
 		Keyspace:     "test",
 		Shard:        "-",
 		MySQLVersion: "8.0.32",
@@ -612,8 +612,8 @@ func createFakeBackupRestoreEnv(t *testing.T) *fakeBackupRestoreEnv {
 	testBackupEngine.ExecuteRestoreReturn = FakeBackupEngineExecuteRestoreReturn{&manifest, nil}
 
 	previousBackupEngineImplementation := backupEngineImplementation
-	BackupRestoreEngineMap["fake"] = &testBackupEngine
-	backupEngineImplementation = "fake"
+	BackupRestoreEngineMap[fakeBackupEngineName] = &testBackupEngine
+	backupEngineImplementation = fakeBackupEngineName
 
 	testBackupStorage := FakeBackupStorage{}
 	testBackupStorage.ListBackupsReturn = FakeBackupStorageListBackupsReturn{
@@ -628,9 +628,9 @@ func createFakeBackupRestoreEnv(t *testing.T) *fakeBackupRestoreEnv {
 	testBackupStorage.StartBackupReturn = FakeBackupStorageStartBackupReturn{&FakeBackupHandle{}, nil}
 	testBackupStorage.WithParamsReturn = &testBackupStorage
 
-	backupstorage.BackupStorageMap["fake"] = &testBackupStorage
+	backupstorage.BackupStorageMap[fakeBackupEngineName] = &testBackupStorage
 	previousBackupStorageImplementation := backupstorage.BackupStorageImplementation
-	backupstorage.BackupStorageImplementation = "fake"
+	backupstorage.BackupStorageImplementation = fakeBackupEngineName
 
 	// all restore integration tests must be leak checked
 	t.Cleanup(func() {
@@ -641,10 +641,10 @@ func createFakeBackupRestoreEnv(t *testing.T) *fakeBackupRestoreEnv {
 		backupstats.DeprecatedBackupDurationS.Reset()
 		backupstats.DeprecatedRestoreDurationS.Reset()
 
-		delete(BackupRestoreEngineMap, "fake")
+		delete(BackupRestoreEngineMap, fakeBackupEngineName)
 		backupEngineImplementation = previousBackupEngineImplementation
 
-		delete(backupstorage.BackupStorageMap, "fake")
+		delete(backupstorage.BackupStorageMap, fakeBackupEngineName)
 		backupstorage.BackupStorageImplementation = previousBackupStorageImplementation
 		mysqld.Close()
 		sqldb.Close()

go/vt/mysqlctl/backupengine.go

@@ -58,6 +58,7 @@ const (
 type BackupEngine interface {
 	ExecuteBackup(ctx context.Context, params BackupParams, bh backupstorage.BackupHandle) (BackupResult, error)
 	ShouldDrainForBackup(req *tabletmanagerdatapb.BackupRequest) bool
+	Name() string
 }
 
 // BackupParams is the struct that holds all params passed to ExecuteBackup

go/vt/mysqlctl/builtinbackupengine.go

@@ -1184,6 +1184,8 @@ func (be *BuiltinBackupEngine) ShouldDrainForBackup(req *tabletmanagerdatapb.Bac
 	return true
 }
 
+func (be *BuiltinBackupEngine) Name() string { return builtinBackupEngineName }
+
 func getPrimaryPosition(ctx context.Context, tmc tmclient.TabletManagerClient, ts *topo.Server, keyspace, shard string) (replication.Position, error) {
 	si, err := ts.GetShard(ctx, keyspace, shard)
 	if err != nil {

go/vt/mysqlctl/fakebackupengine.go

@@ -24,6 +24,8 @@ import (
 	tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata"
 )
 
+const fakeBackupEngineName = "fake"
+
 type FakeBackupEngine struct {
 	ExecuteBackupCalls         []FakeBackupEngineExecuteBackupCall
 	ExecuteBackupDuration      time.Duration
@@ -91,3 +93,5 @@ func (be *FakeBackupEngine) ShouldDrainForBackup(req *tabletmanagerdatapb.Backup
 	be.ShouldDrainForBackupCalls = be.ShouldDrainForBackupCalls + 1
 	return be.ShouldDrainForBackupReturn
 }
+
+func (be *FakeBackupEngine) Name() string { return fakeBackupEngineName }

go/vt/mysqlctl/xtrabackupengine.go

@@ -956,6 +956,8 @@ func (be *XtrabackupEngine) ShouldDrainForBackup(req *tabletmanagerdatapb.Backup
 	return false
 }
 
+func (be *XtrabackupEngine) Name() string { return xtrabackupEngineName }
+
 func init() {
 	BackupRestoreEngineMap[xtrabackupEngineName] = &XtrabackupEngine{}
 }

go/vt/vttablet/tabletmanager/rpc_backup.go

@@ -163,6 +163,7 @@ func (tm *TabletManager) Backup(ctx context.Context, logger logutil.Logger, req
 		Stats:                backupstats.BackupStats(),
 		UpgradeSafe:          req.UpgradeSafe,
 		MysqlShutdownTimeout: mysqlShutdownTimeout,
+		BackupEngine:         req.BackupEngine,
 	}
 
 	returnErr := mysqlctl.Backup(ctx, backupParams)