Remove live_pollable_exists guard from create, not needed here.

Author: kathap

app/jobs/runtime/service_operations_binding_delete_stuck_in_progress_retry.rb

@@ -19,11 +19,9 @@ def max_attempts
         def retry_stuck(operation_model, instance_model, foreign_key, jobs_operation)
           # Find stuck binding 'delete' operations where the broker may still be working
           # but CC's polling job has permanently failed due to a transient error (e.g. brief db connection flip).
-          #
-          # Unlike create we do not mark the operation failed and do not mitigate orphans: for a delete we
-          # re-enqueue the original polling job so the unbind is driven to completion. The original delayed_job's
+          # We re-enqueue the original polling job so the unbind is driven to completion. The original delayed_job's
           # serialized handler is reused, preserving @start_time so the ReoccurringJob max-duration expiry
-          # (which marks the operation failed via handle_timeout) still fires against the original polling window.
+          # still fires against the original polling window.
           operation_table = operation_model.table_name
           instance_table = instance_model.table_name
 
@@ -80,8 +78,7 @@ def resolve_stuck(operation_model, instance_model, op_id, resource_id, pollable_
         end
 
         # Reuse the original delete polling job by deserializing the failed delayed_job's handler and unwrapping
-        # the wrapper chain (LoggingContextJob → TimeoutJob → PollableJobWrapper → DeleteBindingJob).
-        # This preserves the original @user_audit_info, @start_time and the binding @type.
+        # the wrapper chain. This preserves the original @user_audit_info, @start_time and the binding @type.
         def deserialize_handler(pollable)
           delayed_job = Delayed::Job[guid: pollable.delayed_job_guid]
           return unless delayed_job

app/jobs/runtime/service_operations_create_in_progress_cleanup.rb

@@ -40,10 +40,6 @@ def cleanup_operations(operation_model, instance_model, foreign_key, jobs_operat
           #     service instance that happen to share the same resource_guid
           #   - delayed_jobs.failed_at IS NOT NULL: the delayed job permanently failed (exhausted max_attempts);
           #     jobs still alive or locked have failed_at=NULL and must not be touched
-          #   - service_instances.guid NOT IN (live pollables for this operation): skip resources that still
-          #     have a POLLING/PROCESSING pollable driving this operation. A prior operation on the same
-          #     resource can leave a stale, permanently-failed pollable behind; without this guard that dead
-          #     row would match by resource_guid and cause the current healthy operation to be marked failed
           operation_table = operation_model.table_name
           instance_table = instance_model.table_name
 
@@ -57,7 +53,6 @@ def cleanup_operations(operation_model, instance_model, foreign_key, jobs_operat
                   where(Sequel[:jobs][:state] => [PollableJobModel::POLLING_STATE, PollableJobModel::FAILED_STATE]).
                   where(Sequel[:jobs][:operation] => jobs_operation).
                   exclude(Sequel[:delayed_jobs][:failed_at] => nil).
-                  exclude(live_pollable_exists(operation_model, instance_table, jobs_operation)).
                   select(
                     Sequel[:jobs][:guid].as(:pollable_guid),
                     Sequel[operation_table][:id].as(:op_id),
@@ -109,25 +104,6 @@ def default_maximum_duration_seconds
           Config.config.get(:broker_client_max_async_poll_duration_minutes).minutes
         end
 
-        # NOT EXISTS guard: skip a resource if it still has a pollable job actively driving
-        # THIS operation — state POLLING or PROCESSING AND backed by a delayed_job that has
-        # NOT permanently failed (failed_at IS NULL, or no delayed_job row yet). A stale,
-        # permanently-failed pollable left behind by a previous operation on the same
-        # resource must NOT cause the current healthy operation to be marked failed. A
-        # POLLING pollable whose delayed_job IS failed is itself stuck (the DB flip happened
-        # before the failure hook could write FAILED) and must NOT count as live. Correlated
-        # (resource_guid = instance.guid) so a NULL jobs.resource_guid elsewhere cannot
-        # poison the result the way a NOT IN subquery would.
-        def live_pollable_exists(operation_model, instance_table, jobs_operation)
-          operation_model.db[:jobs].
-            left_join(:delayed_jobs, guid: Sequel[:jobs][:delayed_job_guid]).
-            where(Sequel[:jobs][:operation] => jobs_operation).
-            where(Sequel[:jobs][:state] => [PollableJobModel::POLLING_STATE, PollableJobModel::PROCESSING_STATE]).
-            where(Sequel[:delayed_jobs][:failed_at] => nil).
-            where(Sequel[:jobs][:resource_guid] => Sequel[instance_table][:guid]).
-            exists
-        end
-
         def logger
           @logger ||= Steno.logger('cc.background.service-operations-create-in-progress-cleanup')
         end

app/jobs/runtime/service_operations_delete_stuck_in_progress_retry.rb

@@ -18,11 +18,9 @@ def max_attempts
         def retry_stuck(operation_model, instance_model, foreign_key, jobs_operation)
           # Find stuck service instance 'delete' operations where the broker may still be working
           # but CC's polling job has permanently failed due to a transient error (e.g. brief db connection flip).
-          #
-          # Unlike create/update we do not mark the operation failed: for a delete we re-enqueue the original
-          # polling job so the deprovision is driven to completion. The original delayed_job's serialized handler
-          # is reused, preserving @start_time so the ReoccurringJob max-duration expiry (which marks the operation
-          # failed via handle_timeout) still fires against the original polling window.
+          # We re-enqueue the original polling job so the deprovision is driven to completion. The original
+          # delayed_job's serialized handler is reused, preserving @start_time so the ReoccuringJob max-duration expiry
+          # (which marks the operation failed via handle_timeout) still fires against the original polling window.
           operation_table = operation_model.table_name
           instance_table = instance_model.table_name
 
@@ -78,9 +76,8 @@ def resolve_stuck(operation_model, instance_model, op_id, resource_id, pollable_
           end
         end
 
-        # Reuse the original delete polling job by deserializing the failed delayed_job's handler and unwrapping
-        # the wrapper chain (LoggingContextJob → TimeoutJob → PollableJobWrapper → DeleteServiceInstanceJob).
-        # This preserves the original @user_audit_info, @start_time and the recursive-vs-plain delete variant.
+        # Reuse the original delete polling job by deserializing the failed delayed_job's handler and unwrapping the
+        # wrapper chain. This preserves @user_audit_info, @start_time and the recursive-vs-plain delete variant.
         def deserialize_handler(pollable)
           delayed_job = Delayed::Job[guid: pollable.delayed_job_guid]
           return unless delayed_job

spec/unit/jobs/runtime/service_operations_create_in_progress_cleanup_spec.rb

@@ -55,24 +55,6 @@ def prepare_stuck_service_instance(
         { service_instance: service_instance, pjob: pjob, delayed_job: dj }
       end
 
-      # Attach an additional live pollable job (POLLING/PROCESSING, delayed_job NOT failed)
-      # for the same instance + operation. Mirrors a second create actively polling while a
-      # stale, permanently-failed pollable from a previous attempt lingers.
-      def add_live_pollable(service_instance, operation: 'service_instance.create', state: PollableJobModel::POLLING_STATE)
-        dj = Delayed::Job.create!(
-          guid: SecureRandom.uuid,
-          handler: 'fake',
-          run_at: Time.now,
-          queue: 'cc-generic'
-        )
-        create(:pollable_job_model,
-               state: state,
-               operation: operation,
-               resource_guid: service_instance.guid,
-               resource_type: 'service_instances',
-               delayed_job_guid: dj.guid)
-      end
-
       shared_examples 'does not trigger orphan mitigation' do
         before { job.perform }