v3(services): delete SI asynchronously (cloudfoundry#1733)

* v3(services): delete SI asynchronously

[finishes #171726806](https://www.pivotaltracker.com/story/show/171726806)

Author: Derik Evangelista

app/actions/v3/service_instance_delete.rb

@@ -40,7 +40,6 @@ def synchronous_destroy(service_instance, lock)
       def asynchronous_destroy(service_instance)
         delete_job = V3::DeleteServiceInstanceJob.new(
           service_instance.guid,
-          :deprovision,
           service_event_repository.user_audit_info)
 
         pollable_job = Jobs::Enqueuer.new(delete_job, queue: Jobs::Queues.generic).enqueue_pollable

app/jobs/v3/create_service_instance_job.rb

@@ -1,152 +1,28 @@
-require 'jobs/reoccurring_job'
+require 'jobs/v3/service_instance_async_job'
 
 module VCAP::CloudController
   module V3
-    class CreateServiceInstanceJob < VCAP::CloudController::Jobs::ReoccurringJob
-      attr_reader :warnings
-
+    class CreateServiceInstanceJob < ServiceInstanceAsyncJob
       def initialize(service_instance_guid, arbitrary_parameters: {}, user_audit_info:)
-        super()
-        @service_instance_guid = service_instance_guid
-        @arbitrary_parameters = arbitrary_parameters
-        @user_audit_info = user_audit_info
-        @start_time = Time.now
-        @first_time = true
-        @warnings = []
-      end
-
-      def perform
-        client = VCAP::Services::ServiceClientProvider.provide({ instance: service_instance })
-
-        if first_time
-          compute_maximum_duration
-          send_provision_request(client)
-          compatibility_checks
-          @first_time = false
-        end
-
-        gone! if service_instance.nil?
-
-        operation_in_progress = service_instance.last_operation.type
-        aborted! if operation_in_progress != 'create'
-
-        if service_instance.operation_in_progress?
-          fetch_last_operation(client)
-        end
-
-        if service_instance.last_operation.state == 'succeeded'
-          record_event(service_instance, @arbitrary_parameters)
-          finish
-        elsif service_instance.last_operation.state == 'failed'
-          operation_failed!(service_instance.last_operation.description)
-        end
-      end
-
-      def handle_timeout
-        service_instance.save_and_update_operation(
-          last_operation: {
-            state: 'failed',
-            description: 'Service Broker failed to provision within the required time.',
-          }
-        )
+        super(service_instance_guid, user_audit_info)
+        @request_attr = arbitrary_parameters
       end
 
-      def job_name_in_configuration
-        :service_instance_create
+      def operation
+        :provision
       end
 
-      def max_attempts
-        1
+      def operation_type
+        'create'
       end
 
-      def resource_type
-        'service_instances'
-      end
-
-      def resource_guid
-        service_instance_guid
-      end
-
-      def display_name
-        'service_instance.create'
-      end
-
-      private
-
-      attr_reader :service_instance_guid, :arbitrary_parameters, :first_time
-
-      def compute_maximum_duration
-        max_poll_duration_on_plan = service_instance.service_plan.try(:maximum_polling_duration)
-        self.maximum_duration_seconds = max_poll_duration_on_plan if max_poll_duration_on_plan
-      end
-
-      def send_provision_request(client)
-        broker_response = client.provision(
+      def send_broker_request(client)
+        client.provision(
           service_instance,
           accepts_incomplete: true,
-          arbitrary_parameters: arbitrary_parameters,
+          arbitrary_parameters: @request_attr,
           maintenance_info: service_instance.service_plan.maintenance_info
         )
-
-        service_instance.save_with_new_operation(broker_response[:instance], broker_response[:last_operation])
-      rescue => e
-        service_instance.save_with_new_operation({}, {
-          type: 'create',
-          state: 'failed',
-          description: e.message,
-        })
-        raise e
-      end
-
-      def fetch_last_operation(client)
-        last_operation_result = client.fetch_service_instance_last_operation(service_instance)
-        self.polling_interval_seconds = last_operation_result[:retry_after] if last_operation_result[:retry_after]
-
-        service_instance.save_and_update_operation(
-          last_operation: last_operation_result[:last_operation].slice(:state, :description)
-        )
-      rescue HttpRequestError, HttpResponseError, Sequel::Error => e
-        logger = Steno.logger('cc-background')
-        logger.error("There was an error while fetching the service instance operation state: #{e}")
-      end
-
-      def record_event(service_instance, request_attrs)
-        Repositories::ServiceEventRepository.new(@user_audit_info).
-          record_service_instance_event(:create, service_instance, request_attrs)
-      end
-
-      def service_instance
-        ManagedServiceInstance.first(guid: service_instance_guid)
-      end
-
-      def compatibility_checks
-        if service_instance.service_plan.service.volume_service? && volume_services_disabled?
-          @warnings.push({ detail: ServiceInstance::VOLUME_SERVICE_WARNING })
-        end
-
-        if service_instance.service_plan.service.route_service? && route_services_disabled?
-          @warnings.push({ detail: ServiceInstance::ROUTE_SERVICE_WARNING })
-        end
-      end
-
-      def volume_services_disabled?
-        !VCAP::CloudController::Config.config.get(:volume_services_enabled)
-      end
-
-      def route_services_disabled?
-        !VCAP::CloudController::Config.config.get(:route_services_enabled)
-      end
-
-      def gone!
-        raise CloudController::Errors::ApiError.new_from_details('ServiceInstanceNotFound', service_instance_guid)
-      end
-
-      def aborted!
-        raise CloudController::Errors::ApiError.new_from_details('UnableToPerform', 'Create', 'delete in progress')
-      end
-
-      def operation_failed!(msg)
-        raise CloudController::Errors::ApiError.new_from_details('ServiceInstanceProvisionFailed', msg)
       end
     end
   end

app/jobs/v3/delete_service_instance_job.rb

@@ -1,92 +1,40 @@
-require 'jobs/reoccurring_job'
+require 'jobs/v3/service_instance_async_job'
 
 module VCAP::CloudController
   module V3
-    class DeleteServiceInstanceJob < VCAP::CloudController::Jobs::ReoccurringJob
-      attr_reader :warnings
-
-      def initialize(guid, operation, audit_info)
-        super()
-        @service_instance_guid = guid
-        @operation = operation
-        @client_arguments = { accepts_incomplete: false }
-        @user_audit_info = audit_info
-        @warnings = []
-      end
-
-      def perform
-        client = VCAP::Services::ServiceClientProvider.provide({ instance: service_instance })
-
-        execute_request(client)
-
-        finish
-      end
-
-      def job_name_in_configuration
-        "service_instance_#{operation_type}"
+    class DeleteServiceInstanceJob < ServiceInstanceAsyncJob
+      def initialize(guid, audit_info)
+        super(guid, audit_info)
       end
 
-      def max_attempts
-        1
+      def send_broker_request(client)
+        client.deprovision(service_instance, { accepts_incomplete: true })
       end
 
-      def resource_type
-        'service_instances'
+      def operation_succeeded
+        ServiceInstance.db.transaction do
+          service_instance.lock!
+          service_instance.last_operation&.destroy
+          service_instance.destroy
+        end
       end
 
-      def resource_guid
-        service_instance_guid
+      def operation
+        :deprovision
       end
 
-      def display_name
-        "service_instance.#{operation_type}"
+      def operation_type
+        'delete'
       end
 
       private
 
-      attr_reader :service_instance_guid
-
-      def service_instance
-        ManagedServiceInstance.first(guid: @service_instance_guid)
-      end
-
-      def execute_request(client)
-        broker_response = client.public_send(
-          @operation,
-          service_instance,
-          @client_arguments
-        )
-
-        if broker_response.dig(:last_operation, :state) == 'succeeded'
-          ServiceInstance.db.transaction do
-            si = service_instance
-            service_instance.lock!
-            service_instance.last_operation&.destroy
-            service_instance.destroy
-            record_event(si, nil)
-          end
-        end
-      rescue => e
-        service_instance.save_with_new_operation({}, {
-          type: operation_type,
-          state: 'failed',
-          description: e.message,
-        })
-        raise e
-      end
-
-      def record_event(service_instance, request_attrs)
-        Repositories::ServiceEventRepository.new(@user_audit_info).
-          record_service_instance_event(:delete, service_instance, request_attrs)
+      def gone!
+        finish
       end
 
-      def operation_type
-        case @operation
-        when :deprovision
-          'delete'
-        else
-          ''
-        end
+      def compatibility_checks
+        nil
       end
     end
   end