Add project transsfer worker for zoekt

Added a new project transfer worker for zoekt which does the following:
-  If a project is moved out of a Zoekt indexed namespace we need to trigger a delete to clean up the data in Zoekt.
-  If a project is moved into a Zoekt indexed namespace we need to trigger the project to be indexed.

config/sidekiq_queues.yml

@@ -583,6 +583,8 @@
   - 1
 - - search_zoekt_namespace_indexer
   - 1
+- - search_zoekt_project_transfer
+  - 1
 - - security_auto_fix
   - 1
 - - security_generate_policy_violation_comment

ee/app/services/ee/projects/transfer_service.rb

@@ -32,6 +32,7 @@ def post_update_hooks(project, old_group)
         super
 
         ::Elastic::ProjectTransferWorker.perform_async(project.id, old_namespace.id, new_namespace.id)
+        ::Search::Zoekt::ProjectTransferWorker.perform_async(project.id, old_namespace.id)
 
         delete_scan_result_policies(old_group)
         unassign_policy_project

ee/app/workers/all_queues.yml

@@ -1875,6 +1875,15 @@
   :weight: 1
   :idempotent: true
   :tags: []
+- :name: search_zoekt_project_transfer
+  :worker_name: Search::Zoekt::ProjectTransferWorker
+  :feature_category: :global_search
+  :has_external_dependencies: false
+  :urgency: :throttled
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: true
+  :tags: []
 - :name: security_auto_fix
   :worker_name: Security::AutoFixWorker
   :feature_category: :software_composition_analysis

ee/app/workers/search/zoekt/project_transfer_worker.rb

+# frozen_string_literal: true
+
+module Search
+  module Zoekt
+    class ProjectTransferWorker
+      include ApplicationWorker
+
+      pause_control :zoekt
+
+      feature_category :global_search
+      idempotent!
+      data_consistency :delayed
+      urgency :throttled
+
+      def perform(project_id, old_namespace_id)
+        return unless ::Feature.enabled?(:index_code_with_zoekt)
+        return unless ::License.feature_available?(:zoekt_code_search)
+
+        project = Project.find_by_id(project_id)
+        old_namespace = Namespace.find_by_id(old_namespace_id)
+
+        return false unless project && old_namespace
+
+        if old_namespace.use_zoekt?
+          Search::Zoekt::DeleteProjectWorker.perform_async(old_namespace.root_ancestor.id, project_id)
+        end
+
+        return unless project.use_zoekt?
+
+        ::Zoekt::IndexerWorker.perform_async(project_id)
+      end
+    end
+  end
+end

ee/spec/services/projects/transfer_service_spec.rb

@@ -69,8 +69,9 @@ def operation
   end
 
   describe 'elasticsearch indexing' do
-    it 'delegates transfer to Elastic::ProjectTransferWorker' do
+    it 'delegates transfer to Elastic::ProjectTransferWorker and ::Search::Zoekt::ProjectTransferWorker' do
       expect(::Elastic::ProjectTransferWorker).to receive(:perform_async).with(project.id, project.namespace.id, group.id).once
+      expect(::Search::Zoekt::ProjectTransferWorker).to receive(:perform_async).with(project.id, project.namespace.id).once
 
       subject.execute(group)
     end

ee/spec/workers/search/zoekt/project_transfer_worker_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ::Search::Zoekt::ProjectTransferWorker, feature_category: :global_search do
+  let_it_be(:namespace) { create(:group) }
+  let_it_be(:old_namespace) { create(:group) }
+  # create project in indexed_namespace to emulate the successful project transfer
+  # which would have occurred prior to this worker being invoked
+  let_it_be(:project) { create(:project, namespace: namespace) }
+
+  subject(:worker) { described_class.new }
+
+  include_examples 'an idempotent worker' do
+    let(:job_args) { [project.id, namespace.id] }
+
+    describe '#perform' do
+      context 'when zoekt is enabled' do
+        before do
+          stub_feature_flags(index_code_with_zoekt: true)
+          allow(::Zoekt::IndexedNamespace).to receive(:enabled_for_namespace?).with(old_namespace).and_return(
+            namespace_zoekt_enabled)
+          allow(::Zoekt::IndexedNamespace).to receive(:enabled_for_project?).with(project).and_return(
+            project_zoekt_enabled)
+        end
+
+        context 'when moving the project from a non-indexed namespace to an indexed namespace' do
+          let(:namespace_zoekt_enabled) { false }
+          let(:project_zoekt_enabled) { true }
+
+          it 'schedules the project to be indexed and does not delete the project' do
+            expect(Search::Zoekt::DeleteProjectWorker).not_to receive(:perform_async)
+            expect(::Zoekt::IndexerWorker).to receive(:perform_async).with(project.id).once
+            worker.perform(project.id, old_namespace.id)
+          end
+        end
+
+        context 'when moving the project from an indexed namespace to a non-indexed namespace' do
+          let(:namespace_zoekt_enabled) { true }
+          let(:project_zoekt_enabled) { false }
+
+          it 'schedules the project to be deleted and does not index anything' do
+            expect(Search::Zoekt::DeleteProjectWorker).to receive(:perform_async).with(old_namespace.id,
+              project.id).once
+            expect(::Zoekt::IndexerWorker).not_to receive(:perform_async)
+            worker.perform(project.id, old_namespace.id)
+          end
+        end
+      end
+
+      context 'when zoekt is disabled' do
+        before do
+          stub_feature_flags(index_code_with_zoekt: false)
+        end
+
+        it 'does nothing' do
+          expect(Search::Zoekt::DeleteProjectWorker).not_to receive(:perform_async)
+          expect(::Zoekt::IndexerWorker).not_to receive(:perform_async)
+          worker.perform(project.id, old_namespace.id)
+        end
+      end
+    end
+  end
+end