Extract warnings for backup tasks

Previously the db task was unique in that it had special warnings.
Encode these warnings as part of the task interface so that warning
handling can be centralised. This means the db task can be handled in
the exact same way as every other task.

A spec had to be removed because all the methods that would output the
time have been stubbed. This had only worked before because db was
handled separately.

ee/spec/lib/ee/backup/repositories_spec.rb

@@ -5,6 +5,7 @@ require 'spec_helper'
 RSpec.describe Backup::Repositories do
   let(:progress) { spy(:stdout) }
   let(:strategy) { spy(:strategy) }
+  let(:destination) { 'repositories' }
 
   subject { described_class.new(progress, max_concurrency: 1, max_storage_concurrency: 1, strategy: strategy) }
 
@@ -16,9 +17,9 @@ RSpec.describe Backup::Repositories do
       it 'calls enqueue for each repository type', :aggregate_failures do
         create(:wiki_page, container: group)
 
-        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(group, Gitlab::GlRepository::WIKI)
         expect(strategy).to have_received(:finish!)
@@ -31,38 +32,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)
         groups.each do |group|
           expect(strategy).to receive(:enqueue).with(group, Gitlab::GlRepository::WIKI)
         end
         expect(strategy).to receive(:finish!)
 
-        subject.dump
+        subject.dump(destination)
       end
 
       describe 'command failure' do
         it 'enqueue_group raises an error' do
           allow(strategy).to receive(:enqueue).with(anything, Gitlab::GlRepository::WIKI).and_raise(IOError)
 
-          expect { subject.dump }.to raise_error(IOError)
+          expect { subject.dump(destination) }.to raise_error(IOError)
         end
 
         it 'group query raises an error' do
           allow(Group).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(:group, 2, :wiki_repo)
 
         expect do
-          subject.dump
+          subject.dump(destination)
         end.not_to exceed_query_limit(control_count)
       end
     end
@@ -73,9 +74,9 @@ RSpec.describe Backup::Repositories do
     let_it_be(:group) { create(:group) }
 
     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(group, Gitlab::GlRepository::WIKI)
       expect(strategy).to have_received(:finish!)

lib/backup/artifacts.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class Artifacts < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('artifacts', JobArtifactUploader.root, excludes: ['tmp'])
+      super(progress, 'artifacts', JobArtifactUploader.root, excludes: ['tmp'])
     end
 
+    override :human_name
     def human_name
       _('artifacts')
     end

lib/backup/builds.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class Builds < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('builds', Settings.gitlab_ci.builds_path)
+      super(progress, 'builds', Settings.gitlab_ci.builds_path)
     end
 
+    override :human_name
     def human_name
       _('builds')
     end

lib/backup/database.rb

@@ -3,10 +3,10 @@
 require 'yaml'
 
 module Backup
-  class Database
+  class Database < Task
+    extend ::Gitlab::Utils::Override
     include Backup::Helper
-    attr_reader :progress
-    attr_reader :config, :db_file_name
+    attr_reader :force, :config
 
     IGNORED_ERRORS = [
       # Ignore warnings
@@ -18,13 +18,14 @@ module Backup
     ].freeze
     IGNORED_ERRORS_REGEXP = Regexp.union(IGNORED_ERRORS).freeze
 
-    def initialize(progress, filename: nil)
-      @progress = progress
+    def initialize(progress, force:)
+      super(progress)
       @config = ActiveRecord::Base.configurations.find_db_config(Rails.env).configuration_hash
-      @db_file_name = filename || File.join(Gitlab.config.backup.path, 'db', 'database.sql.gz')
+      @force = force
     end
 
-    def dump
+    override :dump
+    def dump(db_file_name)
       FileUtils.mkdir_p(File.dirname(db_file_name))
       FileUtils.rm_f(db_file_name)
       compress_rd, compress_wr = IO.pipe
@@ -64,12 +65,24 @@ module Backup
       raise DatabaseBackupError.new(config, db_file_name) unless success
     end
 
-    def restore
+    override :restore
+    def restore(db_file_name)
+      unless force
+        progress.puts 'Removing all tables. Press `Ctrl-C` within 5 seconds to abort'.color(:yellow)
+        sleep(5)
+      end
+
+      # Drop all tables Load the schema to ensure we don't have any newer tables
+      # hanging out from a failed upgrade
+      puts_time 'Cleaning the database ... '.color(:blue)
+      Rake::Task['gitlab:db:drop_tables'].invoke
+      puts_time 'done'.color(:green)
+
       decompress_rd, decompress_wr = IO.pipe
       decompress_pid = spawn(*%w(gzip -cd), out: decompress_wr, in: db_file_name)
       decompress_wr.close
 
-      status, errors =
+      status, @errors =
         case config[:adapter]
         when "postgresql" then
           progress.print "Restoring PostgreSQL database #{database} ... "
@@ -81,33 +94,47 @@ module Backup
       Process.waitpid(decompress_pid)
       success = $?.success? && status.success?
 
-      if errors.present?
+      if @errors.present?
         progress.print "------ BEGIN ERRORS -----\n".color(:yellow)
-        progress.print errors.join.color(:yellow)
+        progress.print @errors.join.color(:yellow)
         progress.print "------ END ERRORS -------\n".color(:yellow)
       end
 
       report_success(success)
       raise Backup::Error, 'Restore failed' unless success
+    end
 
-      if errors.present?
-        warning = <<~MSG
-            There were errors in restoring the schema. This may cause
-            issues if this results in missing indexes, constraints, or
-            columns. Please record the errors above and contact GitLab
-            Support if you have questions:
-            https://about.gitlab.com/support/
-        MSG
-
-        warn warning.color(:red)
-        Gitlab::TaskHelpers.ask_to_continue
-      end
+    override :pre_restore_warning
+    def pre_restore_warning
+      return if force
+
+      <<-MSG.strip_heredoc
+        Be sure to stop Puma, Sidekiq, and any other process that
+        connects to the database before proceeding. For Omnibus
+        installs, see the following link for more information:
+        https://docs.gitlab.com/ee/raketasks/backup_restore.html#restore-for-omnibus-gitlab-installations
+
+        Before restoring the database, we will remove all existing
+        tables to avoid future upgrade problems. Be aware that if you have
+        custom tables in the GitLab database these tables and all data will be
+        removed.
+      MSG
     end
 
-    def enabled
-      true
+    override :post_restore_warning
+    def post_restore_warning
+      return unless @errors.present?
+
+      <<-MSG.strip_heredoc
+        There were errors in restoring the schema. This may cause
+        issues if this results in missing indexes, constraints, or
+        columns. Please record the errors above and contact GitLab
+        Support if you have questions:
+        https://about.gitlab.com/support/
+      MSG
     end
 
+    override :human_name
     def human_name
       _('database')
     end

lib/backup/files.rb

 # frozen_string_literal: true
 
 require 'open3'
-require_relative 'helper'
 
 module Backup
-  class Files
+  class Files < Task
+    extend ::Gitlab::Utils::Override
     include Backup::Helper
 
     DEFAULT_EXCLUDE = 'lost+found'
 
-    attr_reader :name, :backup_tarball, :excludes
+    attr_reader :name, :excludes
+
+    def initialize(progress, name, app_files_dir, excludes: [])
+      super(progress)
 
-    def initialize(name, app_files_dir, excludes: [])
       @name = name
       @app_files_dir = app_files_dir
-      @backup_tarball = File.join(Gitlab.config.backup.path, name + '.tar.gz')
       @excludes = [DEFAULT_EXCLUDE].concat(excludes)
     end
 
     # Copy files from public/files to backup/files
-    def dump
+    override :dump
+    def dump(backup_tarball)
       FileUtils.mkdir_p(Gitlab.config.backup.path)
       FileUtils.rm_f(backup_tarball)
 
@@ -35,7 +37,7 @@ module Backup
 
         unless status == 0
           puts output
-          raise_custom_error
+          raise_custom_error(backup_tarball)
         end
 
         tar_cmd = [tar, exclude_dirs(:tar), %W[-C #{backup_files_realpath} -cf - .]].flatten
@@ -47,11 +49,12 @@ module Backup
       end
 
       unless pipeline_succeeded?(tar_status: status_list[0], gzip_status: status_list[1], output: output)
-        raise_custom_error
+        raise_custom_error(backup_tarball)
       end
     end
 
-    def restore
+    override :restore
+    def restore(backup_tarball)
       backup_existing_files_dir
 
       cmd_list = [%w[gzip -cd], %W[#{tar} --unlink-first --recursive-unlink -C #{app_files_realpath} -xf -]]
@@ -61,10 +64,6 @@ module Backup
       end
     end
 
-    def enabled
-      true
-    end
-
     def tar
       if system(*%w[gtar --version], out: '/dev/null')
         # It looks like we can get GNU tar by running 'gtar'
@@ -146,7 +145,7 @@ module Backup
       end
     end
 
-    def raise_custom_error
+    def raise_custom_error(backup_tarball)
       raise FileBackupError.new(app_files_realpath, backup_tarball)
     end
 

lib/backup/gitaly_backup.rb

@@ -15,7 +15,7 @@ module Backup
       @storage_parallelism = storage_parallelism
     end
 
-    def start(type)
+    def start(type, backup_repos_path)
       raise Error, 'already started' if started?
 
       command = case type
@@ -93,10 +93,6 @@ module Backup
       @thread.present?
     end
 
-    def backup_repos_path
-      File.absolute_path(File.join(Gitlab.config.backup.path, 'repositories'))
-    end
-
     def bin_path
       File.absolute_path(Gitlab.config.backup.gitaly_backup_path)
     end

lib/backup/gitaly_rpc_backup.rb

@@ -7,10 +7,11 @@ module Backup
       @progress = progress
     end
 
-    def start(type)
+    def start(type, backup_repos_path)
       raise Error, 'already started' if @type
 
       @type = type
+      @backup_repos_path = backup_repos_path
       case type
       when :create
         FileUtils.rm_rf(backup_repos_path)
@@ -31,7 +32,7 @@ module Backup
       backup_restore = BackupRestore.new(
         progress,
         repository_type.repository_for(container),
-        backup_repos_path
+        @backup_repos_path
       )
 
       case @type
@@ -52,10 +53,6 @@ module Backup
 
     attr_reader :progress
 
-    def backup_repos_path
-      @backup_repos_path ||= File.join(Gitlab.config.backup.path, 'repositories')
-    end
-
     class BackupRestore
       attr_accessor :progress, :repository, :backup_repos_path
 

lib/backup/lfs.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class Lfs < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('lfs', Settings.lfs.storage_path)
+      super(progress, 'lfs', Settings.lfs.storage_path)
     end
 
+    override :human_name
     def human_name
       _('lfs objects')
     end

lib/backup/manager.rb

@@ -2,37 +2,77 @@
 
 module Backup
   class Manager
-    ARCHIVES_TO_BACKUP = %w[uploads builds artifacts pages lfs terraform_state registry packages].freeze
-    FOLDERS_TO_BACKUP = %w[repositories db].freeze
     FILE_NAME_SUFFIX = '_gitlab_backup.tar'
+    MANIFEST_NAME = 'backup_information.yml'
+
+    TaskDefinition = Struct.new(
+      :destination_path, # Where the task should put its backup file/dir.
+      :destination_optional, # `true` if the destination might not exist on a successful backup.
+      :cleanup_path, # Path to remove after a successful backup. Uses `destination_path` when not specified.
+      :task,
+      keyword_init: true
+    )
 
     attr_reader :progress
 
-    def initialize(progress)
+    def initialize(progress, definitions: nil)
       @progress = progress
 
       max_concurrency = ENV.fetch('GITLAB_BACKUP_MAX_CONCURRENCY', 1).to_i
       max_storage_concurrency = ENV.fetch('GITLAB_BACKUP_MAX_STORAGE_CONCURRENCY', 1).to_i
-
-      @tasks = {
-        'db' => Database.new(progress),
-        'repositories' => Repositories.new(progress,
-                                           strategy: repository_backup_strategy,
-                                           max_concurrency: max_concurrency,
-                                           max_storage_concurrency: max_storage_concurrency),
-        'uploads' => Uploads.new(progress),
-        'builds' => Builds.new(progress),
-        'artifacts' => Artifacts.new(progress),
-        'pages' => Pages.new(progress),
-        'lfs' => Lfs.new(progress),
-        'terraform_state' => TerraformState.new(progress),
-        'registry' => Registry.new(progress),
-        'packages' => Packages.new(progress)
+      force = ENV['force'] == 'yes'
+
+      @definitions = definitions || {
+        'db' => TaskDefinition.new(
+          destination_path: 'db/database.sql.gz',
+          cleanup_path: 'db',
+          task: Database.new(progress, force: force)
+        ),
+        'repositories' => TaskDefinition.new(
+          destination_path: 'repositories',
+          destination_optional: true,
+          task: Repositories.new(progress,
+                                 strategy: repository_backup_strategy,
+                                 max_concurrency: max_concurrency,
+                                 max_storage_concurrency: max_storage_concurrency)
+        ),
+        'uploads' => TaskDefinition.new(
+          destination_path: 'uploads.tar.gz',
+          task: Uploads.new(progress)
+        ),
+        'builds' => TaskDefinition.new(
+          destination_path: 'builds.tar.gz',
+          task: Builds.new(progress)
+        ),
+        'artifacts' => TaskDefinition.new(
+          destination_path: 'artifacts.tar.gz',
+          task: Artifacts.new(progress)
+        ),
+        'pages' => TaskDefinition.new(
+          destination_path: 'pages.tar.gz',
+          task: Pages.new(progress)
+        ),
+        'lfs' => TaskDefinition.new(
+          destination_path: 'lfs.tar.gz',
+          task: Lfs.new(progress)
+        ),
+        'terraform_state' => TaskDefinition.new(
+          destination_path: 'terraform_state.tar.gz',
+          task: TerraformState.new(progress)
+        ),
+        'registry' => TaskDefinition.new(
+          destination_path: 'registry.tar.gz',
+          task: Registry.new(progress)
+        ),
+        'packages' => TaskDefinition.new(
+          destination_path: 'packages.tar.gz',
+          task: Packages.new(progress)
+        )
       }.freeze
     end
 
     def create
-      @tasks.keys.each do |task_name|
+      @definitions.keys.each do |task_name|
         run_create_task(task_name)
       end
 
@@ -54,11 +94,11 @@ module Backup
     end
 
     def run_create_task(task_name)
-      task = @tasks[task_name]
+      definition = @definitions[task_name]
 
-      puts_time "Dumping #{task.human_name} ... ".color(:blue)
+      puts_time "Dumping #{definition.task.human_name} ... ".color(:blue)
 
-      unless task.enabled
+      unless definition.task.enabled
         puts_time "[DISABLED]".color(:cyan)
         return
       end
@@ -68,7 +108,8 @@ module Backup
         return
       end
 
-      task.dump
+      definition.task.dump(File.join(Gitlab.config.backup.path, definition.destination_path))
+
       puts_time "done".color(:green)
 
     rescue Backup::DatabaseBackupError, Backup::FileBackupError => e
@@ -79,39 +120,7 @@ module Backup
       cleanup_required = unpack
       verify_backup_version
 
-      unless skipped?('db')
-        begin
-          unless ENV['force'] == 'yes'
-            warning = <<-MSG.strip_heredoc
-              Be sure to stop Puma, Sidekiq, and any other process that
-              connects to the database before proceeding. For Omnibus
-              installs, see the following link for more information:
-              https://docs.gitlab.com/ee/raketasks/backup_restore.html#restore-for-omnibus-gitlab-installations
-
-              Before restoring the database, we will remove all existing
-              tables to avoid future upgrade problems. Be aware that if you have
-              custom tables in the GitLab database these tables and all data will be
-              removed.
-            MSG
-            puts warning.color(:red)
-            Gitlab::TaskHelpers.ask_to_continue
-            puts 'Removing all tables. Press `Ctrl-C` within 5 seconds to abort'.color(:yellow)
-            sleep(5)
-          end
-
-          # Drop all tables Load the schema to ensure we don't have any newer tables
-          # hanging out from a failed upgrade
-          puts_time 'Cleaning the database ... '.color(:blue)
-          Rake::Task['gitlab:db:drop_tables'].invoke
-          puts_time 'done'.color(:green)
-          run_restore_task('db')
-        rescue Gitlab::TaskAbortedByUserError
-          puts "Quitting...".color(:red)
-          exit 1
-        end
-      end
-
-      @tasks.except('db').keys.each do |task_name|
+      @definitions.keys.each do |task_name|
         run_restore_task(task_name) unless skipped?(task_name)
       end
 
@@ -130,25 +139,44 @@ module Backup
     end
 
     def run_restore_task(task_name)
-      task = @tasks[task_name]
+      definition = @definitions[task_name]
 
-      puts_time "Restoring #{task.human_name} ... ".color(:blue)
+      puts_time "Restoring #{definition.task.human_name} ... ".color(:blue)
 
-      unless task.enabled
+      unless definition.task.enabled
         puts_time "[DISABLED]".color(:cyan)
         return
       end
 
-      task.restore
+      warning = definition.task.pre_restore_warning
+      if warning.present?
+        puts_time warning.color(:red)
+        Gitlab::TaskHelpers.ask_to_continue
+      end
+
+      definition.task.restore(File.join(Gitlab.config.backup.path, definition.destination_path))
+
       puts_time "done".color(:green)
+
+      warning = definition.task.post_restore_warning
+      if warning.present?
+        puts_time warning.color(:red)
+        Gitlab::TaskHelpers.ask_to_continue
+      end
+
+    rescue Gitlab::TaskAbortedByUserError
+      puts_time "Quitting...".color(:red)
+      exit 1
     end
 
+    private
+
     def write_info
       # Make sure there is a connection
       ActiveRecord::Base.connection.reconnect!
 
       Dir.chdir(backup_path) do
-        File.open("#{backup_path}/backup_information.yml", "w+") do |file|
+        File.open("#{backup_path}/#{MANIFEST_NAME}", "w+") do |file|
           file << backup_information.to_yaml.gsub(/^---\n/, '')
         end
       end
@@ -182,8 +210,11 @@ module Backup
       upload = directory.files.create(create_attributes)
 
       if upload
-        progress.puts "done".color(:green)
-        upload
+        if upload.respond_to?(:encryption) && upload.encryption
+          progress.puts "done (encrypted with #{upload.encryption})".color(:green)
+        else
+          progress.puts "done".color(:green)
+        end
       else
         puts "uploading backup to #{remote_directory} failed".color(:red)
         raise Backup::Error, 'Backup failed'
@@ -193,18 +224,19 @@ module Backup
     def cleanup
       progress.print "Deleting tmp directories ... "
 
-      backup_contents.each do |dir|
-        next unless File.exist?(File.join(backup_path, dir))
-
-        if FileUtils.rm_rf(File.join(backup_path, dir))
-          progress.puts "done".color(:green)
-        else
-          puts "deleting tmp directory '#{dir}' failed".color(:red)
-          raise Backup::Error, 'Backup failed'
-        end
+      remove_backup_path(MANIFEST_NAME)
+      @definitions.each do |_, definition|
+        remove_backup_path(definition.cleanup_path || definition.destination_path)
       end
     end
 
+    def remove_backup_path(path)
+      return unless File.exist?(File.join(backup_path, path))
+
+      FileUtils.rm_rf(File.join(backup_path, path))
+      progress.puts "done".color(:green)
+    end
+
     def remove_tmp
       # delete tmp inside backups
       progress.print "Deleting backups/tmp ... "
@@ -322,10 +354,8 @@ module Backup
       settings[:skipped] && settings[:skipped].include?(item) || !enabled_task?(item)
     end
 
-    private
-
     def enabled_task?(task_name)
-      @tasks[task_name].enabled
+      @definitions[task_name].task.enabled
     end
 
     def backup_file?(file)
@@ -333,7 +363,7 @@ module Backup
     end
 
     def non_tarred_backup?
-      File.exist?(File.join(backup_path, 'backup_information.yml'))
+      File.exist?(File.join(backup_path, MANIFEST_NAME))
     end
 
     def backup_path
@@ -380,19 +410,14 @@ module Backup
     end
 
     def backup_contents
-      folders_to_backup + archives_to_backup + ["backup_information.yml"]
-    end
-
-    def archives_to_backup
-      ARCHIVES_TO_BACKUP.map { |name| (name + ".tar.gz") unless skipped?(name) }.compact
-    end
-
-    def folders_to_backup
-      FOLDERS_TO_BACKUP.select { |name| !skipped?(name) && Dir.exist?(File.join(backup_path, name)) }
+      [MANIFEST_NAME] + @definitions.reject do |name, definition|
+        skipped?(name) ||
+          (definition.destination_optional && !File.exist?(File.join(backup_path, definition.destination_path)))
+      end.values.map(&:destination_path)
     end
 
     def settings
-      @settings ||= YAML.load_file("backup_information.yml")
+      @settings ||= YAML.load_file(MANIFEST_NAME)
     end
 
     def tar_file

lib/backup/packages.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class Packages < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('packages', Settings.packages.storage_path, excludes: ['tmp'])
+      super(progress, 'packages', Settings.packages.storage_path, excludes: ['tmp'])
     end
 
+    override :human_name
     def human_name
       _('packages')
     end

lib/backup/pages.rb

@@ -6,14 +6,11 @@ module Backup
     # if some of these files are still there, we don't need them in the backup
     LEGACY_PAGES_TMP_PATH = '@pages.tmp'
 
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('pages', Gitlab.config.pages.path, excludes: [LEGACY_PAGES_TMP_PATH])
+      super(progress, 'pages', Gitlab.config.pages.path, excludes: [LEGACY_PAGES_TMP_PATH])
     end
 
+    override :human_name
     def human_name
       _('pages')
     end

lib/backup/registry.rb

@@ -2,18 +2,16 @@
 
 module Backup
   class Registry < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('registry', Settings.registry.path)
+      super(progress, 'registry', Settings.registry.path)
     end
 
+    override :human_name
     def human_name
       _('container registry images')
     end
 
+    override :enabled
     def enabled
       Gitlab.config.registry.enabled
     end

lib/backup/repositories.rb

@@ -3,16 +3,20 @@
 require 'yaml'
 
 module Backup
-  class Repositories
+  class Repositories < Task
+    extend ::Gitlab::Utils::Override
+
     def initialize(progress, strategy:, max_concurrency: 1, max_storage_concurrency: 1)
-      @progress = progress
+      super(progress)
+
       @strategy = strategy
       @max_concurrency = max_concurrency
       @max_storage_concurrency = max_storage_concurrency
     end
 
-    def dump
-      strategy.start(:create)
+    override :dump
+    def dump(path)
+      strategy.start(:create, path)
 
       # gitaly-backup is designed to handle concurrency on its own. So we want
       # to avoid entering the buggy concurrency code here when gitaly-backup
@@ -50,8 +54,9 @@ module Backup
       strategy.finish!
     end
 
-    def restore
-      strategy.start(:restore)
+    override :restore
+    def restore(path)
+      strategy.start(:restore, path)
       enqueue_consecutive
 
     ensure
@@ -61,17 +66,14 @@ module Backup
       restore_object_pools
     end
 
-    def enabled
-      true
-    end
-
+    override :human_name
     def human_name
       _('repositories')
     end
 
     private
 
-    attr_reader :progress, :strategy, :max_concurrency, :max_storage_concurrency
+    attr_reader :strategy, :max_concurrency, :max_storage_concurrency
 
     def check_valid_storages!
       repository_storage_klasses.each do |klass|

lib/backup/task.rb

+# frozen_string_literal: true
+
+module Backup
+  class Task
+    def initialize(progress)
+      @progress = progress
+    end
+
+    # human readable task name used for logging
+    def human_name
+      raise NotImplementedError
+    end
+
+    # dump task backup to `path`
+    def dump(path)
+      raise NotImplementedError
+    end
+
+    # restore task backup from `path`
+    def restore(path)
+      raise NotImplementedError
+    end
+
+    # a string returned here will be displayed to the user before calling #restore
+    def pre_restore_warning
+    end
+
+    # a string returned here will be displayed to the user after calling #restore
+    def post_restore_warning
+    end
+
+    # returns `true` when the task should be used
+    def enabled
+      true
+    end
+
+    private
+
+    attr_reader :progress
+
+    def puts_time(msg)
+      progress.puts "#{Time.zone.now} -- #{msg}"
+      Gitlab::BackupLogger.info(message: "#{Rainbow.uncolor(msg)}")
+    end
+  end
+end

lib/backup/terraform_state.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class TerraformState < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('terraform_state', Settings.terraform_state.storage_path, excludes: ['tmp'])
+      super(progress, 'terraform_state', Settings.terraform_state.storage_path, excludes: ['tmp'])
     end
 
+    override :human_name
     def human_name
       _('terraform states')
     end

lib/backup/uploads.rb

@@ -2,14 +2,11 @@
 
 module Backup
   class Uploads < Backup::Files
-    attr_reader :progress
-
     def initialize(progress)
-      @progress = progress
-
-      super('uploads', File.join(Gitlab.config.uploads.storage_path, "uploads"), excludes: ['tmp'])
+      super(progress, 'uploads', File.join(Gitlab.config.uploads.storage_path, "uploads"), excludes: ['tmp'])
     end
 
+    override :human_name
     def human_name
       _('uploads')
     end

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

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"))

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(

spec/lib/backup/gitaly_backup_spec.rb

@@ -5,6 +5,7 @@ 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(:progress) do
     Tempfile.new('progress').tap do |progress|
@@ -27,7 +28,7 @@ RSpec.describe Backup::GitalyBackup 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
 
@@ -42,7 +43,7 @@ RSpec.describe Backup::GitalyBackup do
 
         expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything).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,11 +51,11 @@ 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 + '.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 'parallel option set' do
@@ -63,7 +64,7 @@ RSpec.describe Backup::GitalyBackup do
         it 'passes parallel option through' do
           expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel', '3').and_call_original
 
-          subject.start(:create)
+          subject.start(:create, destination)
           subject.finish!
         end
       end
@@ -74,7 +75,7 @@ RSpec.describe Backup::GitalyBackup do
         it 'passes parallel option through' do
           expect(Open3).to receive(:popen2).with(expected_env, anything, 'create', '-path', anything, '-parallel-storage', '3').and_call_original
 
-          subject.start(:create)
+          subject.start(:create, destination)
           subject.finish!
         end
       end
@@ -82,7 +83,7 @@ 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
     end
@@ -114,7 +115,7 @@ RSpec.describe Backup::GitalyBackup do
       it 'passes through SSL envs' do
         expect(Open3).to receive(:popen2).with(ssl_env, anything, 'create', '-path', anything).and_call_original
 
-        subject.start(:create)
+        subject.start(:create, destination)
         subject.finish!
       end
     end
@@ -139,7 +140,7 @@ RSpec.describe Backup::GitalyBackup do
 
       expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything).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)
@@ -162,7 +163,7 @@ RSpec.describe Backup::GitalyBackup do
       it 'passes parallel option through' do
         expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel', '3').and_call_original
 
-        subject.start(:restore)
+        subject.start(:restore, destination)
         subject.finish!
       end
     end
@@ -173,7 +174,7 @@ RSpec.describe Backup::GitalyBackup do
       it 'passes parallel option through' do
         expect(Open3).to receive(:popen2).with(expected_env, anything, 'restore', '-path', anything, '-parallel-storage', '3').and_call_original
 
-        subject.start(:restore)
+        subject.start(:restore, destination)
         subject.finish!
       end
     end
@@ -181,7 +182,7 @@ 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(:restore)
+      subject.start(:restore, destination)
       expect { subject.finish! }.to raise_error(::Backup::Error, 'gitaly-backup exit status 1')
     end
   end

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!
 

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

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('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,27 @@ 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(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 +189,400 @@ 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)
+        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 '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
+
+        it 'does not remove files that are not old enough' do
+          expect(FileUtils).not_to have_received(:rm).with(files[0])
+        end
+
+        it 'does not remove non-matching files' do
+          expect(FileUtils).not_to have_received(:rm).with(files[9])
+        end
+
+        it 'prints a done message' do
+          expect(progress).to have_received(:puts).with('done. (8 removed)')
+        end
       end
 
-      it 'prints a done message' do
-        expect(progress).to have_received(:puts).with('done. (0 removed)')
+      context 'when removing a file fails' do
+        let(:file) { files[1] }
+        let(:message) { "Permission denied @ unlink_internal - #{file}" }
+
+        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)
+
+          subject.create # rubocop:disable Rails/SaveBang
+        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 'sets the correct removed count' do
+          expect(progress).to have_received(:puts).with('done. (7 removed)')
+        end
+
+        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 keep_time is set to remove files' do
+    describe 'cloud storage' do
+      let(:backup_file) { Tempfile.new('backup', Gitlab.config.backup.path) }
+      let(:backup_filename) { File.basename(backup_file.path) }
+
       before do
-        # Set to 1 second
-        allow(Gitlab.config.backup).to receive(:keep_time).and_return(1)
+        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 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
+        Fog.mock!
 
-      it 'removes matching files with a human-readable versioned timestamp with tagged EE' do
-        expect(FileUtils).to have_received(:rm).with(files[4])
+        # 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 '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
+      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
 
-      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 'adds the DIRECTORY environment variable if present' do
+          stub_env('DIRECTORY', 'daily')
 
-      it 'does not remove non-matching files' do
-        expect(FileUtils).not_to have_received(:rm).with(files[9])
-      end
+          expect_any_instance_of(Fog::Collection).to receive(:create)
+            .with(hash_including(key: "daily/#{backup_filename}", public: false))
+            .and_call_original
 
-      it 'prints a done message' do
-        expect(progress).to have_received(:puts).with('done. (8 removed)')
+          subject.create # rubocop:disable Rails/SaveBang
+        end
       end
-    end
 
-    context 'when removing a file fails' do
-      let(:file) { files[1] }
-      let(:message) { "Permission denied @ unlink_internal - #{file}" }
+      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
 
-      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)
+        context 'with SSE-S3 without using storage_options' do
+          let(:encryption) { 'AES256' }
 
-        subject.remove_old
-      end
+          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 'sets encryption attributes' do
+            subject.create # rubocop:disable Rails/SaveBang
 
-      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])
+            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
 
-      it 'sets the correct removed count' do
-        expect(progress).to have_received(:puts).with('done. (7 removed)')
+      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 not attempt to set ACL' do
+          expect_any_instance_of(Fog::Collection).to receive(:create)
+            .with(hash_excluding(public: false))
+            .and_call_original
+
+          subject.create # rubocop:disable Rails/SaveBang
+        end
       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 '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 'verify_backup_version' do
-    context 'on version mismatch' do
-      let(:gitlab_version) { Gitlab::VERSION }
-
-      it 'stops the process' do
-        allow(YAML).to receive(:load_file)
-          .and_return({ gitlab_version: "not #{gitlab_version}" })
-
-        expect { subject.verify_backup_version }.to raise_error SystemExit
-      end
+  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
 
-    context 'on version match' do
-      let(:gitlab_version) { Gitlab::VERSION }
+    let(:gitlab_version) { Gitlab::VERSION }
+    let(:backup_information) do
+      {
+        backup_created_at: Time.zone.parse('2019-01-01'),
+        gitlab_version: gitlab_version
+      }
+    end
 
-      it 'does nothing' do
-        allow(YAML).to receive(:load_file)
-          .and_return({ gitlab_version: "#{gitlab_version}" })
+    before do
+      Rake.application.rake_require 'tasks/gitlab/shell'
+      Rake.application.rake_require 'tasks/cache'
 
-        expect { subject.verify_backup_version }.not_to raise_error
-      end
+      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).and_return(backup_information)
+      allow(Rake::Task['gitlab:shell:setup']).to receive(:invoke)
+      allow(Rake::Task['cache:clear']).to receive(:invoke)
     end
-  end
 
-  describe '#unpack' do
     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 +599,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 +624,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 +640,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 +696,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

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

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

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

spec/lib/backup/task_spec.rb

+# 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

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

spec/tasks/gitlab/backup_rake_spec.rb

@@ -72,7 +72,6 @@ RSpec.describe 'gitlab:app namespace rake task', :delete do
         before do
           allow(YAML).to receive(:load_file)
             .and_return({ gitlab_version: gitlab_version })
-          expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
           expect_next_instance_of(::Backup::Manager) do |instance|
             backup_types.each do |subtask|
               expect(instance).to receive(:run_restore_task).with(subtask).ordered
@@ -85,10 +84,6 @@ RSpec.describe 'gitlab:app namespace rake task', :delete do
         it 'invokes restoration on match' do
           expect { run_rake_task('gitlab:backup:restore') }.to output.to_stdout_from_any_process
         end
-
-        it 'prints timestamps on messages' do
-          expect { run_rake_task('gitlab:backup:restore') }.to output(/.*\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\s[-+]\d{4}\s--\s.*/).to_stdout_from_any_process
-        end
       end
     end
 
@@ -131,8 +126,6 @@ RSpec.describe 'gitlab:app namespace rake task', :delete do
         allow(YAML).to receive(:load_file)
           .and_return({ gitlab_version: Gitlab::VERSION })
 
-        expect(Rake::Task['gitlab:db:drop_tables']).to receive(:invoke)
-
         expect_next_instance_of(::Backup::Manager) do |instance|
           backup_types.each do |subtask|
             expect(instance).to receive(:run_restore_task).with(subtask).ordered
@@ -486,7 +479,6 @@ RSpec.describe 'gitlab:app namespace rake task', :delete do
       allow(Rake::Task['gitlab:shell:setup'])
         .to receive(:invoke).and_return(true)
 
-      expect(Rake::Task['gitlab:db:drop_tables']).to receive :invoke
       expect_next_instance_of(::Backup::Manager) do |instance|
         (backup_types - %w{repositories uploads}).each do |subtask|
           expect(instance).to receive(:run_restore_task).with(subtask).ordered
@@ -531,7 +523,6 @@ RSpec.describe 'gitlab:app namespace rake task', :delete do
       allow(Rake::Task['gitlab:shell:setup'])
         .to receive(:invoke).and_return(true)
 
-      expect(Rake::Task['gitlab:db:drop_tables']).to receive :invoke
       expect_next_instance_of(::Backup::Manager) do |instance|
         backup_types.each do |subtask|
           expect(instance).to receive(:run_restore_task).with(subtask).ordered