v3(services): allow SI's to be purged

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

Author: Derik Evangelista

app/actions/service_instance_purge.rb

@@ -0,0 +1,40 @@
+module VCAP::CloudController
+  class ServiceInstancePurge
+    def initialize(event_repository)
+      @event_repository = event_repository
+    end
+
+    def purge(service_instance)
+      logger.info("purging service instance #{service_instance.guid}")
+
+      service_instance.db.transaction do
+        service_instance.routes.each do |route|
+          route.route_binding.destroy
+        end
+
+        service_instance.service_bindings.each do |binding|
+          binding.destroy
+          Repositories::ServiceBindingEventRepository.record_delete(binding, @event_repository.user_audit_info)
+        end
+
+        service_instance.service_keys.each do |key|
+          key.destroy
+          @event_repository.record_service_key_event('delete', key, nil)
+        end
+
+        service_instance.shared_spaces.each do |target_space|
+          Repositories::ServiceInstanceShareEventRepository.record_unshare_event(service_instance, target_space, @event_repository.user_audit_info)
+        end
+
+        service_instance.destroy
+        @event_repository.record_service_instance_event('purge', service_instance, nil)
+      end
+
+      logger.info("successfully purged service instance #{service_instance.guid}")
+    end
+
+    def logger
+      @logger ||= Steno.logger('cc.service_lifecycle.instance_purger')
+    end
+  end
+end

app/controllers/v3/service_instances_controller.rb

@@ -18,6 +18,7 @@
 require 'actions/service_instance_create_user_provided'
 require 'actions/v3/service_instance_delete'
 require 'actions/service_instance_create_managed'
+require 'actions/service_instance_purge'
 require 'fetchers/service_instance_list_fetcher'
 require 'decorators/field_service_instance_space_decorator'
 require 'decorators/field_service_instance_organization_decorator'
@@ -97,10 +98,17 @@ def update
   def destroy
     service_instance = ServiceInstance.first(guid: hashed_params[:guid])
     service_instance_not_found! unless service_instance && can_read_service_instance?(service_instance)
+    purge = params['purge'] == 'true'
 
     unauthorized! unless can_write_space?(service_instance.space)
 
     service_event_repository = VCAP::CloudController::Repositories::ServiceEventRepository.new(user_audit_info)
+
+    if purge
+      ServiceInstancePurge.new(service_event_repository).purge(service_instance)
+      return [:no_content, nil]
+    end
+
     job_guid = V3::ServiceInstanceDelete.new(service_event_repository).delete(service_instance)
 
     if job_guid.blank?

docs/v3/source/includes/experimental_resources/service_instances/_delete.md

@@ -42,6 +42,12 @@ accordingly to cases outlined in the [OSBAPI specification](https://github.com/o
 #### Definition
 `DELETE /v3/service_instances/:guid`
 
+#### Query parameters
+
+Name | Type | Description
+---- | ---- | ------------
+**purge** | _boolean_ | If `true`, deletes the service instance and all associated resources without any interaction with the service broker.
+
 #### Permitted Roles
  |
 --- | ---

spec/request/service_instances_spec.rb

@@ -2578,7 +2578,8 @@ def check_filtered_instances(*instances)
   end
 
   describe 'DELETE /v3/service_instances/:guid' do
-    let(:api_call) { lambda { |user_headers| delete "/v3/service_instances/#{instance.guid}", '{}', user_headers } }
+    let(:query_params) { '' }
+    let(:api_call) { lambda { |user_headers| delete "/v3/service_instances/#{instance.guid}?#{query_params}", '{}', user_headers } }
 
     context 'permissions' do
       let!(:instance) { VCAP::CloudController::UserProvidedServiceInstance.make(space: space) }
@@ -2602,7 +2603,9 @@ def check_filtered_instances(*instances)
     end
 
     context 'user provided service instances' do
-      let!(:instance) { VCAP::CloudController::UserProvidedServiceInstance.make(space: space) }
+      let!(:instance) { VCAP::CloudController::UserProvidedServiceInstance.make(space: space, route_service_url: 'https://banana.example.com/') }
+      let(:instance_labels) { VCAP::CloudController::ServiceInstanceLabelModel.where(service_instance: instance) }
+      let(:instance_annotations) { VCAP::CloudController::ServiceInstanceAnnotationModel.where(service_instance: instance) }
 
       before do
         VCAP::CloudController::ServiceInstanceLabelModel.make(key_name: 'fruit', value: 'banana', service_instance: instance)
@@ -2620,6 +2623,31 @@ def check_filtered_instances(*instances)
         expect(VCAP::CloudController::ServiceInstanceLabelModel.where(service_instance: instance).all).to be_empty
         expect(VCAP::CloudController::ServiceInstanceAnnotationModel.where(service_instance: instance).all).to be_empty
       end
+
+      it 'fails to delete when there are bindings' do
+        VCAP::CloudController::ServiceBinding.make(service_instance: instance)
+        api_call.call(admin_headers)
+        expect(last_response).to have_status_code(422)
+      end
+
+      context 'with purge' do
+        let(:query_params) { 'purge=true' }
+        before(:each) do
+          @binding = VCAP::CloudController::ServiceBinding.make(service_instance: instance)
+          @route = VCAP::CloudController::RouteBinding.make(service_instance: instance)
+        end
+
+        it 'deletes the instance and the related resources' do
+          api_call.call(admin_headers)
+          expect(last_response).to have_status_code(204)
+
+          expect { instance.reload }.to raise_error Sequel::NoExistingObject
+          expect { @binding.reload }.to raise_error Sequel::NoExistingObject
+          expect { @route.reload }.to raise_error Sequel::NoExistingObject
+          expect(instance_labels.count).to eq(0)
+          expect(instance_annotations.count).to eq(0)
+        end
+      end
     end
 
     context 'managed service instance' do
@@ -3092,6 +3120,62 @@ def check_filtered_instances(*instances)
         end
       end
 
+      context 'when there are associations' do
+        RSpec.shared_examples 'associations not empty' do
+          it 'returns a 422 Unprocessable Entity' do
+            api_call.call(admin_headers)
+            expect(last_response).to have_status_code(422)
+            response = parsed_response['errors'].first
+            expect(response).to include('title' => 'CF-AssociationNotEmpty')
+            expect(response).to include('detail' => include('Please delete the service_bindings, service_keys, and routes associations for your service_instances.'))
+          end
+        end
+
+        let(:service_offering) { VCAP::CloudController::Service.make(requires: %w(route_forwarding)) }
+        let(:service_plan) { VCAP::CloudController::ServicePlan.make(service: service_offering) }
+        let(:instance) { VCAP::CloudController::ManagedServiceInstance.make(space: space, service_plan: service_plan) }
+
+        describe 'service bindings' do
+          before(:each) { VCAP::CloudController::ServiceBinding.make(service_instance: instance) }
+          it_should_behave_like 'associations not empty'
+        end
+
+        describe 'service keys' do
+          before(:each) { VCAP::CloudController::ServiceKey.make(service_instance: instance) }
+          it_should_behave_like 'associations not empty'
+        end
+
+        describe 'route bindings' do
+          before(:each) { VCAP::CloudController::RouteBinding.make(service_instance: instance) }
+          it_should_behave_like 'associations not empty'
+        end
+
+        context 'but purge is true' do
+          let(:query_params) { 'purge=true' }
+          before(:each) do
+            @binding = VCAP::CloudController::ServiceBinding.make(service_instance: instance)
+            @key = VCAP::CloudController::ServiceKey.make(service_instance: instance)
+            @route = VCAP::CloudController::RouteBinding.make(service_instance: instance)
+
+            api_call.call(admin_headers)
+          end
+
+          it 'removes all associations' do
+            expect { @binding.reload }.to raise_error Sequel::NoExistingObject
+            expect { @key.reload }.to raise_error Sequel::NoExistingObject
+            expect { @route.reload }.to raise_error Sequel::NoExistingObject
+          end
+
+          it 'deletes the service instance' do
+            expect { instance.reload }.to raise_error Sequel::NoExistingObject
+          end
+
+          it 'responds with 204' do
+            expect(last_response).to have_status_code(204)
+          end
+        end
+      end
+
       context 'when the creation is still in progress' do
         before do
           instance.save_with_new_operation({}, {
@@ -3173,20 +3257,6 @@ def check_filtered_instances(*instances)
       end
     end
 
-    context 'when associations are not empty' do
-      let(:instance) { VCAP::CloudController::ServiceInstance.make(space: space) }
-
-      it 'returns a 422 Unprocessable Entity' do
-        VCAP::CloudController::ServiceBinding.make(service_instance: instance)
-
-        api_call.call(admin_headers)
-        expect(last_response).to have_status_code(422)
-        response = parsed_response['errors'].first
-        expect(response).to include('title' => 'CF-AssociationNotEmpty')
-        expect(response).to include('detail' => 'Please delete the service_bindings, service_keys, and routes associations for your service_instances.')
-      end
-    end
-
     context 'when the service instance does not exist' do
       let(:instance) { Struct.new(:guid).new('some-fake-guid') }
       it 'returns a 404' do

spec/unit/actions/service_instance_purge_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'actions/service_instance_purge'
+
+module VCAP::CloudController
+  RSpec.describe ServiceInstancePurge do
+    let(:user_audit_info) { UserAuditInfo.new(user_guid: User.make.guid, user_email: 'email') }
+    let(:event_repository) { Repositories::ServiceEventRepository.new(user_audit_info) }
+    subject { described_class.new(event_repository) }
+
+    describe '#purge' do
+      let(:service_instance) { ManagedServiceInstance.make }
+
+      it 'deletes the service instance' do
+        subject.purge(service_instance)
+        expect(service_instance).not_to exist
+      end
+
+      it 'records a service instance purge event' do
+        subject.purge(service_instance)
+        event = Event.last
+        expect(event.type).to eq('audit.service_instance.purge')
+        expect(event.actee).to eq(service_instance.guid)
+      end
+
+      it 'records a service usage event for DELETED' do
+        subject.purge(service_instance)
+        event = ServiceUsageEvent.last
+        expect(event.service_instance_guid).to eq(service_instance.guid)
+        expect(event.state).to eq('DELETED')
+      end
+
+      context 'when there are service bindings' do
+        let!(:service_binding_1) { ServiceBinding.make(service_instance: service_instance) }
+        let!(:service_binding_2) { ServiceBinding.make(service_instance: service_instance) }
+
+        it 'records the service binding delete event' do
+          subject.purge(service_instance)
+          events              = Event.where(type: 'audit.service_binding.delete').all
+          event_binding_guids = events.collect(&:actee)
+
+          expect(events.length).to eq(2)
+          expect(event_binding_guids).to match_array([service_binding_1.guid, service_binding_2.guid])
+        end
+
+        it 'deletes the service bindings' do
+          subject.purge(service_instance)
+          expect(service_binding_1).not_to exist
+          expect(service_binding_2).not_to exist
+        end
+      end
+
+      context 'when there are route bindings' do
+        let(:route_1) { Route.make(space: service_instance.space) }
+        let(:route_2) { Route.make(space: service_instance.space) }
+        let!(:service_instance) { ManagedServiceInstance.make(:routing) }
+        let!(:route_binding_1) { RouteBinding.make(service_instance: service_instance, route: route_1) }
+        let!(:route_binding_2) { RouteBinding.make(service_instance: service_instance, route: route_2) }
+
+        it 'deletes the route bindings' do
+          subject.purge(service_instance)
+          expect(route_binding_1).not_to exist
+          expect(route_binding_2).not_to exist
+        end
+      end
+
+      context 'when there are service keys' do
+        let!(:service_key_1) { ServiceKey.make(service_instance: service_instance) }
+        let!(:service_key_2) { ServiceKey.make(service_instance: service_instance) }
+
+        it 'records the service key delete event' do
+          subject.purge(service_instance)
+          events          = Event.where(type: 'audit.service_key.delete').all
+          event_key_guids = events.collect(&:actee)
+
+          expect(events.length).to eq(2)
+          expect(event_key_guids).to match_array([service_key_1.guid, service_key_2.guid])
+        end
+
+        it 'deletes the service keys' do
+          subject.purge(service_instance)
+          expect(service_key_1).not_to exist
+          expect(service_key_2).not_to exist
+        end
+      end
+
+      context 'when the service instance has shared spaces' do
+        let(:target_space) { Space.make }
+
+        before { service_instance.add_shared_space(target_space) }
+
+        it 'records an unshare service event' do
+          subject.purge(service_instance)
+          events = Event.where(type: 'audit.service_instance.unshare').all
+          event_key_guid = events.collect(&:actee)
+
+          expect(events.length).to eq(1)
+          expect(event_key_guid).to match_array([service_instance.guid])
+        end
+      end
+    end
+  end
+end