AddFunc: func(obj interface{}) {
			h.addSV(obj)
		},
		UpdateFunc: func(oldObj, newObj interface{}) {
			h.updateSV(oldObj, newObj)
		},
		DeleteFunc: func(obj interface{}) {
			h.deleteSV(obj)
		}})
	return h

		return
	}
	h.updateSVMap(oldSV, newSV)
}

// Deletes a storageversion object from SVMap
func (h *peerProxyHandler) deleteSV(obj interface{}) {
	sv, ok := obj.(*v1alpha1.StorageVersion)
	if !ok {
		klog.Errorf("Invalid StorageVersion provided to deleteSV()")
		return
	}
	h.updateSVMap(sv, nil)
}

// Delete old storageversion, add new storagversion

import java.io.File;
import java.io.IOException;

/**
 * A file deleter that doesn't give up if deletion doesn't work on the first try.
 */
@ServiceScope(Scope.Global.class)
public interface Deleter {
    /**
     * Attempts to delete the given file or directory recursively.
     *
     * Can delete directories with contents.
     * Does not Follow symlinks.
     *

import org.gradle.api.internal.ConventionTask;
import org.gradle.internal.file.Deleter;
import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;
import java.io.File;
import java.io.IOException;
import java.util.Set;

/**
 * <p>Deletes files or directories. Example:</p>
 * <pre class='autoTested'>
 * task makePretty(type: Delete) {
 *   delete 'uglyFolder', 'uglyFile'
 *   followSymlinks = true
 * }
 * </pre>

			obj, deleted, err := r.Delete(ctx, name, rest.AdmissionToValidateObjectDeleteFunc(admit, staticAdmissionAttrs, scope), options)
			wasDeleted = deleted
			return obj, err
		})
		if err != nil {
			scope.err(err, w, req)
			return
		}
		span.AddEvent("Object deleted from database")

		status := http.StatusOK
		// Return http.StatusAccepted if the resource was not deleted immediately and

        ex.suppressed.collect { it.message } == ["ROOT CAUSE"]
    }

    def "reports failed to delete child files and reports a reasonable number of retries after failure to delete directory"() {

        given:
        def targetDir = tmpDir.createDir("target")
        def deletable = targetDir.createFile("delete.yes")
        def nonDeletable = targetDir.createFile("delete.no")

aws configure set aws_secret_access_key minioadmin --profile minioadmin
aws configure set default.region us-east-1 --profile minioadmin

aws s3api --endpoint-url http://localhost:9001 --profile minioadmin delete-object --bucket testbucket --key dir/file --version-id "$versionId"

./mc ls -r --versions myminio1/testbucket >/tmp/myminio1.txt
./mc ls -r --versions myminio2/testbucket >/tmp/myminio2.txt

			expectedEvents:  noevents,
			errors:          noerrors,
			// Inject deleter into the controller and call syncVolume. The
			// deleter simulates one delete() call that succeeds.
			test: wrapTestWithReclaimCalls(operationDelete, []error{nil}, testSyncVolume),
		},
		{
			// PV requires external deleter
			name:            "8-10-1 - external deleter when volume is dynamic provisioning",

import org.gradle.internal.file.Deleter
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

class StaleOutputCleanerTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    Deleter deleter = TestFiles.deleter()

    def "deletes all previous output files"() {

        when:
        delete.delete(file)
        execute(delete)

        then:
        delete.getDidWork()
        !file.exists()
    }

    def "did work is false when nothing gets deleted"() {
        when:
        delete.delete("does-not-exist")
        execute(delete)

        then:
        !delete.getDidWork()
    }

    def "get target files and multiple targets"() {
        when: