Extract a Git::{Base,Tag,Branch}HooksService

5 files changed, 310 insertions, 229 deletions

diff --git a/app/services/git/base_hooks_service.rb b/app/services/git/base_hooks_service.rb
new file mode 100644
index 00000000000..e0dccb8716a
--- /dev/null
+++ b/app/services/git/base_hooks_service.rb
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Git
+  class BaseHooksService < ::BaseService
+    include Gitlab::Utils::StrongMemoize
+
+    # The N most recent commits to process in a single push payload.
+    PROCESS_COMMIT_LIMIT = 100
+
+    def execute
+      project.repository.after_create if project.empty_repo?
+
+      create_events
+      create_pipelines
+      execute_project_hooks
+
+      # Not a hook, but it needs access to the list of changed commits
+      enqueue_invalidate_cache
+
+      push_data
+    end
+
+    private
+
+    def hook_name
+      raise NotImplementedError, "Please implement #{self.class}##{__method__}"
+    end
+
+    def commits
+      raise NotImplementedError, "Please implement #{self.class}##{__method__}"
+    end
+
+    def limited_commits
+      commits.last(PROCESS_COMMIT_LIMIT)
+    end
+
+    def commits_count
+      commits.count
+    end
+
+    def event_message
+      nil
+    end
+
+    def invalidated_file_types
+      []
+    end
+
+    def create_events
+      EventCreateService.new.push(project, current_user, push_data)
+    end
+
+    def create_pipelines
+      Ci::CreatePipelineService
+        .new(project, current_user, push_data)
+        .execute(:push, pipeline_options)
+    end
+
+    def execute_project_hooks
+      project.execute_hooks(push_data, hook_name)
+      project.execute_services(push_data, hook_name)
+    end
+
+    def enqueue_invalidate_cache
+      ProjectCacheWorker.perform_async(
+        project.id,
+        invalidated_file_types,
+        [:commit_count, :repository_size]
+      )
+    end
+
+    def push_data
+      @push_data ||= Gitlab::DataBuilder::Push.build(
+        project,
+        current_user,
+        params[:oldrev],
+        params[:newrev],
+        params[:ref],
+        limited_commits,
+        event_message,
+        commits_count: commits_count,
+        push_options: params[:push_options] || []
+      )
+
+      # Dependent code may modify the push data, so return a duplicate each time
+      @push_data.dup
+    end
+
+    # to be overridden in EE
+    def pipeline_options
+      {}
+    end
+  end
+end
diff --git a/app/services/git/branch_hooks_service.rb b/app/services/git/branch_hooks_service.rb
new file mode 100644
index 00000000000..d21a6bb1b9a
--- /dev/null
+++ b/app/services/git/branch_hooks_service.rb
@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Git
+  class BranchHooksService < ::Git::BaseHooksService
+    def execute
+      execute_branch_hooks
+
+      super.tap do
+        enqueue_update_gpg_signatures
+      end
+    end
+
+    private
+
+    def hook_name
+      :push_hooks
+    end
+
+    def commits
+      strong_memoize(:commits) do
+        if creating_default_branch?
+          # The most recent PROCESS_COMMIT_LIMIT commits in the default branch
+          offset = [count_commits_in_branch - PROCESS_COMMIT_LIMIT, 0].max
+          project.repository.commits(params[:newrev], offset: offset, limit: PROCESS_COMMIT_LIMIT)
+        elsif creating_branch?
+          # Use the pushed commits that aren't reachable by the default branch
+          # as a heuristic. This may include more commits than are actually
+          # pushed, but that shouldn't matter because we check for existing
+          # cross-references later.
+          project.repository.commits_between(project.default_branch, params[:newrev])
+        elsif updating_branch?
+          project.repository.commits_between(params[:oldrev], params[:newrev])
+        else # removing branch
+          []
+        end
+      end
+    end
+
+    def commits_count
+      return count_commits_in_branch if creating_default_branch?
+
+      super
+    end
+
+    def invalidated_file_types
+      return super unless default_branch? && !creating_branch?
+
+      paths = limited_commits.each_with_object(Set.new) do |commit, set|
+        commit.raw_deltas.each do |diff|
+          set << diff.new_path
+        end
+      end
+
+      Gitlab::FileDetector.types_in_paths(paths)
+    end
+
+    def execute_branch_hooks
+      project.repository.after_push_commit(branch_name)
+
+      branch_create_hooks if creating_branch?
+      branch_update_hooks if updating_branch?
+      branch_change_hooks if creating_branch? || updating_branch?
+      branch_remove_hooks if removing_branch?
+    end
+
+    def branch_create_hooks
+      project.repository.after_create_branch
+      project.after_create_default_branch if default_branch?
+    end
+
+    def branch_update_hooks
+      # Update the bare repositories info/attributes file using the contents of
+      # the default branch's .gitattributes file
+      project.repository.copy_gitattributes(params[:ref]) if default_branch?
+    end
+
+    def branch_change_hooks
+      enqueue_process_commit_messages
+    end
+
+    def branch_remove_hooks
+      project.repository.after_remove_branch
+    end
+
+    # Schedules processing of commit messages
+    def enqueue_process_commit_messages
+      # don't process commits for the initial push to the default branch
+      return if creating_default_branch?
+
+      limited_commits.each do |commit|
+        next unless commit.matches_cross_reference_regex?
+
+        ProcessCommitWorker.perform_async(
+          project.id,
+          current_user.id,
+          commit.to_hash,
+          default_branch?
+        )
+      end
+    end
+
+    def enqueue_update_gpg_signatures
+      unsigned = GpgSignature.unsigned_commit_shas(limited_commits.map(&:sha))
+      return if unsigned.empty?
+
+      signable = Gitlab::Git::Commit.shas_with_signatures(project.repository, unsigned)
+      return if signable.empty?
+
+      CreateGpgSignatureWorker.perform_async(signable, project.id)
+    end
+
+    def creating_branch?
+      Gitlab::Git.blank_ref?(params[:oldrev])
+    end
+
+    def updating_branch?
+      !creating_branch? && !removing_branch?
+    end
+
+    def removing_branch?
+      Gitlab::Git.blank_ref?(params[:newrev])
+    end
+
+    def creating_default_branch?
+      creating_branch? && default_branch?
+    end
+
+    def count_commits_in_branch
+      strong_memoize(:count_commits_in_branch) do
+        project.repository.commit_count_for_ref(params[:ref])
+      end
+    end
+
+    def default_branch?
+      strong_memoize(:default_branch) do
+        [nil, branch_name].include?(project.default_branch)
+      end
+    end
+
+    def branch_name
+      strong_memoize(:branch_name) { Gitlab::Git.ref_name(params[:ref]) }
+    end
+  end
+end
diff --git a/app/services/git/branch_push_service.rb b/app/services/git/branch_push_service.rb
index b55aeb5f2b9..da053ce80c7 100644
--- a/app/services/git/branch_push_service.rb
+++ b/app/services/git/branch_push_service.rb
@@ -1,14 +1,10 @@
 # frozen_string_literal: true
 
 module Git
-  class BranchPushService < BaseService
-    attr_accessor :push_data, :push_commits
+  class BranchPushService < ::BaseService
     include Gitlab::Access
     include Gitlab::Utils::StrongMemoize
 
-    # The N most recent commits to process in a single push payload.
-    PROCESS_COMMIT_LIMIT = 100
-
     # This method will be called after each git update
     # and only if the provided user and project are present in GitLab.
     #
@@ -23,108 +19,43 @@ module Git
     #  6. Checks if the project's main language has changed
     #
     def execute
-      update_commits
+      return unless Gitlab::Git.branch_ref?(params[:ref])
+
+      enqueue_update_mrs
+      enqueue_detect_repository_languages
+
       execute_related_hooks
       perform_housekeeping
 
       update_remote_mirrors
-      update_caches
+      stop_environments
 
-      update_signatures
+      true
     end
 
-    def update_commits
-      project.repository.after_create if project.empty_repo?
-      project.repository.after_push_commit(branch_name)
-
-      if push_remove_branch?
-        project.repository.after_remove_branch
-        @push_commits = []
-      elsif push_to_new_branch?
-        project.repository.after_create_branch
-
-        # Re-find the pushed commits.
-        if default_branch?
-          # Initial push to the default branch. Take the full history of that branch as "newly pushed".
-          process_default_branch
-        else
-          # Use the pushed commits that aren't reachable by the default branch
-          # as a heuristic. This may include more commits than are actually pushed, but
-          # that shouldn't matter because we check for existing cross-references later.
-          @push_commits = project.repository.commits_between(project.default_branch, params[:newrev])
-
-          # don't process commits for the initial push to the default branch
-          process_commit_messages
-        end
-      elsif push_to_existing_branch?
-        # Collect data for this git push
-        @push_commits = project.repository.commits_between(params[:oldrev], params[:newrev])
-
-        process_commit_messages
-
-        # Update the bare repositories info/attributes file using the contents of the default branches
-        # .gitattributes file
-        update_gitattributes if default_branch?
-      end
-    end
-
-    def update_gitattributes
-      project.repository.copy_gitattributes(params[:ref])
-    end
-
-    def update_caches
-      if default_branch?
-        if push_to_new_branch?
-          # If this is the initial push into the default branch, the file type caches
-          # will already be reset as a result of `Project#change_head`.
-          types = []
-        else
-          paths = Set.new
-
-          last_pushed_commits.each do |commit|
-            commit.raw_deltas.each do |diff|
-              paths << diff.new_path
-            end
-          end
-
-          types = Gitlab::FileDetector.types_in_paths(paths.to_a)
-        end
-
-        DetectRepositoryLanguagesWorker.perform_async(@project.id, current_user.id)
-      else
-        types = []
-      end
-
-      ProjectCacheWorker.perform_async(project.id, types, [:commit_count, :repository_size])
+    # Update merge requests that may be affected by this push. A new branch
+    # could cause the last commit of a merge request to change.
+    def enqueue_update_mrs
+      UpdateMergeRequestsWorker.perform_async(
+        project.id,
+        current_user.id,
+        params[:oldrev],
+        params[:newrev],
+        params[:ref]
+      )
     end
 
-    # rubocop: disable CodeReuse/ActiveRecord
-    def update_signatures
-      commit_shas = last_pushed_commits.map(&:sha)
+    def enqueue_detect_repository_languages
+      return unless default_branch?
 
-      return if commit_shas.empty?
-
-      shas_with_cached_signatures = GpgSignature.where(commit_sha: commit_shas).pluck(:commit_sha)
-      commit_shas -= shas_with_cached_signatures
-
-      return if commit_shas.empty?
-
-      commit_shas = Gitlab::Git::Commit.shas_with_signatures(project.repository, commit_shas)
-
-      CreateGpgSignatureWorker.perform_async(commit_shas, project.id)
+      DetectRepositoryLanguagesWorker.perform_async(project.id, current_user.id)
     end
-    # rubocop: enable CodeReuse/ActiveRecord
 
-    # Schedules processing of commit messages.
-    def process_commit_messages
-      default = default_branch?
+    # Only stop environments if the ref is a branch that is being deleted
+    def stop_environments
+      return unless removing_branch?
 
-      last_pushed_commits.each do |commit|
-        if commit.matches_cross_reference_regex?
-          ProcessCommitWorker
-            .perform_async(project.id, current_user.id, commit.to_hash, default)
-        end
-      end
+      Ci::StopEnvironmentsService.new(project, current_user).execute(branch_name)
     end
 
     def update_remote_mirrors
@@ -135,23 +66,7 @@ module Git
     end
 
     def execute_related_hooks
-      # Update merge requests that may be affected by this push. A new branch
-      # could cause the last commit of a merge request to change.
-      #
-      UpdateMergeRequestsWorker
-        .perform_async(project.id, current_user.id, params[:oldrev], params[:newrev], params[:ref])
-
-      EventCreateService.new.push(project, current_user, build_push_data)
-      Ci::CreatePipelineService.new(project, current_user, build_push_data).execute(:push, pipeline_options)
-
-      project.execute_hooks(build_push_data.dup, :push_hooks)
-      project.execute_services(build_push_data.dup, :push_hooks)
-
-      if push_remove_branch?
-        AfterBranchDeleteService
-          .new(project, current_user)
-          .execute(branch_name)
-      end
+      BranchHooksService.new(project, current_user, params).execute
     end
 
     def perform_housekeeping
@@ -161,84 +76,18 @@ module Git
     rescue Projects::HousekeepingService::LeaseTaken
     end
 
-    def process_default_branch
-      offset = [push_commits_count_for_ref - PROCESS_COMMIT_LIMIT, 0].max
-      @push_commits = project.repository.commits(params[:newrev], offset: offset, limit: PROCESS_COMMIT_LIMIT)
-
-      project.after_create_default_branch
-    end
-
-    def build_push_data
-      @push_data ||= Gitlab::DataBuilder::Push.build(
-        project,
-        current_user,
-        params[:oldrev],
-        params[:newrev],
-        params[:ref],
-        @push_commits,
-        commits_count: commits_count,
-        push_options: params[:push_options] || []
-      )
-    end
-
-    def push_to_existing_branch?
-      # Return if this is not a push to a branch (e.g. new commits)
-      branch_ref? && !Gitlab::Git.blank_ref?(params[:oldrev])
-    end
-
-    def push_to_new_branch?
-      strong_memoize(:push_to_new_branch) do
-        branch_ref? && Gitlab::Git.blank_ref?(params[:oldrev])
-      end
-    end
-
-    def push_remove_branch?
-      strong_memoize(:push_remove_branch) do
-        branch_ref? && Gitlab::Git.blank_ref?(params[:newrev])
-      end
-    end
-
-    def default_branch?
-      branch_ref? &&
-        (branch_name == project.default_branch || project.default_branch.nil?)
-    end
-
-    def commit_user(commit)
-      commit.author || current_user
+    def removing_branch?
+      Gitlab::Git.blank_ref?(params[:newrev])
     end
 
     def branch_name
-      strong_memoize(:branch_name) do
-        Gitlab::Git.ref_name(params[:ref])
-      end
+      strong_memoize(:branch_name) { Gitlab::Git.ref_name(params[:ref]) }
     end
 
-    def branch_ref?
-      strong_memoize(:branch_ref) do
-        Gitlab::Git.branch_ref?(params[:ref])
-      end
-    end
-
-    def commits_count
-      return push_commits_count_for_ref if default_branch? && push_to_new_branch?
-
-      Array(@push_commits).size
-    end
-
-    def push_commits_count_for_ref
-      strong_memoize(:push_commits_count_for_ref) do
-        project.repository.commit_count_for_ref(params[:ref])
+    def default_branch?
+      strong_memoize(:default_branch) do
+        [nil, branch_name].include?(project.default_branch)
       end
     end
-
-    def last_pushed_commits
-      @last_pushed_commits ||= @push_commits.last(PROCESS_COMMIT_LIMIT)
-    end
-
-    private
-
-    def pipeline_options
-      {} # to be overridden in EE
-    end
   end
 end
diff --git a/app/services/git/tag_hooks_service.rb b/app/services/git/tag_hooks_service.rb
new file mode 100644
index 00000000000..18eb780579f
--- /dev/null
+++ b/app/services/git/tag_hooks_service.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Git
+  class TagHooksService < ::Git::BaseHooksService
+    private
+
+    def hook_name
+      :tag_push_hooks
+    end
+
+    def commits
+      [tag_commit].compact
+    end
+
+    def event_message
+      tag&.message
+    end
+
+    def tag
+      strong_memoize(:tag) do
+        next if Gitlab::Git.blank_ref?(params[:newrev])
+
+        tag_name = Gitlab::Git.ref_name(params[:ref])
+        tag = project.repository.find_tag(tag_name)
+
+        tag if tag && tag.target == params[:newrev]
+      end
+    end
+
+    def tag_commit
+      strong_memoize(:tag_commit) do
+        project.commit(tag.dereferenced_target) if tag
+      end
+    end
+  end
+end
diff --git a/app/services/git/tag_push_service.rb b/app/services/git/tag_push_service.rb
index 9ce0fbdb206..ee4166dccd0 100644
--- a/app/services/git/tag_push_service.rb
+++ b/app/services/git/tag_push_service.rb
@@ -1,56 +1,14 @@
 # frozen_string_literal: true
 
 module Git
-  class TagPushService < BaseService
-    attr_accessor :push_data
-
+  class TagPushService < ::BaseService
     def execute
-      project.repository.after_create if project.empty_repo?
-      project.repository.before_push_tag
-
-      @push_data = build_push_data
-
-      EventCreateService.new.push(project, current_user, push_data)
-      Ci::CreatePipelineService.new(project, current_user, push_data).execute(:push, pipeline_options)
+      return unless Gitlab::Git.tag_ref?(params[:ref])
 
-      project.execute_hooks(push_data.dup, :tag_push_hooks)
-      project.execute_services(push_data.dup, :tag_push_hooks)
-
-      ProjectCacheWorker.perform_async(project.id, [], [:commit_count, :repository_size])
+      project.repository.before_push_tag
+      TagHooksService.new(project, current_user, params).execute
 
       true
     end
-
-    private
-
-    def build_push_data
-      commits = []
-      message = nil
-
-      unless Gitlab::Git.blank_ref?(params[:newrev])
-        tag_name = Gitlab::Git.ref_name(params[:ref])
-        tag = project.repository.find_tag(tag_name)
-
-        if tag && tag.target == params[:newrev]
-          commit = project.commit(tag.dereferenced_target)
-          commits = [commit].compact
-          message = tag.message
-        end
-      end
-
-      Gitlab::DataBuilder::Push.build(
-        project,
-        current_user,
-        params[:oldrev],
-        params[:newrev],
-        params[:ref],
-        commits,
-        message,
-        push_options: params[:push_options] || [])
-    end
-
-    def pipeline_options
-      {} # to be overridden in EE
-    end
   end
 end