Use new pipeline retry service with optimistic locking

app/models/ci/pipeline.rb

@@ -224,13 +224,9 @@ module Ci
         end
     end
 
-    def retry_failed(user)
-      Gitlab::OptimisticLocking.retry_lock(
-        builds.latest.failed_or_canceled) do |failed_or_canceled|
-          failed_or_canceled.select(&:retryable?).each do |build|
-            Ci::Build.retry(build, user)
-          end
-        end
+    def retry_failed(current_user)
+      Ci::RetryPipelineService.new(project, current_user)
+        .execute(self)
     end
 
     def mark_as_processable_after_stage(stage_idx)

app/services/ci/retry_build_service.rb

 module Ci
   class RetryBuildService < ::BaseService
     def execute(build)
+      # return unless build.retryable?
+
       self.retry(build).tap do |new_build|
         MergeRequests::AddTodoWhenBuildFailsService
           .new(build.project, current_user)

app/services/ci/retry_pipeline_service.rb

@@ -7,34 +7,48 @@ module Ci
         raise Gitlab::Access::AccessDeniedError
       end
 
-      ##
-      # Reprocess builds in subsequent stages
-      #
-      pipeline.builds
-        .after_stage(resume_stage.index)
-        .failed_or_canceled.find_each do |build|
-          Ci::RetryBuildService
-            .new(project, current_user)
-            .reprocess(build)
-        end
-
-      ##
-      # Mark skipped builds as processable again
-      #
       pipeline.mark_as_processable_after_stage(resume_stage.index)
 
-      ##
-      # Retry builds in the first unsuccessful stage
-      #
-      resume_stage.builds.failed_or_canceled.find_each do |build|
-        Ci::RetryBuildService
-          .new(project, current_user)
+      retryable_builds_in_subsequent_stages do |build|
+        Ci::RetryBuildService.new(project, current_user)
+          .reprocess(build)
+      end
+
+      retryable_builds_in_first_unsuccessful_stage do |build|
+        Ci::RetryBuildService.new(project, current_user)
           .retry(build)
       end
     end
 
     private
 
+    def retryable_builds_in_subsequent_stages
+      relation = @pipeline.builds
+        .after_stage(resume_stage.index)
+        .failed_or_canceled
+
+      each_retryable_build_with_locking(relation) do |build|
+        yield build
+      end
+    end
+
+    def retryable_builds_in_first_unsuccessful_stage
+      relation = resume_stage.builds.failed_or_canceled
+
+      each_retryable_build_with_locking(relation) do |build|
+        yield build
+      end
+    end
+
+    def each_retryable_build_with_locking(relation)
+      Gitlab::OptimisticLocking.retry_lock(relation) do |builds|
+        builds.find_each do |build|
+          next unless build.retryable?
+          yield build
+        end
+      end
+    end
+
     def resume_stage
       @resume_stage ||= @pipeline.stages.find do |stage|
         stage.failed? || stage.canceled?