Add latest changes from gitlab-org/gitlab@14-9-stable-eev14.9.0-rc42

12 files changed, 733 insertions, 429 deletions

diff --git a/spec/lib/backup/artifacts_spec.rb b/spec/lib/backup/artifacts_spec.rb
index e65dc79b65b..d830692d96b 100644
--- a/spec/lib/backup/artifacts_spec.rb
+++ b/spec/lib/backup/artifacts_spec.rb
@@ -18,7 +18,7 @@ RSpec.describe Backup::Artifacts do
       expect(backup).to receive(:tar).and_return('blabla-tar')
       expect(backup).to receive(:run_pipeline!).with([%w(blabla-tar --exclude=lost+found --exclude=./tmp -C /var/gitlab-artifacts -cf - .), 'gzip -c -1'], any_args).and_return([[true, true], ''])
       expect(backup).to receive(:pipeline_succeeded?).and_return(true)
-      backup.dump
+      backup.dump('artifacts.tar.gz')
     end
   end
 end
diff --git a/spec/lib/backup/database_spec.rb b/spec/lib/backup/database_spec.rb
index 4345778ba92..53db7f0f149 100644
--- a/spec/lib/backup/database_spec.rb
+++ b/spec/lib/backup/database_spec.rb
@@ -6,25 +6,49 @@ RSpec.describe Backup::Database do
   let(:progress) { StringIO.new }
   let(:output) { progress.string }
 
-  before do
-    allow(Gitlab::TaskHelpers).to receive(:ask_to_continue)
+  before(:all) do
+    Rake.application.rake_require 'active_record/railties/databases'
+    Rake.application.rake_require 'tasks/gitlab/backup'
+    Rake.application.rake_require 'tasks/gitlab/shell'
+    Rake.application.rake_require 'tasks/gitlab/db'
+    Rake.application.rake_require 'tasks/cache'
   end
 
   describe '#restore' do
     let(:cmd) { %W[#{Gem.ruby} -e $stdout.puts(1)] }
     let(:data) { Rails.root.join("spec/fixtures/pages_empty.tar.gz").to_s }
+    let(:force) { true }
 
-    subject { described_class.new(progress, filename: data) }
+    subject { described_class.new(progress, force: force) }
 
     before do
       allow(subject).to receive(:pg_restore_cmd).and_return(cmd)
     end
 
+    context 'when not forced' do
+      let(:force) { false }
+
+      it 'warns the user and waits' do
+        expect(subject).to receive(:sleep)
+        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
+
+        subject.restore(data)
+
+        expect(output).to include('Removing all tables. Press `Ctrl-C` within 5 seconds to abort')
+      end
+
+      it 'has a pre restore warning' do
+        expect(subject.pre_restore_warning).not_to be_nil
+      end
+    end
+
     context 'with an empty .gz file' do
       let(:data) { Rails.root.join("spec/fixtures/pages_empty.tar.gz").to_s }
 
       it 'returns successfully' do
-        subject.restore
+        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
+
+        subject.restore(data)
 
         expect(output).to include("Restoring PostgreSQL database")
         expect(output).to include("[DONE]")
@@ -36,7 +60,9 @@ RSpec.describe Backup::Database do
       let(:data) { Rails.root.join("spec/fixtures/big-image.png").to_s }
 
       it 'raises a backup error' do
-        expect { subject.restore }.to raise_error(Backup::Error)
+        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
+
+        expect { subject.restore(data) }.to raise_error(Backup::Error)
       end
     end
 
@@ -45,12 +71,15 @@ RSpec.describe Backup::Database do
       let(:noise) { "Table projects does not exist\nmust be owner of extension pg_trgm\nWARNING:  no privileges could be revoked for public\n" }
       let(:cmd) { %W[#{Gem.ruby} -e $stderr.write("#{noise}#{visible_error}")] }
 
-      it 'filters out noise from errors' do
-        subject.restore
+      it 'filters out noise from errors and has a post restore warning' do
+        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
+
+        subject.restore(data)
 
         expect(output).to include("ERRORS")
         expect(output).not_to include(noise)
         expect(output).to include(visible_error)
+        expect(subject.post_restore_warning).not_to be_nil
       end
     end
 
@@ -66,7 +95,9 @@ RSpec.describe Backup::Database do
       end
 
       it 'overrides default config values' do
-        subject.restore
+        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
+
+        subject.restore(data)
 
         expect(output).to include(%("PGHOST"=>"test.example.com"))
         expect(output).to include(%("PGPASSWORD"=>"donotchange"))
diff --git a/spec/lib/backup/files_spec.rb b/spec/lib/backup/files_spec.rb
index 6bff0919293..bbc465a26c9 100644
--- a/spec/lib/backup/files_spec.rb
+++ b/spec/lib/backup/files_spec.rb
@@ -39,7 +39,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#restore' do
-    subject { described_class.new('registry', '/var/gitlab-registry') }
+    subject { described_class.new(progress, 'registry', '/var/gitlab-registry') }
 
     let(:timestamp) { Time.utc(2017, 3, 22) }
 
@@ -58,11 +58,11 @@ RSpec.describe Backup::Files do
       it 'moves all necessary files' do
         allow(subject).to receive(:backup_existing_files).and_call_original
         expect(FileUtils).to receive(:mv).with(["/var/gitlab-registry/sample1"], File.join(Gitlab.config.backup.path, "tmp", "registry.#{Time.now.to_i}"))
-        subject.restore
+        subject.restore('registry.tar.gz')
       end
 
       it 'raises no errors' do
-        expect { subject.restore }.not_to raise_error
+        expect { subject.restore('registry.tar.gz') }.not_to raise_error
       end
 
       it 'calls tar command with unlink' do
@@ -70,13 +70,13 @@ RSpec.describe Backup::Files do
 
         expect(subject).to receive(:run_pipeline!).with([%w(gzip -cd), %w(blabla-tar --unlink-first --recursive-unlink -C /var/gitlab-registry -xf -)], any_args)
         expect(subject).to receive(:pipeline_succeeded?).and_return(true)
-        subject.restore
+        subject.restore('registry.tar.gz')
       end
 
       it 'raises an error on failure' do
         expect(subject).to receive(:pipeline_succeeded?).and_return(false)
 
-        expect { subject.restore }.to raise_error(/Restore operation failed:/)
+        expect { subject.restore('registry.tar.gz') }.to raise_error(/Restore operation failed:/)
       end
     end
 
@@ -89,7 +89,7 @@ RSpec.describe Backup::Files do
 
       it 'shows error message' do
         expect(subject).to receive(:access_denied_error).with("/var/gitlab-registry")
-        subject.restore
+        subject.restore('registry.tar.gz')
       end
     end
 
@@ -104,13 +104,13 @@ RSpec.describe Backup::Files do
         expect(subject).to receive(:resource_busy_error).with("/var/gitlab-registry")
                              .and_call_original
 
-        expect { subject.restore }.to raise_error(/is a mountpoint/)
+        expect { subject.restore('registry.tar.gz') }.to raise_error(/is a mountpoint/)
       end
     end
   end
 
   describe '#dump' do
-    subject { described_class.new('pages', '/var/gitlab-pages', excludes: ['@pages.tmp']) }
+    subject { described_class.new(progress, 'pages', '/var/gitlab-pages', excludes: ['@pages.tmp']) }
 
     before do
       allow(subject).to receive(:run_pipeline!).and_return([[true, true], ''])
@@ -118,14 +118,14 @@ RSpec.describe Backup::Files do
     end
 
     it 'raises no errors' do
-      expect { subject.dump }.not_to raise_error
+      expect { subject.dump('registry.tar.gz') }.not_to raise_error
     end
 
     it 'excludes tmp dirs from archive' do
       expect(subject).to receive(:tar).and_return('blabla-tar')
 
       expect(subject).to receive(:run_pipeline!).with([%w(blabla-tar --exclude=lost+found --exclude=./@pages.tmp -C /var/gitlab-pages -cf - .), 'gzip -c -1'], any_args)
-      subject.dump
+      subject.dump('registry.tar.gz')
     end
 
     it 'raises an error on failure' do
@@ -133,7 +133,7 @@ RSpec.describe Backup::Files do
       expect(subject).to receive(:pipeline_succeeded?).and_return(false)
 
       expect do
-        subject.dump
+        subject.dump('registry.tar.gz')
       end.to raise_error(/Failed to create compressed file/)
     end
 
@@ -149,7 +149,7 @@ RSpec.describe Backup::Files do
           .with(%w(rsync -a --delete --exclude=lost+found --exclude=/gitlab-pages/@pages.tmp /var/gitlab-pages /var/gitlab-backup))
           .and_return(['', 0])
 
-        subject.dump
+        subject.dump('registry.tar.gz')
       end
 
       it 'retries if rsync fails due to vanishing files' do
@@ -158,7 +158,7 @@ RSpec.describe Backup::Files do
           .and_return(['rsync failed', 24], ['', 0])
 
         expect do
-          subject.dump
+          subject.dump('registry.tar.gz')
         end.to output(/files vanished during rsync, retrying/).to_stdout
       end
 
@@ -168,7 +168,7 @@ RSpec.describe Backup::Files do
           .and_return(['rsync failed', 1])
 
         expect do
-          subject.dump
+          subject.dump('registry.tar.gz')
         end.to output(/rsync failed/).to_stdout
            .and raise_error(/Failed to create compressed file/)
       end
@@ -176,7 +176,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#exclude_dirs' do
-    subject { described_class.new('pages', '/var/gitlab-pages', excludes: ['@pages.tmp']) }
+    subject { described_class.new(progress, 'pages', '/var/gitlab-pages', excludes: ['@pages.tmp']) }
 
     it 'prepends a leading dot slash to tar excludes' do
       expect(subject.exclude_dirs(:tar)).to eq(['--exclude=lost+found', '--exclude=./@pages.tmp'])
@@ -188,7 +188,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#run_pipeline!' do
-    subject { described_class.new('registry', '/var/gitlab-registry') }
+    subject { described_class.new(progress, 'registry', '/var/gitlab-registry') }
 
     it 'executes an Open3.pipeline for cmd_list' do
       expect(Open3).to receive(:pipeline).with(%w[whew command], %w[another cmd], any_args)
@@ -222,7 +222,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#pipeline_succeeded?' do
-    subject { described_class.new('registry', '/var/gitlab-registry') }
+    subject { described_class.new(progress, 'registry', '/var/gitlab-registry') }
 
     it 'returns true if both tar and gzip succeeeded' do
       expect(
@@ -262,7 +262,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#tar_ignore_non_success?' do
-    subject { described_class.new('registry', '/var/gitlab-registry') }
+    subject { described_class.new(progress, 'registry', '/var/gitlab-registry') }
 
     context 'if `tar` command exits with 1 exitstatus' do
       it 'returns true' do
@@ -310,7 +310,7 @@ RSpec.describe Backup::Files do
   end
 
   describe '#noncritical_warning?' do
-    subject { described_class.new('registry', '/var/gitlab-registry') }
+    subject { described_class.new(progress, 'registry', '/var/gitlab-registry') }
 
     it 'returns true if given text matches noncritical warnings list' do
       expect(
diff --git a/spec/lib/backup/gitaly_backup_spec.rb b/spec/lib/backup/gitaly_backup_spec.rb
index 6bf4f833c1f..f5295c2b04c 100644
--- a/spec/lib/backup/gitaly_backup_spec.rb
+++ b/spec/lib/backup/gitaly_backup_spec.rb
@@ -5,6 +5,8 @@ require 'spec_helper'
 RSpec.describe Backup::GitalyBackup do
   let(:max_parallelism) { nil }
   let(:storage_parallelism) { nil }
+  let(:destination) { File.join(Gitlab.config.backup.path, 'repositories') }
+  let(:backup_id) { '20220101' }
 
   let(:progress) do
     Tempfile.new('progress').tap do |progress|
@@ -23,11 +25,11 @@ RSpec.describe Backup::GitalyBackup do
     progress.close
   end
 
-  subject { described_class.new(progress, max_parallelism: max_parallelism, storage_parallelism: storage_parallelism) }
+  subject { described_class.new(progress, max_parallelism: max_parallelism, storage_parallelism: storage_parallelism, backup_id: backup_id) }
 
   context 'unknown' do
     it 'fails to start unknown' do
-      expect { subject.start(:unknown) }.to raise_error(::Backup::Error, 'unknown backup type: unknown')
+      expect { subject.start(:unknown, destination) }.to raise_error(::Backup::Error, 'unknown backup type: unknown')
     end
   end
 
@@ -40,9 +42,9 @@ RSpec.describe Backup::GitalyBackup do
         project_snippet = create(:project_snippet, :repository, project: project)
         personal_snippet = create(:personal_snippet, :repository, author: project.first_owner)
 
-        expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything).and_call_original
+        expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-layout', 'pointer', '-id', backup_id).and_call_original
 
-        subject.start(:create)
+        subject.start(:create, destination)
         subject.enqueue(project, Gitlab::GlRepository::PROJECT)
         subject.enqueue(project, Gitlab::GlRepository::WIKI)
         subject.enqueue(project, Gitlab::GlRepository::DESIGN)
@@ -50,20 +52,20 @@ RSpec.describe Backup::GitalyBackup do
         subject.enqueue(project_snippet, Gitlab::GlRepository::SNIPPET)
         subject.finish!
 
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.wiki.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.design.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', personal_snippet.disk_path + '.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project_snippet.disk_path + '.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path, backup_id, '001.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path + '.wiki', backup_id, '001.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path + '.design', backup_id, '001.bundle'))
+        expect(File).to exist(File.join(destination, personal_snippet.disk_path, backup_id, '001.bundle'))
+        expect(File).to exist(File.join(destination, project_snippet.disk_path, backup_id, '001.bundle'))
       end
 
       context 'parallel option set' do
         let(:max_parallelism) { 3 }
 
         it 'passes parallel option through' do
-          expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel', '3').and_call_original
+          expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel', '3', '-layout', 'pointer', '-id', backup_id).and_call_original
 
-          subject.start(:create)
+          subject.start(:create, destination)
           subject.finish!
         end
       end
@@ -72,9 +74,9 @@ RSpec.describe Backup::GitalyBackup do
         let(:storage_parallelism) { 3 }
 
         it 'passes parallel option through' do
-          expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel-storage', '3').and_call_original
+          expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel-storage', '3', '-layout', 'pointer', '-id', backup_id).and_call_original
 
-          subject.start(:create)
+          subject.start(:create, destination)
           subject.finish!
         end
       end
@@ -82,9 +84,39 @@ RSpec.describe Backup::GitalyBackup do
       it 'raises when the exit code not zero' do
         expect(subject).to receive(:bin_path).and_return(Gitlab::Utils.which('false'))
 
-        subject.start(:create)
+        subject.start(:create, destination)
         expect { subject.finish! }.to raise_error(::Backup::Error, 'gitaly-backup exit status 1')
       end
+
+      context 'feature flag incremental_repository_backup disabled' do
+        before do
+          stub_feature_flags(incremental_repository_backup: false)
+        end
+
+        it 'creates repository bundles', :aggregate_failures do
+          # Add data to the wiki, design repositories, and snippets, so they will be included in the dump.
+          create(:wiki_page, container: project)
+          create(:design, :with_file, issue: create(:issue, project: project))
+          project_snippet = create(:project_snippet, :repository, project: project)
+          personal_snippet = create(:personal_snippet, :repository, author: project.first_owner)
+
+          expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything).and_call_original
+
+          subject.start(:create, destination)
+          subject.enqueue(project, Gitlab::GlRepository::PROJECT)
+          subject.enqueue(project, Gitlab::GlRepository::WIKI)
+          subject.enqueue(project, Gitlab::GlRepository::DESIGN)
+          subject.enqueue(personal_snippet, Gitlab::GlRepository::SNIPPET)
+          subject.enqueue(project_snippet, Gitlab::GlRepository::SNIPPET)
+          subject.finish!
+
+          expect(File).to exist(File.join(destination, project.disk_path + '.bundle'))
+          expect(File).to exist(File.join(destination, project.disk_path + '.wiki.bundle'))
+          expect(File).to exist(File.join(destination, project.disk_path + '.design.bundle'))
+          expect(File).to exist(File.join(destination, personal_snippet.disk_path + '.bundle'))
+          expect(File).to exist(File.join(destination, project_snippet.disk_path + '.bundle'))
+        end
+      end
     end
 
     context 'hashed storage' do
@@ -112,9 +144,9 @@ RSpec.describe Backup::GitalyBackup do
       end
 
       it 'passes through SSL envs' do
-        expect(Open3).to receive(:popen2).with(ssl_env, anything, 'create', '-path', anything).and_call_original
+        expect(Open3).to receive(:popen2).with(ssl_env, anything, 'create', '-path', anything, '-layout', 'pointer', '-id', backup_id).and_call_original
 
-        subject.start(:create)
+        subject.start(:create, destination)
         subject.finish!
       end
     end
@@ -137,9 +169,9 @@ RSpec.describe Backup::GitalyBackup do
       copy_bundle_to_backup_path('personal_snippet_repo.bundle', personal_snippet.disk_path + '.bundle')
       copy_bundle_to_backup_path('project_snippet_repo.bundle', project_snippet.disk_path + '.bundle')
 
-      expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything).and_call_original
+      expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-layout', 'pointer').and_call_original
 
-      subject.start(:restore)
+      subject.start(:restore, destination)
       subject.enqueue(project, Gitlab::GlRepository::PROJECT)
       subject.enqueue(project, Gitlab::GlRepository::WIKI)
       subject.enqueue(project, Gitlab::GlRepository::DESIGN)
@@ -149,20 +181,20 @@ RSpec.describe Backup::GitalyBackup do
 
       collect_commit_shas = -> (repo) { repo.commits('master', limit: 10).map(&:sha) }
 
-      expect(collect_commit_shas.call(project.repository)).to eq(['393a7d860a5a4c3cc736d7eb00604e3472bb95ec'])
-      expect(collect_commit_shas.call(project.wiki.repository)).to eq(['c74b9948d0088d703ee1fafeddd9ed9add2901ea'])
-      expect(collect_commit_shas.call(project.design_repository)).to eq(['c3cd4d7bd73a51a0f22045c3a4c871c435dc959d'])
-      expect(collect_commit_shas.call(personal_snippet.repository)).to eq(['3b3c067a3bc1d1b695b51e2be30c0f8cf698a06e'])
-      expect(collect_commit_shas.call(project_snippet.repository)).to eq(['6e44ba56a4748be361a841e759c20e421a1651a1'])
+      expect(collect_commit_shas.call(project.repository)).to match_array(['393a7d860a5a4c3cc736d7eb00604e3472bb95ec'])
+      expect(collect_commit_shas.call(project.wiki.repository)).to match_array(['c74b9948d0088d703ee1fafeddd9ed9add2901ea'])
+      expect(collect_commit_shas.call(project.design_repository)).to match_array(['c3cd4d7bd73a51a0f22045c3a4c871c435dc959d'])
+      expect(collect_commit_shas.call(personal_snippet.repository)).to match_array(['3b3c067a3bc1d1b695b51e2be30c0f8cf698a06e'])
+      expect(collect_commit_shas.call(project_snippet.repository)).to match_array(['6e44ba56a4748be361a841e759c20e421a1651a1'])
     end
 
     context 'parallel option set' do
       let(:max_parallelism) { 3 }
 
       it 'passes parallel option through' do
-        expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel', '3').and_call_original
+        expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel', '3', '-layout', 'pointer').and_call_original
 
-        subject.start(:restore)
+        subject.start(:restore, destination)
         subject.finish!
       end
     end
@@ -171,17 +203,49 @@ RSpec.describe Backup::GitalyBackup do
       let(:storage_parallelism) { 3 }
 
       it 'passes parallel option through' do
-        expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel-storage', '3').and_call_original
+        expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel-storage', '3', '-layout', 'pointer').and_call_original
 
-        subject.start(:restore)
+        subject.start(:restore, destination)
         subject.finish!
       end
     end
 
+    context 'feature flag incremental_repository_backup disabled' do
+      before do
+        stub_feature_flags(incremental_repository_backup: false)
+      end
+
+      it 'restores from repository bundles', :aggregate_failures do
+        copy_bundle_to_backup_path('project_repo.bundle', project.disk_path + '.bundle')
+        copy_bundle_to_backup_path('wiki_repo.bundle', project.disk_path + '.wiki.bundle')
+        copy_bundle_to_backup_path('design_repo.bundle', project.disk_path + '.design.bundle')
+        copy_bundle_to_backup_path('personal_snippet_repo.bundle', personal_snippet.disk_path + '.bundle')
+        copy_bundle_to_backup_path('project_snippet_repo.bundle', project_snippet.disk_path + '.bundle')
+
+        expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything).and_call_original
+
+        subject.start(:restore, destination)
+        subject.enqueue(project, Gitlab::GlRepository::PROJECT)
+        subject.enqueue(project, Gitlab::GlRepository::WIKI)
+        subject.enqueue(project, Gitlab::GlRepository::DESIGN)
+        subject.enqueue(personal_snippet, Gitlab::GlRepository::SNIPPET)
+        subject.enqueue(project_snippet, Gitlab::GlRepository::SNIPPET)
+        subject.finish!
+
+        collect_commit_shas = -> (repo) { repo.commits('master', limit: 10).map(&:sha) }
+
+        expect(collect_commit_shas.call(project.repository)).to match_array(['393a7d860a5a4c3cc736d7eb00604e3472bb95ec'])
+        expect(collect_commit_shas.call(project.wiki.repository)).to match_array(['c74b9948d0088d703ee1fafeddd9ed9add2901ea'])
+        expect(collect_commit_shas.call(project.design_repository)).to match_array(['c3cd4d7bd73a51a0f22045c3a4c871c435dc959d'])
+        expect(collect_commit_shas.call(personal_snippet.repository)).to match_array(['3b3c067a3bc1d1b695b51e2be30c0f8cf698a06e'])
+        expect(collect_commit_shas.call(project_snippet.repository)).to match_array(['6e44ba56a4748be361a841e759c20e421a1651a1'])
+      end
+    end
+
     it 'raises when the exit code not zero' do
       expect(subject).to receive(:bin_path).and_return(Gitlab::Utils.which('false'))
 
-      subject.start(:restore)
+      subject.start(:restore, destination)
       expect { subject.finish! }.to raise_error(::Backup::Error, 'gitaly-backup exit status 1')
     end
   end
diff --git a/spec/lib/backup/gitaly_rpc_backup_spec.rb b/spec/lib/backup/gitaly_rpc_backup_spec.rb
index 4829d51ac9d..6cba8c5c9b1 100644
--- a/spec/lib/backup/gitaly_rpc_backup_spec.rb
+++ b/spec/lib/backup/gitaly_rpc_backup_spec.rb
@@ -4,6 +4,7 @@ require 'spec_helper'
 
 RSpec.describe Backup::GitalyRpcBackup do
   let(:progress) { spy(:stdout) }
+  let(:destination) { File.join(Gitlab.config.backup.path, 'repositories') }
 
   subject { described_class.new(progress) }
 
@@ -14,7 +15,7 @@ RSpec.describe Backup::GitalyRpcBackup do
 
   context 'unknown' do
     it 'fails to start unknown' do
-      expect { subject.start(:unknown) }.to raise_error(::Backup::Error, 'unknown backup type: unknown')
+      expect { subject.start(:unknown, destination) }.to raise_error(::Backup::Error, 'unknown backup type: unknown')
     end
   end
 
@@ -27,7 +28,7 @@ RSpec.describe Backup::GitalyRpcBackup do
         project_snippet = create(:project_snippet, :repository, project: project)
         personal_snippet = create(:personal_snippet, :repository, author: project.first_owner)
 
-        subject.start(:create)
+        subject.start(:create, destination)
         subject.enqueue(project, Gitlab::GlRepository::PROJECT)
         subject.enqueue(project, Gitlab::GlRepository::WIKI)
         subject.enqueue(project, Gitlab::GlRepository::DESIGN)
@@ -35,11 +36,11 @@ RSpec.describe Backup::GitalyRpcBackup do
         subject.enqueue(project_snippet, Gitlab::GlRepository::SNIPPET)
         subject.finish!
 
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.wiki.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project.disk_path + '.design.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', personal_snippet.disk_path + '.bundle'))
-        expect(File).to exist(File.join(Gitlab.config.backup.path, 'repositories', project_snippet.disk_path + '.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path + '.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path + '.wiki.bundle'))
+        expect(File).to exist(File.join(destination, project.disk_path + '.design.bundle'))
+        expect(File).to exist(File.join(destination, personal_snippet.disk_path + '.bundle'))
+        expect(File).to exist(File.join(destination, project_snippet.disk_path + '.bundle'))
       end
 
       context 'failure' do
@@ -50,7 +51,7 @@ RSpec.describe Backup::GitalyRpcBackup do
         end
 
         it 'logs an appropriate message', :aggregate_failures do
-          subject.start(:create)
+          subject.start(:create, destination)
           subject.enqueue(project, Gitlab::GlRepository::PROJECT)
           subject.finish!
 
@@ -90,7 +91,7 @@ RSpec.describe Backup::GitalyRpcBackup do
       copy_bundle_to_backup_path('personal_snippet_repo.bundle', personal_snippet.disk_path + '.bundle')
       copy_bundle_to_backup_path('project_snippet_repo.bundle', project_snippet.disk_path + '.bundle')
 
-      subject.start(:restore)
+      subject.start(:restore, destination)
       subject.enqueue(project, Gitlab::GlRepository::PROJECT)
       subject.enqueue(project, Gitlab::GlRepository::WIKI)
       subject.enqueue(project, Gitlab::GlRepository::DESIGN)
@@ -123,7 +124,7 @@ RSpec.describe Backup::GitalyRpcBackup do
         repository
       end
 
-      subject.start(:restore)
+      subject.start(:restore, destination)
       subject.enqueue(project, Gitlab::GlRepository::PROJECT)
       subject.enqueue(project, Gitlab::GlRepository::WIKI)
       subject.enqueue(project, Gitlab::GlRepository::DESIGN)
@@ -141,7 +142,7 @@ RSpec.describe Backup::GitalyRpcBackup do
       end
 
       it 'logs an appropriate message', :aggregate_failures do
-        subject.start(:restore)
+        subject.start(:restore, destination)
         subject.enqueue(project, Gitlab::GlRepository::PROJECT)
         subject.finish!
 
diff --git a/spec/lib/backup/lfs_spec.rb b/spec/lib/backup/lfs_spec.rb
index 6525019d9ac..a27f60f20d0 100644
--- a/spec/lib/backup/lfs_spec.rb
+++ b/spec/lib/backup/lfs_spec.rb
@@ -20,7 +20,7 @@ RSpec.describe Backup::Lfs do
       expect(backup).to receive(:run_pipeline!).with([%w(blabla-tar --exclude=lost+found -C /var/lfs-objects -cf - .), 'gzip -c -1'], any_args).and_return([[true, true], ''])
       expect(backup).to receive(:pipeline_succeeded?).and_return(true)
 
-      backup.dump
+      backup.dump('lfs.tar.gz')
     end
   end
 end
diff --git a/spec/lib/backup/manager_spec.rb b/spec/lib/backup/manager_spec.rb
index 9c186205067..9cf78a11bc7 100644
--- a/spec/lib/backup/manager_spec.rb
+++ b/spec/lib/backup/manager_spec.rb
@@ -6,16 +6,149 @@ RSpec.describe Backup::Manager do
   include StubENV
 
   let(:progress) { StringIO.new }
+  let(:definitions) { nil }
 
-  subject { described_class.new(progress) }
+  subject { described_class.new(progress, definitions: definitions) }
 
   before do
+    # Rspec fails with `uninitialized constant RSpec::Support::Differ` when it
+    # is trying to display a diff and `File.exist?` is stubbed. Adding a
+    # default stub fixes this.
+    allow(File).to receive(:exist?).and_call_original
+
     allow(progress).to receive(:puts)
     allow(progress).to receive(:print)
   end
 
-  describe '#pack' do
-    let(:expected_backup_contents) { %w(repositories db uploads.tar.gz builds.tar.gz artifacts.tar.gz pages.tar.gz lfs.tar.gz terraform_state.tar.gz packages.tar.gz backup_information.yml) }
+  describe '#run_create_task' do
+    let(:enabled) { true }
+    let(:task) { instance_double(Backup::Task, human_name: 'my task', enabled: enabled) }
+    let(:definitions) { { 'my_task' => Backup::Manager::TaskDefinition.new(task: task, destination_path: 'my_task.tar.gz') } }
+
+    it 'calls the named task' do
+      expect(task).to receive(:dump)
+      expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Dumping my task ... ')
+      expect(Gitlab::BackupLogger).to receive(:info).with(message: 'done')
+
+      subject.run_create_task('my_task')
+    end
+
+    describe 'disabled' do
+      let(:enabled) { false }
+
+      it 'informs the user' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Dumping my task ... ')
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: '[DISABLED]')
+
+        subject.run_create_task('my_task')
+      end
+    end
+
+    describe 'skipped' do
+      it 'informs the user' do
+        stub_env('SKIP', 'my_task')
+
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Dumping my task ... ')
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: '[SKIPPED]')
+
+        subject.run_create_task('my_task')
+      end
+    end
+  end
+
+  describe '#run_restore_task' do
+    let(:enabled) { true }
+    let(:pre_restore_warning) { nil }
+    let(:post_restore_warning) { nil }
+    let(:definitions) { { 'my_task' => Backup::Manager::TaskDefinition.new(task: task, destination_path: 'my_task.tar.gz') } }
+    let(:backup_information) { {} }
+    let(:task) do
+      instance_double(Backup::Task,
+             human_name: 'my task',
+             enabled: enabled,
+             pre_restore_warning: pre_restore_warning,
+             post_restore_warning: post_restore_warning)
+    end
+
+    before do
+      allow(YAML).to receive(:load_file).with(File.join(Gitlab.config.backup.path, 'backup_information.yml'))
+        .and_return(backup_information)
+    end
+
+    it 'calls the named task' do
+      expect(task).to receive(:restore)
+      expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+      expect(Gitlab::BackupLogger).to receive(:info).with(message: 'done').ordered
+
+      subject.run_restore_task('my_task')
+    end
+
+    describe 'disabled' do
+      let(:enabled) { false }
+
+      it 'informs the user' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: '[DISABLED]').ordered
+
+        subject.run_restore_task('my_task')
+      end
+    end
+
+    describe 'pre_restore_warning' do
+      let(:pre_restore_warning) { 'Watch out!' }
+
+      it 'displays and waits for the user' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Watch out!').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'done').ordered
+        expect(Gitlab::TaskHelpers).to receive(:ask_to_continue)
+        expect(task).to receive(:restore)
+
+        subject.run_restore_task('my_task')
+      end
+
+      it 'does not continue when the user quits' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Watch out!').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Quitting...').ordered
+        expect(Gitlab::TaskHelpers).to receive(:ask_to_continue).and_raise(Gitlab::TaskAbortedByUserError)
+
+        expect do
+          subject.run_restore_task('my_task')
+        end.to raise_error(SystemExit)
+      end
+    end
+
+    describe 'post_restore_warning' do
+      let(:post_restore_warning) { 'Watch out!' }
+
+      it 'displays and waits for the user' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'done').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Watch out!').ordered
+        expect(Gitlab::TaskHelpers).to receive(:ask_to_continue)
+        expect(task).to receive(:restore)
+
+        subject.run_restore_task('my_task')
+      end
+
+      it 'does not continue when the user quits' do
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Restoring my task ... ').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'done').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Watch out!').ordered
+        expect(Gitlab::BackupLogger).to receive(:info).with(message: 'Quitting...').ordered
+        expect(task).to receive(:restore)
+        expect(Gitlab::TaskHelpers).to receive(:ask_to_continue).and_raise(Gitlab::TaskAbortedByUserError)
+
+        expect do
+          subject.run_restore_task('my_task')
+        end.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:expected_backup_contents) { %w{backup_information.yml task1.tar.gz task2.tar.gz} }
     let(:tar_file) { '1546300800_2019_01_01_12.3_gitlab_backup.tar' }
     let(:tar_system_options) { { out: [tar_file, 'w', Gitlab.config.backup.archive_permissions] } }
     let(:tar_cmdline) { ['tar', '-cf', '-', *expected_backup_contents, tar_system_options] }
@@ -26,21 +159,28 @@ RSpec.describe Backup::Manager do
       }
     end
 
+    let(:task1) { instance_double(Backup::Task, human_name: 'task 1', enabled: true) }
+    let(:task2) { instance_double(Backup::Task, human_name: 'task 2', enabled: true) }
+    let(:definitions) do
+      {
+        'task1' => Backup::Manager::TaskDefinition.new(task: task1, destination_path: 'task1.tar.gz'),
+        'task2' => Backup::Manager::TaskDefinition.new(task: task2, destination_path: 'task2.tar.gz')
+      }
+    end
+
     before do
       allow(ActiveRecord::Base.connection).to receive(:reconnect!)
       allow(Kernel).to receive(:system).and_return(true)
-      allow(YAML).to receive(:load_file).and_return(backup_information)
-
-      ::Backup::Manager::FOLDERS_TO_BACKUP.each do |folder|
-        allow(Dir).to receive(:exist?).with(File.join(Gitlab.config.backup.path, folder)).and_return(true)
-      end
+      allow(YAML).to receive(:load_file).with(File.join(Gitlab.config.backup.path, 'backup_information.yml'))
+        .and_return(backup_information)
 
       allow(subject).to receive(:backup_information).and_return(backup_information)
-      allow(subject).to receive(:upload)
+      allow(task1).to receive(:dump).with(File.join(Gitlab.config.backup.path, 'task1.tar.gz'))
+      allow(task2).to receive(:dump).with(File.join(Gitlab.config.backup.path, 'task2.tar.gz'))
     end
 
     it 'executes tar' do
-      subject.pack
+      subject.create # rubocop:disable Rails/SaveBang
 
       expect(Kernel).to have_received(:system).with(*tar_cmdline)
     end
@@ -50,247 +190,401 @@ RSpec.describe Backup::Manager do
 
       it 'uses the given value as tar file name' do
         stub_env('BACKUP', '/ignored/path/custom')
-        subject.pack
+        subject.create # rubocop:disable Rails/SaveBang
 
         expect(Kernel).to have_received(:system).with(*tar_cmdline)
       end
     end
 
     context 'when skipped is set in backup_information.yml' do
-      let(:expected_backup_contents) { %w{db uploads.tar.gz builds.tar.gz artifacts.tar.gz pages.tar.gz lfs.tar.gz terraform_state.tar.gz packages.tar.gz backup_information.yml} }
+      let(:expected_backup_contents) { %w{backup_information.yml task1.tar.gz} }
       let(:backup_information) do
         {
           backup_created_at: Time.zone.parse('2019-01-01'),
           gitlab_version: '12.3',
-          skipped: ['repositories']
+          skipped: ['task2']
         }
       end
 
       it 'executes tar' do
-        subject.pack
+        subject.create # rubocop:disable Rails/SaveBang
 
         expect(Kernel).to have_received(:system).with(*tar_cmdline)
       end
     end
 
-    context 'when a directory does not exist' do
-      let(:expected_backup_contents) { %w{db uploads.tar.gz builds.tar.gz artifacts.tar.gz pages.tar.gz lfs.tar.gz terraform_state.tar.gz packages.tar.gz backup_information.yml} }
-
-      before do
-        expect(Dir).to receive(:exist?).with(File.join(Gitlab.config.backup.path, 'repositories')).and_return(false)
+    context 'when the destination is optional' do
+      let(:expected_backup_contents) { %w{backup_information.yml task1.tar.gz} }
+      let(:definitions) do
+        {
+          'task1' => Backup::Manager::TaskDefinition.new(task: task1, destination_path: 'task1.tar.gz'),
+          'task2' => Backup::Manager::TaskDefinition.new(task: task2, destination_path: 'task2.tar.gz', destination_optional: true)
+        }
       end
 
       it 'executes tar' do
-        subject.pack
+        expect(File).to receive(:exist?).with(File.join(Gitlab.config.backup.path, 'task2.tar.gz')).and_return(false)
+
+        subject.create # rubocop:disable Rails/SaveBang
 
         expect(Kernel).to have_received(:system).with(*tar_cmdline)
       end
     end
-  end
 
-  describe '#remove_tmp' do
-    let(:path) { File.join(Gitlab.config.backup.path, 'tmp') }
+    context 'many backup files' do
+      let(:files) do
+        [
+          '1451606400_2016_01_01_1.2.3_gitlab_backup.tar',
+          '1451520000_2015_12_31_4.5.6_gitlab_backup.tar',
+          '1451520000_2015_12_31_4.5.6-pre_gitlab_backup.tar',
+          '1451520000_2015_12_31_4.5.6-rc1_gitlab_backup.tar',
+          '1451520000_2015_12_31_4.5.6-pre-ee_gitlab_backup.tar',
+          '1451510000_2015_12_30_gitlab_backup.tar',
+          '1450742400_2015_12_22_gitlab_backup.tar',
+          '1449878400_gitlab_backup.tar',
+          '1449014400_gitlab_backup.tar',
+          'manual_gitlab_backup.tar'
+        ]
+      end
 
-    before do
-      allow(FileUtils).to receive(:rm_rf).and_return(true)
-    end
+      before do
+        allow(Dir).to receive(:chdir).and_yield
+        allow(Dir).to receive(:glob).and_return(files)
+        allow(FileUtils).to receive(:rm)
+        allow(Time).to receive(:now).and_return(Time.utc(2016))
+      end
 
-    it 'removes backups/tmp dir' do
-      subject.remove_tmp
+      context 'when keep_time is zero' do
+        before do
+          allow(Gitlab.config.backup).to receive(:keep_time).and_return(0)
 
-      expect(FileUtils).to have_received(:rm_rf).with(path)
-    end
+          subject.create # rubocop:disable Rails/SaveBang
+        end
 
-    it 'prints running task with a done confirmation' do
-      subject.remove_tmp
+        it 'removes no files' do
+          expect(FileUtils).not_to have_received(:rm)
+        end
 
-      expect(progress).to have_received(:print).with('Deleting backups/tmp ... ')
-      expect(progress).to have_received(:puts).with('done')
-    end
-  end
+        it 'prints a skipped message' do
+          expect(progress).to have_received(:puts).with('skipping')
+        end
+      end
 
-  describe '#remove_old' do
-    let(:files) do
-      [
-        '1451606400_2016_01_01_1.2.3_gitlab_backup.tar',
-        '1451520000_2015_12_31_4.5.6_gitlab_backup.tar',
-        '1451520000_2015_12_31_4.5.6-pre_gitlab_backup.tar',
-        '1451520000_2015_12_31_4.5.6-rc1_gitlab_backup.tar',
-        '1451520000_2015_12_31_4.5.6-pre-ee_gitlab_backup.tar',
-        '1451510000_2015_12_30_gitlab_backup.tar',
-        '1450742400_2015_12_22_gitlab_backup.tar',
-        '1449878400_gitlab_backup.tar',
-        '1449014400_gitlab_backup.tar',
-        'manual_gitlab_backup.tar'
-      ]
-    end
+      context 'when no valid file is found' do
+        let(:files) do
+          [
+            '14516064000_2016_01_01_1.2.3_gitlab_backup.tar',
+            'foo_1451520000_2015_12_31_4.5.6_gitlab_backup.tar',
+            '1451520000_2015_12_31_4.5.6-foo_gitlab_backup.tar'
+          ]
+        end
 
-    before do
-      allow(Dir).to receive(:chdir).and_yield
-      allow(Dir).to receive(:glob).and_return(files)
-      allow(FileUtils).to receive(:rm)
-      allow(Time).to receive(:now).and_return(Time.utc(2016))
-    end
+        before do
+          allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
 
-    context 'when keep_time is zero' do
-      before do
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(0)
+          subject.create # rubocop:disable Rails/SaveBang
+        end
 
-        subject.remove_old
-      end
+        it 'removes no files' do
+          expect(FileUtils).not_to have_received(:rm)
+        end
 
-      it 'removes no files' do
-        expect(FileUtils).not_to have_received(:rm)
+        it 'prints a done message' do
+          expect(progress).to have_received(:puts).with('done. (0 removed)')
+        end
       end
 
-      it 'prints a skipped message' do
-        expect(progress).to have_received(:puts).with('skipping')
-      end
-    end
+      context 'when there are no files older than keep_time' do
+        before do
+          # Set to 30 days
+          allow(Gitlab.config.backup).to receive(:keep_time).and_return(2592000)
 
-    context 'when no valid file is found' do
-      let(:files) do
-        [
-          '14516064000_2016_01_01_1.2.3_gitlab_backup.tar',
-          'foo_1451520000_2015_12_31_4.5.6_gitlab_backup.tar',
-          '1451520000_2015_12_31_4.5.6-foo_gitlab_backup.tar'
-        ]
-      end
+          subject.create # rubocop:disable Rails/SaveBang
+        end
 
-      before do
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+        it 'removes no files' do
+          expect(FileUtils).not_to have_received(:rm)
+        end
 
-        subject.remove_old
+        it 'prints a done message' do
+          expect(progress).to have_received(:puts).with('done. (0 removed)')
+        end
       end
 
-      it 'removes no files' do
-        expect(FileUtils).not_to have_received(:rm)
-      end
+      context 'when keep_time is set to remove files' do
+        before do
+          # Set to 1 second
+          allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
 
-      it 'prints a done message' do
-        expect(progress).to have_received(:puts).with('done. (0 removed)')
-      end
-    end
+          subject.create # rubocop:disable Rails/SaveBang
+        end
 
-    context 'when there are no files older than keep_time' do
-      before do
-        # Set to 30 days
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(2592000)
+        it 'removes matching files with a human-readable versioned timestamp' do
+          expect(FileUtils).to have_received(:rm).with(files[1])
+          expect(FileUtils).to have_received(:rm).with(files[2])
+          expect(FileUtils).to have_received(:rm).with(files[3])
+        end
 
-        subject.remove_old
-      end
+        it 'removes matching files with a human-readable versioned timestamp with tagged EE' do
+          expect(FileUtils).to have_received(:rm).with(files[4])
+        end
 
-      it 'removes no files' do
-        expect(FileUtils).not_to have_received(:rm)
-      end
+        it 'removes matching files with a human-readable non-versioned timestamp' do
+          expect(FileUtils).to have_received(:rm).with(files[5])
+          expect(FileUtils).to have_received(:rm).with(files[6])
+        end
 
-      it 'prints a done message' do
-        expect(progress).to have_received(:puts).with('done. (0 removed)')
-      end
-    end
+        it 'removes matching files without a human-readable timestamp' do
+          expect(FileUtils).to have_received(:rm).with(files[7])
+          expect(FileUtils).to have_received(:rm).with(files[8])
+        end
 
-    context 'when keep_time is set to remove files' do
-      before do
-        # Set to 1 second
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+        it 'does not remove files that are not old enough' do
+          expect(FileUtils).not_to have_received(:rm).with(files[0])
+        end
 
-        subject.remove_old
-      end
+        it 'does not remove non-matching files' do
+          expect(FileUtils).not_to have_received(:rm).with(files[9])
+        end
 
-      it 'removes matching files with a human-readable versioned timestamp' do
-        expect(FileUtils).to have_received(:rm).with(files[1])
-        expect(FileUtils).to have_received(:rm).with(files[2])
-        expect(FileUtils).to have_received(:rm).with(files[3])
+        it 'prints a done message' do
+          expect(progress).to have_received(:puts).with('done. (8 removed)')
+        end
       end
 
-      it 'removes matching files with a human-readable versioned timestamp with tagged EE' do
-        expect(FileUtils).to have_received(:rm).with(files[4])
-      end
+      context 'when removing a file fails' do
+        let(:file) { files[1] }
+        let(:message) { "Permission denied @ unlink_internal - #{file}" }
 
-      it 'removes matching files with a human-readable non-versioned timestamp' do
-        expect(FileUtils).to have_received(:rm).with(files[5])
-        expect(FileUtils).to have_received(:rm).with(files[6])
-      end
+        before do
+          allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+          allow(FileUtils).to receive(:rm).with(file).and_raise(Errno::EACCES, message)
 
-      it 'removes matching files without a human-readable timestamp' do
-        expect(FileUtils).to have_received(:rm).with(files[7])
-        expect(FileUtils).to have_received(:rm).with(files[8])
-      end
+          subject.create # rubocop:disable Rails/SaveBang
+        end
 
-      it 'does not remove files that are not old enough' do
-        expect(FileUtils).not_to have_received(:rm).with(files[0])
-      end
+        it 'removes the remaining expected files' do
+          expect(FileUtils).to have_received(:rm).with(files[4])
+          expect(FileUtils).to have_received(:rm).with(files[5])
+          expect(FileUtils).to have_received(:rm).with(files[6])
+          expect(FileUtils).to have_received(:rm).with(files[7])
+          expect(FileUtils).to have_received(:rm).with(files[8])
+        end
 
-      it 'does not remove non-matching files' do
-        expect(FileUtils).not_to have_received(:rm).with(files[9])
-      end
+        it 'sets the correct removed count' do
+          expect(progress).to have_received(:puts).with('done. (7 removed)')
+        end
 
-      it 'prints a done message' do
-        expect(progress).to have_received(:puts).with('done. (8 removed)')
+        it 'prints the error from file that could not be removed' do
+          expect(progress).to have_received(:puts).with(a_string_matching(message))
+        end
       end
     end
 
-    context 'when removing a file fails' do
-      let(:file) { files[1] }
-      let(:message) { "Permission denied @ unlink_internal - #{file}" }
+    describe 'cloud storage' do
+      let(:backup_file) { Tempfile.new('backup', Gitlab.config.backup.path) }
+      let(:backup_filename) { File.basename(backup_file.path) }
 
       before do
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
-        allow(FileUtils).to receive(:rm).with(file).and_raise(Errno::EACCES, message)
+        allow(subject).to receive(:tar_file).and_return(backup_filename)
 
-        subject.remove_old
-      end
+        stub_backup_setting(
+          upload: {
+            connection: {
+              provider: 'AWS',
+              aws_access_key_id: 'id',
+              aws_secret_access_key: 'secret'
+            },
+            remote_directory: 'directory',
+            multipart_chunk_size: 104857600,
+            encryption: nil,
+            encryption_key: nil,
+            storage_class: nil
+          }
+        )
 
-      it 'removes the remaining expected files' do
-        expect(FileUtils).to have_received(:rm).with(files[4])
-        expect(FileUtils).to have_received(:rm).with(files[5])
-        expect(FileUtils).to have_received(:rm).with(files[6])
-        expect(FileUtils).to have_received(:rm).with(files[7])
-        expect(FileUtils).to have_received(:rm).with(files[8])
-      end
+        Fog.mock!
 
-      it 'sets the correct removed count' do
-        expect(progress).to have_received(:puts).with('done. (7 removed)')
+        # the Fog mock only knows about directories we create explicitly
+        connection = ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys)
+        connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
       end
 
-      it 'prints the error from file that could not be removed' do
-        expect(progress).to have_received(:puts).with(a_string_matching(message))
+      context 'target path' do
+        it 'uses the tar filename by default' do
+          expect_any_instance_of(Fog::Collection).to receive(:create)
+            .with(hash_including(key: backup_filename, public: false))
+            .and_call_original
+
+          subject.create # rubocop:disable Rails/SaveBang
+        end
+
+        it 'adds the DIRECTORY environment variable if present' do
+          stub_env('DIRECTORY', 'daily')
+
+          expect_any_instance_of(Fog::Collection).to receive(:create)
+            .with(hash_including(key: "daily/#{backup_filename}", public: false))
+            .and_call_original
+
+          subject.create # rubocop:disable Rails/SaveBang
+        end
       end
-    end
-  end
 
-  describe 'verify_backup_version' do
-    context 'on version mismatch' do
-      let(:gitlab_version) { Gitlab::VERSION }
+      context 'with AWS with server side encryption' do
+        let(:connection) { ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys) }
+        let(:encryption_key) { nil }
+        let(:encryption) { nil }
+        let(:storage_options) { nil }
+
+        before do
+          stub_backup_setting(
+            upload: {
+              connection: {
+                provider: 'AWS',
+                aws_access_key_id: 'AWS_ACCESS_KEY_ID',
+                aws_secret_access_key: 'AWS_SECRET_ACCESS_KEY'
+              },
+              remote_directory: 'directory',
+              multipart_chunk_size: Gitlab.config.backup.upload.multipart_chunk_size,
+              encryption: encryption,
+              encryption_key: encryption_key,
+              storage_options: storage_options,
+              storage_class: nil
+            }
+          )
+
+          connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
+        end
+
+        context 'with SSE-S3 without using storage_options' do
+          let(:encryption) { 'AES256' }
+
+          it 'sets encryption attributes' do
+            subject.create # rubocop:disable Rails/SaveBang
+
+            expect(progress).to have_received(:puts).with("done (encrypted with AES256)")
+          end
+        end
+
+        context 'with SSE-C (customer-provided keys) options' do
+          let(:encryption) { 'AES256' }
+          let(:encryption_key) { SecureRandom.hex }
 
-      it 'stops the process' do
-        allow(YAML).to receive(:load_file)
-          .and_return({ gitlab_version: "not #{gitlab_version}" })
+          it 'sets encryption attributes' do
+            subject.create # rubocop:disable Rails/SaveBang
 
-        expect { subject.verify_backup_version }.to raise_error SystemExit
+            expect(progress).to have_received(:puts).with("done (encrypted with AES256)")
+          end
+        end
+
+        context 'with SSE-KMS options' do
+          let(:storage_options) do
+            {
+              server_side_encryption: 'aws:kms',
+              server_side_encryption_kms_key_id: 'arn:aws:kms:12345'
+            }
+          end
+
+          it 'sets encryption attributes' do
+            subject.create # rubocop:disable Rails/SaveBang
+
+            expect(progress).to have_received(:puts).with("done (encrypted with aws:kms)")
+          end
+        end
       end
-    end
 
-    context 'on version match' do
-      let(:gitlab_version) { Gitlab::VERSION }
+      context 'with Google provider' do
+        before do
+          stub_backup_setting(
+            upload: {
+              connection: {
+                provider: 'Google',
+                google_storage_access_key_id: 'test-access-id',
+                google_storage_secret_access_key: 'secret'
+              },
+              remote_directory: 'directory',
+              multipart_chunk_size: Gitlab.config.backup.upload.multipart_chunk_size,
+              encryption: nil,
+              encryption_key: nil,
+              storage_class: nil
+            }
+          )
+
+          connection = ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys)
+          connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
+        end
 
-      it 'does nothing' do
-        allow(YAML).to receive(:load_file)
-          .and_return({ gitlab_version: "#{gitlab_version}" })
+        it 'does not attempt to set ACL' do
+          expect_any_instance_of(Fog::Collection).to receive(:create)
+            .with(hash_excluding(public: false))
+            .and_call_original
 
-        expect { subject.verify_backup_version }.not_to raise_error
+          subject.create # rubocop:disable Rails/SaveBang
+        end
+      end
+
+      context 'with AzureRM provider' do
+        before do
+          stub_backup_setting(
+            upload: {
+              connection: {
+                provider: 'AzureRM',
+                azure_storage_account_name: 'test-access-id',
+                azure_storage_access_key: 'secret'
+              },
+              remote_directory: 'directory',
+              multipart_chunk_size: nil,
+              encryption: nil,
+              encryption_key: nil,
+              storage_class: nil
+            }
+          )
+        end
+
+        it 'loads the provider' do
+          expect { subject.create }.not_to raise_error # rubocop:disable Rails/SaveBang
+        end
       end
     end
   end
 
-  describe '#unpack' do
+  describe '#restore' do
+    let(:task1) { instance_double(Backup::Task, human_name: 'task 1', enabled: true, pre_restore_warning: nil, post_restore_warning: nil) }
+    let(:task2) { instance_double(Backup::Task, human_name: 'task 2', enabled: true, pre_restore_warning: nil, post_restore_warning: nil) }
+    let(:definitions) do
+      {
+        'task1' => Backup::Manager::TaskDefinition.new(task: task1, destination_path: 'task1.tar.gz'),
+        'task2' => Backup::Manager::TaskDefinition.new(task: task2, destination_path: 'task2.tar.gz')
+      }
+    end
+
+    let(:gitlab_version) { Gitlab::VERSION }
+    let(:backup_information) do
+      {
+        backup_created_at: Time.zone.parse('2019-01-01'),
+        gitlab_version: gitlab_version
+      }
+    end
+
+    before do
+      Rake.application.rake_require 'tasks/gitlab/shell'
+      Rake.application.rake_require 'tasks/cache'
+
+      allow(task1).to receive(:restore).with(File.join(Gitlab.config.backup.path, 'task1.tar.gz'))
+      allow(task2).to receive(:restore).with(File.join(Gitlab.config.backup.path, 'task2.tar.gz'))
+      allow(YAML).to receive(:load_file).with(File.join(Gitlab.config.backup.path, 'backup_information.yml'))
+        .and_return(backup_information)
+      allow(Rake::Task['gitlab:shell:setup']).to receive(:invoke)
+      allow(Rake::Task['cache:clear']).to receive(:invoke)
+    end
+
     context 'when there are no backup files in the directory' do
       before do
         allow(Dir).to receive(:glob).and_return([])
       end
 
       it 'fails the operation and prints an error' do
-        expect { subject.unpack }.to raise_error SystemExit
+        expect { subject.restore }.to raise_error SystemExit
         expect(progress).to have_received(:puts)
           .with(a_string_matching('No backups found'))
       end
@@ -307,13 +601,13 @@ RSpec.describe Backup::Manager do
       end
 
       it 'prints the list of available backups' do
-        expect { subject.unpack }.to raise_error SystemExit
+        expect { subject.restore }.to raise_error SystemExit
         expect(progress).to have_received(:puts)
           .with(a_string_matching('1451606400_2016_01_01_1.2.3\n 1451520000_2015_12_31'))
       end
 
       it 'fails the operation and prints an error' do
-        expect { subject.unpack }.to raise_error SystemExit
+        expect { subject.restore }.to raise_error SystemExit
         expect(progress).to have_received(:puts)
           .with(a_string_matching('Found more than one backup'))
       end
@@ -332,7 +626,7 @@ RSpec.describe Backup::Manager do
       end
 
       it 'fails the operation and prints an error' do
-        expect { subject.unpack }.to raise_error SystemExit
+        expect { subject.restore }.to raise_error SystemExit
         expect(File).to have_received(:exist?).with('wrong_gitlab_backup.tar')
         expect(progress).to have_received(:puts)
           .with(a_string_matching('The backup file wrong_gitlab_backup.tar does not exist'))
@@ -348,17 +642,46 @@ RSpec.describe Backup::Manager do
         )
         allow(File).to receive(:exist?).and_return(true)
         allow(Kernel).to receive(:system).and_return(true)
-        allow(YAML).to receive(:load_file).and_return(gitlab_version: Gitlab::VERSION)
 
         stub_env('BACKUP', '/ignored/path/1451606400_2016_01_01_1.2.3')
       end
 
       it 'unpacks the file' do
-        subject.unpack
+        subject.restore
 
         expect(Kernel).to have_received(:system)
           .with("tar", "-xf", "1451606400_2016_01_01_1.2.3_gitlab_backup.tar")
-        expect(progress).to have_received(:puts).with(a_string_matching('done'))
+      end
+
+      context 'on version mismatch' do
+        let(:backup_information) do
+          {
+            backup_created_at: Time.zone.parse('2019-01-01'),
+            gitlab_version: "not #{gitlab_version}"
+          }
+        end
+
+        it 'stops the process' do
+          expect { subject.restore }.to raise_error SystemExit
+          expect(progress).to have_received(:puts)
+            .with(a_string_matching('GitLab version mismatch'))
+        end
+      end
+
+      describe 'tmp files' do
+        let(:path) { File.join(Gitlab.config.backup.path, 'tmp') }
+
+        before do
+          allow(FileUtils).to receive(:rm_rf).and_call_original
+        end
+
+        it 'removes backups/tmp dir' do
+          expect(FileUtils).to receive(:rm_rf).with(path).and_call_original
+
+          subject.restore
+
+          expect(progress).to have_received(:print).with('Deleting backups/tmp ... ')
+        end
       end
     end
 
@@ -375,184 +698,41 @@ RSpec.describe Backup::Manager do
       it 'selects the non-tarred backup to restore from' do
         expect(Kernel).not_to receive(:system)
 
-        subject.unpack
+        subject.restore
 
         expect(progress).to have_received(:puts)
           .with(a_string_matching('Non tarred backup found '))
       end
-    end
-  end
-
-  describe '#upload' do
-    let(:backup_file) { Tempfile.new('backup', Gitlab.config.backup.path) }
-    let(:backup_filename) { File.basename(backup_file.path) }
-
-    before do
-      allow(subject).to receive(:tar_file).and_return(backup_filename)
-
-      stub_backup_setting(
-        upload: {
-          connection: {
-            provider: 'AWS',
-            aws_access_key_id: 'id',
-            aws_secret_access_key: 'secret'
-          },
-          remote_directory: 'directory',
-          multipart_chunk_size: 104857600,
-          encryption: nil,
-          encryption_key: nil,
-          storage_class: nil
-        }
-      )
-
-      Fog.mock!
-
-      # the Fog mock only knows about directories we create explicitly
-      connection = ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys)
-      connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
-    end
 
-    context 'target path' do
-      it 'uses the tar filename by default' do
-        expect_any_instance_of(Fog::Collection).to receive(:create)
-          .with(hash_including(key: backup_filename, public: false))
-          .and_return(true)
-
-        subject.upload
-      end
-
-      it 'adds the DIRECTORY environment variable if present' do
-        stub_env('DIRECTORY', 'daily')
-
-        expect_any_instance_of(Fog::Collection).to receive(:create)
-          .with(hash_including(key: "daily/#{backup_filename}", public: false))
-          .and_return(true)
-
-        subject.upload
-      end
-    end
-
-    context 'with AWS with server side encryption' do
-      let(:connection) { ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys) }
-      let(:encryption_key) { nil }
-      let(:encryption) { nil }
-      let(:storage_options) { nil }
-
-      before do
-        stub_backup_setting(
-          upload: {
-            connection: {
-              provider: 'AWS',
-              aws_access_key_id: 'AWS_ACCESS_KEY_ID',
-              aws_secret_access_key: 'AWS_SECRET_ACCESS_KEY'
-            },
-            remote_directory: 'directory',
-            multipart_chunk_size: Gitlab.config.backup.upload.multipart_chunk_size,
-            encryption: encryption,
-            encryption_key: encryption_key,
-            storage_options: storage_options,
-            storage_class: nil
-          }
-        )
-
-        connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
-      end
-
-      context 'with SSE-S3 without using storage_options' do
-        let(:encryption) { 'AES256' }
-
-        it 'sets encryption attributes' do
-          result = subject.upload
-
-          expect(result.key).to be_present
-          expect(result.encryption).to eq('AES256')
-          expect(result.encryption_key).to be_nil
-          expect(result.kms_key_id).to be_nil
-        end
-      end
-
-      context 'with SSE-C (customer-provided keys) options' do
-        let(:encryption) { 'AES256' }
-        let(:encryption_key) { SecureRandom.hex }
-
-        it 'sets encryption attributes' do
-          result = subject.upload
-
-          expect(result.key).to be_present
-          expect(result.encryption).to eq(encryption)
-          expect(result.encryption_key).to eq(encryption_key)
-          expect(result.kms_key_id).to be_nil
-        end
-      end
-
-      context 'with SSE-KMS options' do
-        let(:storage_options) do
+      context 'on version mismatch' do
+        let(:backup_information) do
           {
-            server_side_encryption: 'aws:kms',
-            server_side_encryption_kms_key_id: 'arn:aws:kms:12345'
+            backup_created_at: Time.zone.parse('2019-01-01'),
+            gitlab_version: "not #{gitlab_version}"
           }
         end
 
-        it 'sets encryption attributes' do
-          result = subject.upload
-
-          expect(result.key).to be_present
-          expect(result.encryption).to eq('aws:kms')
-          expect(result.kms_key_id).to eq('arn:aws:kms:12345')
+        it 'stops the process' do
+          expect { subject.restore }.to raise_error SystemExit
+          expect(progress).to have_received(:puts)
+            .with(a_string_matching('GitLab version mismatch'))
         end
       end
-    end
 
-    context 'with Google provider' do
-      before do
-        stub_backup_setting(
-          upload: {
-            connection: {
-              provider: 'Google',
-              google_storage_access_key_id: 'test-access-id',
-              google_storage_secret_access_key: 'secret'
-            },
-            remote_directory: 'directory',
-            multipart_chunk_size: Gitlab.config.backup.upload.multipart_chunk_size,
-            encryption: nil,
-            encryption_key: nil,
-            storage_class: nil
-          }
-        )
-
-        connection = ::Fog::Storage.new(Gitlab.config.backup.upload.connection.symbolize_keys)
-        connection.directories.create(key: Gitlab.config.backup.upload.remote_directory) # rubocop:disable Rails/SaveBang
-      end
+      describe 'tmp files' do
+        let(:path) { File.join(Gitlab.config.backup.path, 'tmp') }
 
-      it 'does not attempt to set ACL' do
-        expect_any_instance_of(Fog::Collection).to receive(:create)
-          .with(hash_excluding(public: false))
-          .and_return(true)
+        before do
+          allow(FileUtils).to receive(:rm_rf).and_call_original
+        end
 
-        subject.upload
-      end
-    end
+        it 'removes backups/tmp dir' do
+          expect(FileUtils).to receive(:rm_rf).with(path).and_call_original
 
-    context 'with AzureRM provider' do
-      before do
-        stub_backup_setting(
-          upload: {
-            connection: {
-              provider: 'AzureRM',
-              azure_storage_account_name: 'test-access-id',
-              azure_storage_access_key: 'secret'
-            },
-            remote_directory: 'directory',
-            multipart_chunk_size: nil,
-            encryption: nil,
-            encryption_key: nil,
-            storage_class: nil
-          }
-        )
-      end
+          subject.restore
 
-      it 'loads the provider' do
-        expect { subject.upload }.not_to raise_error
+          expect(progress).to have_received(:print).with('Deleting backups/tmp ... ')
+        end
       end
     end
   end
diff --git a/spec/lib/backup/object_backup_spec.rb b/spec/lib/backup/object_backup_spec.rb
index 4d34dc0ade7..85658173b0e 100644
--- a/spec/lib/backup/object_backup_spec.rb
+++ b/spec/lib/backup/object_backup_spec.rb
@@ -21,7 +21,7 @@ RSpec.shared_examples 'backup object' do |setting|
       expect(backup).to receive(:run_pipeline!).with([%W(blabla-tar --exclude=lost+found --exclude=./tmp -C #{backup_path} -cf - .), 'gzip -c -1'], any_args).and_return([[true, true], ''])
       expect(backup).to receive(:pipeline_succeeded?).and_return(true)
 
-      backup.dump
+      backup.dump('backup_object.tar.gz')
     end
   end
 end
diff --git a/spec/lib/backup/pages_spec.rb b/spec/lib/backup/pages_spec.rb
index f9ee4bbdc41..095dda61cf4 100644
--- a/spec/lib/backup/pages_spec.rb
+++ b/spec/lib/backup/pages_spec.rb
@@ -19,7 +19,7 @@ RSpec.describe Backup::Pages do
       expect(subject).to receive(:tar).and_return('blabla-tar')
       expect(subject).to receive(:run_pipeline!).with([%w(blabla-tar --exclude=lost+found --exclude=./@pages.tmp -C /var/gitlab-pages -cf - .), 'gzip -c -1'], any_args).and_return([[true, true], ''])
       expect(subject).to receive(:pipeline_succeeded?).and_return(true)
-      subject.dump
+      subject.dump('pages.tar.gz')
     end
   end
 end
diff --git a/spec/lib/backup/repositories_spec.rb b/spec/lib/backup/repositories_spec.rb
index 0b29a25360d..db3e507596f 100644
--- a/spec/lib/backup/repositories_spec.rb
+++ b/spec/lib/backup/repositories_spec.rb
@@ -8,6 +8,7 @@ RSpec.describe Backup::Repositories do
   let(:strategy) { spy(:strategy, parallel_enqueue?: parallel_enqueue) }
   let(:max_concurrency) { 1 }
   let(:max_storage_concurrency) { 1 }
+  let(:destination) { 'repositories' }
 
   subject do
     described_class.new(
@@ -26,9 +27,9 @@ RSpec.describe Backup::Repositories do
         project_snippet = create(:project_snippet, :repository, project: project)
         personal_snippet = create(:personal_snippet, :repository, author: project.first_owner)
 
-        subject.dump
+        subject.dump(destination)
 
-        expect(strategy).to have_received(:start).with(:create)
+        expect(strategy).to have_received(:start).with(:create, destination)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::WIKI)
         expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::DESIGN)
@@ -54,38 +55,38 @@ RSpec.describe Backup::Repositories do
       it 'creates the expected number of threads' do
         expect(Thread).not_to receive(:new)
 
-        expect(strategy).to receive(:start).with(:create)
+        expect(strategy).to receive(:start).with(:create, destination)
         projects.each do |project|
           expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
         end
         expect(strategy).to receive(:finish!)
 
-        subject.dump
+        subject.dump(destination)
       end
 
       describe 'command failure' do
         it 'enqueue_project raises an error' do
           allow(strategy).to receive(:enqueue).with(anything, Gitlab::GlRepository::PROJECT).and_raise(IOError)
 
-          expect { subject.dump }.to raise_error(IOError)
+          expect { subject.dump(destination) }.to raise_error(IOError)
         end
 
         it 'project query raises an error' do
           allow(Project).to receive_message_chain(:includes, :find_each).and_raise(ActiveRecord::StatementTimeout)
 
-          expect { subject.dump }.to raise_error(ActiveRecord::StatementTimeout)
+          expect { subject.dump(destination) }.to raise_error(ActiveRecord::StatementTimeout)
         end
       end
 
       it 'avoids N+1 database queries' do
         control_count = ActiveRecord::QueryRecorder.new do
-          subject.dump
+          subject.dump(destination)
         end.count
 
         create_list(:project, 2, :repository)
 
         expect do
-          subject.dump
+          subject.dump(destination)
         end.not_to exceed_query_limit(control_count)
       end
     end
@@ -98,13 +99,13 @@ RSpec.describe Backup::Repositories do
       it 'enqueues all projects sequentially' do
         expect(Thread).not_to receive(:new)
 
-        expect(strategy).to receive(:start).with(:create)
+        expect(strategy).to receive(:start).with(:create, destination)
         projects.each do |project|
           expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
         end
         expect(strategy).to receive(:finish!)
 
-        subject.dump
+        subject.dump(destination)
       end
     end
 
@@ -122,13 +123,13 @@ RSpec.describe Backup::Repositories do
             .exactly(storage_keys.length * (max_storage_concurrency + 1)).times
             .and_call_original
 
-          expect(strategy).to receive(:start).with(:create)
+          expect(strategy).to receive(:start).with(:create, destination)
           projects.each do |project|
             expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
           end
           expect(strategy).to receive(:finish!)
 
-          subject.dump
+          subject.dump(destination)
         end
 
         context 'with extra max concurrency' do
@@ -139,13 +140,13 @@ RSpec.describe Backup::Repositories do
               .exactly(storage_keys.length * (max_storage_concurrency + 1)).times
               .and_call_original
 
-            expect(strategy).to receive(:start).with(:create)
+            expect(strategy).to receive(:start).with(:create, destination)
             projects.each do |project|
               expect(strategy).to receive(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
             end
             expect(strategy).to receive(:finish!)
 
-            subject.dump
+            subject.dump(destination)
           end
         end
 
@@ -153,33 +154,33 @@ RSpec.describe Backup::Repositories do
           it 'enqueue_project raises an error' do
             allow(strategy).to receive(:enqueue).and_raise(IOError)
 
-            expect { subject.dump }.to raise_error(IOError)
+            expect { subject.dump(destination) }.to raise_error(IOError)
           end
 
           it 'project query raises an error' do
             allow(Project).to receive_message_chain(:for_repository_storage, :includes, :find_each).and_raise(ActiveRecord::StatementTimeout)
 
-            expect { subject.dump }.to raise_error(ActiveRecord::StatementTimeout)
+            expect { subject.dump(destination) }.to raise_error(ActiveRecord::StatementTimeout)
           end
 
           context 'misconfigured storages' do
             let(:storage_keys) { %w[test_second_storage] }
 
             it 'raises an error' do
-              expect { subject.dump }.to raise_error(Backup::Error, 'repositories.storages in gitlab.yml is misconfigured')
+              expect { subject.dump(destination) }.to raise_error(Backup::Error, 'repositories.storages in gitlab.yml is misconfigured')
             end
           end
         end
 
         it 'avoids N+1 database queries' do
           control_count = ActiveRecord::QueryRecorder.new do
-            subject.dump
+            subject.dump(destination)
           end.count
 
           create_list(:project, 2, :repository)
 
           expect do
-            subject.dump
+            subject.dump(destination)
           end.not_to exceed_query_limit(control_count)
         end
       end
@@ -192,9 +193,9 @@ RSpec.describe Backup::Repositories do
     let_it_be(:project_snippet) { create(:project_snippet, project: project, author: project.first_owner) }
 
     it 'calls enqueue for each repository type', :aggregate_failures do
-      subject.restore
+      subject.restore(destination)
 
-      expect(strategy).to have_received(:start).with(:restore)
+      expect(strategy).to have_received(:start).with(:restore, destination)
       expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::PROJECT)
       expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::WIKI)
       expect(strategy).to have_received(:enqueue).with(project, Gitlab::GlRepository::DESIGN)
@@ -208,7 +209,7 @@ RSpec.describe Backup::Repositories do
         pool_repository = create(:pool_repository, :failed)
         pool_repository.delete_object_pool
 
-        subject.restore
+        subject.restore(destination)
 
         pool_repository.reload
         expect(pool_repository).not_to be_failed
@@ -219,7 +220,7 @@ RSpec.describe Backup::Repositories do
         pool_repository = create(:pool_repository, state: :obsolete)
         pool_repository.update_column(:source_project_id, nil)
 
-        subject.restore
+        subject.restore(destination)
 
         pool_repository.reload
         expect(pool_repository).to be_obsolete
@@ -236,14 +237,14 @@ RSpec.describe Backup::Repositories do
       end
 
       it 'shows the appropriate error' do
-        subject.restore
+        subject.restore(destination)
 
         expect(progress).to have_received(:puts).with("Snippet #{personal_snippet.full_path} can't be restored: Repository has more than one branch")
         expect(progress).to have_received(:puts).with("Snippet #{project_snippet.full_path} can't be restored: Repository has more than one branch")
       end
 
       it 'removes the snippets from the DB' do
-        expect { subject.restore }.to change(PersonalSnippet, :count).by(-1)
+        expect { subject.restore(destination) }.to change(PersonalSnippet, :count).by(-1)
           .and change(ProjectSnippet, :count).by(-1)
           .and change(SnippetRepository, :count).by(-2)
       end
@@ -253,7 +254,7 @@ RSpec.describe Backup::Repositories do
         shard_name = personal_snippet.repository.shard
         path = personal_snippet.disk_path + '.git'
 
-        subject.restore
+        subject.restore(destination)
 
         expect(gitlab_shell.repository_exists?(shard_name, path)).to eq false
       end
diff --git a/spec/lib/backup/task_spec.rb b/spec/lib/backup/task_spec.rb
new file mode 100644
index 00000000000..b0eb885d3f4
--- /dev/null
+++ b/spec/lib/backup/task_spec.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Backup::Task do
+  let(:progress) { StringIO.new }
+
+  subject { described_class.new(progress) }
+
+  describe '#human_name' do
+    it 'must be implemented by the subclass' do
+      expect { subject.human_name }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#dump' do
+    it 'must be implemented by the subclass' do
+      expect { subject.dump('some/path') }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#restore' do
+    it 'must be implemented by the subclass' do
+      expect { subject.restore('some/path') }.to raise_error(NotImplementedError)
+    end
+  end
+end
diff --git a/spec/lib/backup/uploads_spec.rb b/spec/lib/backup/uploads_spec.rb
index 25ad0c0d3f7..0cfc80a9cb9 100644
--- a/spec/lib/backup/uploads_spec.rb
+++ b/spec/lib/backup/uploads_spec.rb
@@ -19,7 +19,7 @@ RSpec.describe Backup::Uploads do
       expect(backup).to receive(:tar).and_return('blabla-tar')
       expect(backup).to receive(:run_pipeline!).with([%w(blabla-tar --exclude=lost+found --exclude=./tmp -C /var/uploads -cf - .), 'gzip -c -1'], any_args).and_return([[true, true], ''])
       expect(backup).to receive(:pipeline_succeeded?).and_return(true)
-      backup.dump
+      backup.dump('uploads.tar.gz')
     end
   end
 end