Rename BackupRepository/RestoreRepository to Create/Restore

This makes the terminology consistent throughout the stack.

4 files changed, 18 insertions, 18 deletions

diff --git a/cmd/gitaly-backup/create.go b/cmd/gitaly-backup/create.go
index 49aac2be8..950eec2cb 100644
--- a/cmd/gitaly-backup/create.go
+++ b/cmd/gitaly-backup/create.go
@@ -52,7 +52,7 @@ func (cmd *createSubcommand) Run(ctx context.Context, stdin io.Reader, stdout io
 			GlProjectPath: sr.GlProjectPath,
 		}
 		repoLog.Info("started backup")
-		if err := fsBackup.BackupRepository(ctx, sr.ServerInfo, &repo); err != nil {
+		if err := fsBackup.Create(ctx, sr.ServerInfo, &repo); err != nil {
 			if errors.Is(err, backup.ErrSkipped) {
 				repoLog.Warn("skipped backup")
 			} else {
diff --git a/cmd/gitaly-backup/restore.go b/cmd/gitaly-backup/restore.go
index 619192a8a..1b9ee001f 100644
--- a/cmd/gitaly-backup/restore.go
+++ b/cmd/gitaly-backup/restore.go
@@ -54,7 +54,7 @@ func (cmd *restoreSubcommand) Run(ctx context.Context, stdin io.Reader, stdout i
 			GlProjectPath: req.GlProjectPath,
 		}
 		repoLog.Info("started restore")
-		if err := fsBackup.RestoreRepository(ctx, req.ServerInfo, &repo, req.AlwaysCreate); err != nil {
+		if err := fsBackup.Restore(ctx, req.ServerInfo, &repo, req.AlwaysCreate); err != nil {
 			if errors.Is(err, backup.ErrSkipped) {
 				repoLog.WithError(err).Warn("skipped restore")
 			} else {
diff --git a/internal/backup/backup.go b/internal/backup/backup.go
index 46445f9a2..bd665b62f 100644
--- a/internal/backup/backup.go
+++ b/internal/backup/backup.go
@@ -34,10 +34,10 @@ func NewFilesystem(path string) *Filesystem {
 	}
 }
 
-// BackupRepository creates a repository backup on a local filesystem
-func (fs *Filesystem) BackupRepository(ctx context.Context, server storage.ServerInfo, repo *gitalypb.Repository) error {
+// Create creates a repository backup on a local filesystem
+func (fs *Filesystem) Create(ctx context.Context, server storage.ServerInfo, repo *gitalypb.Repository) error {
 	if isEmpty, err := fs.isEmpty(ctx, server, repo); err != nil {
-		return fmt.Errorf("backup: %w", err)
+		return fmt.Errorf("filesystem: %w", err)
 	} else if isEmpty {
 		return ErrSkipped
 	}
@@ -47,26 +47,26 @@ func (fs *Filesystem) BackupRepository(ctx context.Context, server storage.Serve
 	customHooksPath := filepath.Join(backupPath, "custom_hooks.tar")
 
 	if err := os.MkdirAll(backupPath, 0700); err != nil {
-		return fmt.Errorf("backup: %w", err)
+		return fmt.Errorf("filesystem: %w", err)
 	}
 	if err := fs.writeBundle(ctx, bundlePath, server, repo); err != nil {
-		return fmt.Errorf("backup: write bundle: %w", err)
+		return fmt.Errorf("filesystem: write bundle: %w", err)
 	}
 	if err := fs.writeCustomHooks(ctx, customHooksPath, server, repo); err != nil {
-		return fmt.Errorf("backup: write custom hooks: %w", err)
+		return fmt.Errorf("filesystem: write custom hooks: %w", err)
 	}
 
 	return nil
 }
 
-// RestoreRepository restores a repository from a backup on a local filesystem
-func (fs *Filesystem) RestoreRepository(ctx context.Context, server storage.ServerInfo, repo *gitalypb.Repository, alwaysCreate bool) error {
+// Restore restores a repository from a backup on a local filesystem
+func (fs *Filesystem) Restore(ctx context.Context, server storage.ServerInfo, repo *gitalypb.Repository, alwaysCreate bool) error {
 	backupPath := strings.TrimSuffix(filepath.Join(fs.path, repo.RelativePath), ".git")
 	bundlePath := backupPath + ".bundle"
 	customHooksPath := filepath.Join(backupPath, "custom_hooks.tar")
 
 	if err := fs.removeRepository(ctx, server, repo); err != nil {
-		return fmt.Errorf("restore: %w", err)
+		return fmt.Errorf("filesystem: %w", err)
 	}
 	if err := fs.restoreBundle(ctx, bundlePath, server, repo); err != nil {
 		// For compatibility with existing backups we need to always create the
@@ -76,14 +76,14 @@ func (fs *Filesystem) RestoreRepository(ctx context.Context, server storage.Serv
 		// to employ this behaviour.
 		if alwaysCreate && errors.Is(err, ErrSkipped) {
 			if err := fs.createRepository(ctx, server, repo); err != nil {
-				return fmt.Errorf("restore: %w", err)
+				return fmt.Errorf("filesystem: %w", err)
 			}
 		} else {
-			return fmt.Errorf("restore: %w", err)
+			return fmt.Errorf("filesystem: %w", err)
 		}
 	}
 	if err := fs.restoreCustomHooks(ctx, customHooksPath, server, repo); err != nil {
-		return fmt.Errorf("restore: %w", err)
+		return fmt.Errorf("filesystem: %w", err)
 	}
 	return nil
 }
diff --git a/internal/backup/backup_test.go b/internal/backup/backup_test.go
index adeae46bb..1637d2b55 100644
--- a/internal/backup/backup_test.go
+++ b/internal/backup/backup_test.go
@@ -17,7 +17,7 @@ import (
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
 )
 
-func TestFilesystem_BackupRepository(t *testing.T) {
+func TestFilesystem_Create(t *testing.T) {
 	cfg := testcfg.Build(t)
 
 	gitalyAddr := testserver.RunGitalyServer(t, cfg, nil, setup.RegisterAll)
@@ -76,7 +76,7 @@ func TestFilesystem_BackupRepository(t *testing.T) {
 			defer cancel()
 
 			fsBackup := NewFilesystem(path)
-			err := fsBackup.BackupRepository(ctx, storage.ServerInfo{Address: gitalyAddr, Token: cfg.Auth.Token}, tc.repo)
+			err := fsBackup.Create(ctx, storage.ServerInfo{Address: gitalyAddr, Token: cfg.Auth.Token}, tc.repo)
 			if tc.err == nil {
 				require.NoError(t, err)
 			} else {
@@ -109,7 +109,7 @@ func TestFilesystem_BackupRepository(t *testing.T) {
 	}
 }
 
-func TestFilesystem_RestoreRepository(t *testing.T) {
+func TestFilesystem_Restore(t *testing.T) {
 	cfg := testcfg.Build(t)
 	testhelper.ConfigureGitalyHooksBin(t, cfg)
 
@@ -175,7 +175,7 @@ func TestFilesystem_RestoreRepository(t *testing.T) {
 			defer cancel()
 
 			fsBackup := NewFilesystem(path)
-			err := fsBackup.RestoreRepository(ctx, storage.ServerInfo{Address: gitalyAddr, Token: cfg.Auth.Token}, tc.repo, tc.alwaysCreate)
+			err := fsBackup.Restore(ctx, storage.ServerInfo{Address: gitalyAddr, Token: cfg.Auth.Token}, tc.repo, tc.alwaysCreate)
 			if tc.expectedErrAs != nil {
 				require.True(t, errors.Is(err, tc.expectedErrAs), err.Error())
 			} else {