Merge branch 'jprovazn-fast-upload-delete' into 'master'

Use FastDestroy for deleting uploads

Closes #46069

See merge request gitlab-org/gitlab-ce!20977

6 files changed, 166 insertions, 7 deletions

diff --git a/app/models/concerns/fast_destroy_all.rb b/app/models/concerns/fast_destroy_all.rb
index 2bfa7da6c1c..1e3afd641ed 100644
--- a/app/models/concerns/fast_destroy_all.rb
+++ b/app/models/concerns/fast_destroy_all.rb
@@ -70,13 +70,14 @@ module FastDestroyAll
 
   module Helpers
     extend ActiveSupport::Concern
+    include AfterCommitQueue
 
     class_methods do
       ##
       # This method is to be defined on models which have fast destroyable models as children,
       # and let us avoid to use `dependent: :destroy` hook
-      def use_fast_destroy(relation)
-        before_destroy(prepend: true) do
+      def use_fast_destroy(relation, opts = {})
+        set_callback :destroy, :before, opts.merge(prepend: true) do
           perform_fast_destroy(public_send(relation)) # rubocop:disable GitlabSecurity/PublicSend
         end
       end
diff --git a/app/models/concerns/with_uploads.rb b/app/models/concerns/with_uploads.rb
index 2bdef2a40e4..d79c0eae77e 100644
--- a/app/models/concerns/with_uploads.rb
+++ b/app/models/concerns/with_uploads.rb
@@ -17,6 +17,8 @@
 
 module WithUploads
   extend ActiveSupport::Concern
+  include FastDestroyAll::Helpers
+  include FeatureGate
 
   # Currently there is no simple way how to select only not-mounted
   # uploads, it should be all FileUploaders so we select them by
@@ -25,21 +27,40 @@ module WithUploads
 
   included do
     has_many :uploads, as: :model
+    has_many :file_uploads, -> { where(uploader: FILE_UPLOADERS) }, class_name: 'Upload', as: :model
 
-    before_destroy :destroy_file_uploads
+    # TODO: when feature flag is removed, we can use just dependent: destroy
+    # option on :file_uploads
+    before_destroy :remove_file_uploads
+
+    use_fast_destroy :file_uploads, if: :fast_destroy_enabled?
+  end
+
+  def retrieve_upload(_identifier, paths)
+    uploads.find_by(path: paths)
   end
 
+  private
+
   # mounted uploads are deleted in carrierwave's after_commit hook,
   # but FileUploaders which are not mounted must be deleted explicitly and
   # it can not be done in after_commit because FileUploader requires loads
   # associated model on destroy (which is already deleted in after_commit)
-  def destroy_file_uploads
-    self.uploads.where(uploader: FILE_UPLOADERS).find_each do |upload|
+  def remove_file_uploads
+    fast_destroy_enabled? ? delete_uploads : destroy_uploads
+  end
+
+  def delete_uploads
+    file_uploads.delete_all(:delete_all)
+  end
+
+  def destroy_uploads
+    file_uploads.find_each do |upload|
       upload.destroy
     end
   end
 
-  def retrieve_upload(_identifier, paths)
-    uploads.find_by(path: paths)
+  def fast_destroy_enabled?
+    Feature.enabled?(:fast_destroy_uploads, self)
   end
 end
diff --git a/app/models/upload.rb b/app/models/upload.rb
index e01e9c6a4f0..20860f14b83 100644
--- a/app/models/upload.rb
+++ b/app/models/upload.rb
@@ -25,6 +25,25 @@ class Upload < ActiveRecord::Base
     Digest::SHA256.file(path).hexdigest
   end
 
+  class << self
+    ##
+    # FastDestroyAll concerns
+    def begin_fast_destroy
+      {
+        Uploads::Local => Uploads::Local.new.keys(with_files_stored_locally),
+        Uploads::Fog => Uploads::Fog.new.keys(with_files_stored_remotely)
+      }
+    end
+
+    ##
+    # FastDestroyAll concerns
+    def finalize_fast_destroy(keys)
+      keys.each do |store_class, paths|
+        store_class.new.delete_keys_async(paths)
+      end
+    end
+  end
+
   def absolute_path
     raise ObjectStorage::RemoteStoreError, "Remote object has no absolute path." unless local?
     return path unless relative_path?
diff --git a/app/models/uploads/base.rb b/app/models/uploads/base.rb
new file mode 100644
index 00000000000..f9814159958
--- /dev/null
+++ b/app/models/uploads/base.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Uploads
+  class Base
+    BATCH_SIZE = 100
+
+    attr_reader :logger
+
+    def initialize(logger: nil)
+      @logger ||= Rails.logger
+    end
+
+    def delete_keys_async(keys_to_delete)
+      keys_to_delete.each_slice(BATCH_SIZE) do |batch|
+        DeleteStoredFilesWorker.perform_async(self.class, batch)
+      end
+    end
+  end
+end
diff --git a/app/models/uploads/fog.rb b/app/models/uploads/fog.rb
new file mode 100644
index 00000000000..b44e273e9ab
--- /dev/null
+++ b/app/models/uploads/fog.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Uploads
+  class Fog < Base
+    include ::Gitlab::Utils::StrongMemoize
+
+    def available?
+      object_store.enabled
+    end
+
+    def keys(relation)
+      return [] unless available?
+
+      relation.pluck(:path)
+    end
+
+    def delete_keys(keys)
+      keys.each do |key|
+        connection.delete_object(bucket_name, key)
+      end
+    end
+
+    private
+
+    def object_store
+      Gitlab.config.uploads.object_store
+    end
+
+    def bucket_name
+      return unless available?
+
+      object_store.remote_directory
+    end
+
+    def connection
+      return unless available?
+
+      strong_memoize(:connection) do
+        ::Fog::Storage.new(object_store.connection.to_hash.deep_symbolize_keys)
+      end
+    end
+  end
+end
diff --git a/app/models/uploads/local.rb b/app/models/uploads/local.rb
new file mode 100644
index 00000000000..2901c33c359
--- /dev/null
+++ b/app/models/uploads/local.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Uploads
+  class Local < Base
+    def keys(relation)
+      relation.includes(:model).find_each.map(&:absolute_path)
+    end
+
+    def delete_keys(keys)
+      keys.each do |path|
+        delete_file(path)
+      end
+    end
+
+    private
+
+    def delete_file(path)
+      unless exists?(path)
+        logger.warn("File '#{path}' doesn't exist, skipping")
+        return
+      end
+
+      unless in_uploads?(path)
+        message = "Path '#{path}' is not in uploads dir, skipping"
+        logger.warn(message)
+        Gitlab::Sentry.track_exception(RuntimeError.new(message), extra: { uploads_dir: storage_dir })
+        return
+      end
+
+      FileUtils.rm(path)
+      delete_dir!(File.dirname(path))
+    end
+
+    def exists?(path)
+      path.present? && File.exist?(path)
+    end
+
+    def in_uploads?(path)
+      path.start_with?(storage_dir)
+    end
+
+    def delete_dir!(path)
+      Dir.rmdir(path)
+    rescue Errno::ENOENT
+      # Ignore: path does not exist
+    rescue Errno::ENOTDIR
+      # Ignore: path is not a dir
+    rescue Errno::ENOTEMPTY, Errno::EEXIST
+      # Ignore: dir is not empty
+    end
+
+    def storage_dir
+      @storage_dir ||= File.realpath(Gitlab.config.uploads.storage_path)
+    end
+  end
+end