diff --git a/.gitignore b/.gitignore
index 81322bc..8967117 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,7 @@
 /bazel-*
 /eclipse-out
 /node_modules
+
+# IntelliJ files
+.idea
+*.iml
\ No newline at end of file
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteAction.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteAction.java
index 459d819..47feddf 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteAction.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteAction.java
@@ -14,8 +14,12 @@
 
 package com.googlesource.gerrit.plugins.deleteproject;
 
+import com.google.gerrit.common.Nullable;
+import com.google.gerrit.extensions.registration.DynamicItem;
 import com.google.gerrit.extensions.webui.UiAction;
 import com.google.gerrit.server.CurrentUser;
+import com.google.gerrit.server.config.GerritInstanceId;
+import com.google.gerrit.server.events.EventDispatcher;
 import com.google.gerrit.server.project.ProjectResource;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
@@ -36,7 +40,9 @@
       DeleteLog deleteLog,
       DeletePreconditions preConditions,
       Configuration cfg,
-      HideProject hideProject) {
+      HideProject hideProject,
+      DynamicItem<EventDispatcher> dispatcher,
+      @Nullable @GerritInstanceId String instanceId) {
     super(
         dbHandler,
         fsHandler,
@@ -45,7 +51,9 @@
         deleteLog,
         preConditions,
         cfg,
-        hideProject);
+        hideProject,
+        dispatcher,
+        instanceId);
     this.protectedProjects = protectedProjects;
   }
 
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteProject.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteProject.java
index 40463b2..75a948a 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteProject.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/DeleteProject.java
@@ -14,13 +14,17 @@
 
 package com.googlesource.gerrit.plugins.deleteproject;
 
+import com.google.gerrit.common.Nullable;
 import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.registration.DynamicItem;
 import com.google.gerrit.extensions.restapi.ResourceNotFoundException;
 import com.google.gerrit.extensions.restapi.Response;
 import com.google.gerrit.extensions.restapi.RestApiException;
 import com.google.gerrit.extensions.restapi.RestModifyView;
 import com.google.gerrit.server.CurrentUser;
 import com.google.gerrit.server.IdentifiedUser;
+import com.google.gerrit.server.config.GerritInstanceId;
+import com.google.gerrit.server.events.EventDispatcher;
 import com.google.gerrit.server.project.ProjectResource;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
@@ -48,6 +52,8 @@
   private final DeleteLog deleteLog;
   private final Configuration cfg;
   private final HideProject hideProject;
+  private final DynamicItem<EventDispatcher> dispatcher;
+  private final String instanceId;
 
   @Inject
   DeleteProject(
@@ -58,7 +64,9 @@
       DeleteLog deleteLog,
       DeletePreconditions preConditions,
       Configuration cfg,
-      HideProject hideProject) {
+      HideProject hideProject,
+      DynamicItem<EventDispatcher> dispatcher,
+      @Nullable @GerritInstanceId String instanceId) {
     this.dbHandler = dbHandler;
     this.fsHandler = fsHandler;
     this.cacheHandler = cacheHandler;
@@ -67,6 +75,8 @@
     this.preConditions = preConditions;
     this.cfg = cfg;
     this.hideProject = hideProject;
+    this.dispatcher = dispatcher;
+    this.instanceId = instanceId;
   }
 
   @Override
@@ -94,6 +104,20 @@
       } else {
         hideProject.apply(rsrc);
       }
+
+      ProjectDeletedEvent event = new ProjectDeletedEvent();
+      event.projectName = project.getName();
+      event.instanceId = instanceId;
+
+      /**
+       * EventBroker checks if user has the permission to access the project. But because this
+       * project is already deleted, check will always fail. That's why this event will be delivered
+       * only to the unrestricted listeners. Unrestricted events listeners are implementing {@link
+       * com.google.gerrit.server.events.EventListener} which allows to listen to events without
+       * user visibility restrictions. For example these events are going to be delivered to
+       * multi-site {@link com.googlesource.gerrit.plugins.multisite.event.EventHandler}
+       */
+      dispatcher.get().postEvent(project.getNameKey(), event);
     } catch (Exception e) {
       ex = e;
       throw e;
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/PluginModule.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/PluginModule.java
index 4d0a802..a2e3f15 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/PluginModule.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/PluginModule.java
@@ -22,6 +22,7 @@
 import com.google.gerrit.extensions.config.CapabilityDefinition;
 import com.google.gerrit.extensions.events.LifecycleListener;
 import com.google.gerrit.extensions.restapi.RestApiModule;
+import com.google.gerrit.server.events.EventTypes;
 import com.google.inject.AbstractModule;
 import com.google.inject.Inject;
 import com.google.inject.internal.UniqueAnnotations;
@@ -60,6 +61,8 @@
           .to(ArchiveRepositoryRemover.class);
     }
 
+    EventTypes.register(ProjectDeletedEvent.TYPE, ProjectDeletedEvent.class);
+
     install(
         new RestApiModule() {
           @Override
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEvent.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEvent.java
new file mode 100644
index 0000000..31a41cc
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEvent.java
@@ -0,0 +1,33 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.deleteproject;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.entities.Project.NameKey;
+import com.google.gerrit.server.events.ProjectEvent;
+
+public class ProjectDeletedEvent extends ProjectEvent {
+  public static final String TYPE = "project-deleted";
+  public String projectName;
+
+  public ProjectDeletedEvent() {
+    super(TYPE);
+  }
+
+  @Override
+  public NameKey getProjectNameKey() {
+    return Project.nameKey(projectName);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandler.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandler.java
index 053b2fc..80d4eea 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandler.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandler.java
@@ -14,156 +14,37 @@
 
 package com.googlesource.gerrit.plugins.deleteproject.fs;
 
-import static com.google.common.io.RecursiveDeleteOption.ALLOW_INSECURE;
-
-import com.google.common.flogger.FluentLogger;
-import com.google.common.io.MoreFiles;
 import com.google.gerrit.entities.Project;
-import com.google.gerrit.extensions.api.changes.NotifyHandling;
 import com.google.gerrit.extensions.events.ProjectDeletedListener;
 import com.google.gerrit.extensions.registration.DynamicSet;
-import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.inject.Inject;
 import com.googlesource.gerrit.plugins.deleteproject.Configuration;
-import com.googlesource.gerrit.plugins.deleteproject.TimeMachine;
-import java.io.File;
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.StandardCopyOption;
-import java.time.ZoneId;
-import java.time.format.DateTimeFormatter;
-import org.apache.commons.io.FileUtils;
+import java.util.Optional;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
-import org.eclipse.jgit.lib.Repository;
-import org.eclipse.jgit.lib.RepositoryCache;
 
 public class FilesystemDeleteHandler {
-  private static final FluentLogger log = FluentLogger.forEnclosingClass();
-  private static final DateTimeFormatter FORMAT =
-      DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(ZoneId.of("UTC"));
-
-  private final GitRepositoryManager repoManager;
+  private final RepositoryDelete repositoryDelete;
   private final DynamicSet<ProjectDeletedListener> deletedListeners;
   private final Configuration config;
 
   @Inject
   public FilesystemDeleteHandler(
-      GitRepositoryManager repoManager,
+      RepositoryDelete repositoryDelete,
       DynamicSet<ProjectDeletedListener> deletedListeners,
       Configuration config) {
-    this.repoManager = repoManager;
+    this.repositoryDelete = repositoryDelete;
     this.deletedListeners = deletedListeners;
     this.config = config;
   }
 
   public void delete(Project.NameKey project, boolean preserveGitRepository)
       throws IOException, RepositoryNotFoundException {
-    // Remove from the jgit cache
-    Repository repository = repoManager.openRepository(project);
-    cleanCache(repository);
-    if (!preserveGitRepository) {
-      Path repoPath = repository.getDirectory().toPath();
-      String projectName = project.get();
-      if (config.shouldArchiveDeletedRepos()) {
-        archiveGitRepository(projectName, repoPath);
-      } else {
-        deleteGitRepository(projectName, repoPath);
-      }
-    }
-  }
-
-  private void cleanCache(Repository repository) {
-    repository.close();
-    RepositoryCache.close(repository);
-  }
-
-  private void archiveGitRepository(String projectName, Path repoPath) throws IOException {
-    Path basePath = getBasePath(repoPath, projectName);
-    Path renamedProjectDir = renameRepository(repoPath, basePath, projectName, "archived");
-    try {
-      Path archive = getArchivePath(renamedProjectDir, basePath);
-      FileUtils.copyDirectory(renamedProjectDir.toFile(), archive.toFile());
-      MoreFiles.deleteRecursively(renamedProjectDir, ALLOW_INSECURE);
-    } catch (IOException e) {
-      log.atWarning().withCause(e).log("Error trying to archive %s", renamedProjectDir);
-    }
-  }
-
-  private Path getArchivePath(Path renamedProjectDir, Path basePath) {
-    Path configArchiveRepo = config.getArchiveFolder().toAbsolutePath();
-    Path relativePath = basePath.relativize(renamedProjectDir);
-    return configArchiveRepo.resolve(relativePath);
-  }
-
-  private void deleteGitRepository(String projectName, Path repoPath) throws IOException {
-    // Delete the repository from disk
-    Path basePath = getBasePath(repoPath, projectName);
-    Path trash = renameRepository(repoPath, basePath, projectName, "deleted");
-    try {
-      MoreFiles.deleteRecursively(trash, ALLOW_INSECURE);
-      recursivelyDeleteEmptyParents(repoPath.toFile().getParentFile(), basePath.toFile());
-    } catch (IOException e) {
-      // Only log if delete failed - repo already moved to trash.
-      log.atWarning().withCause(e).log("Error trying to delete %s or its parents", trash);
-    } finally {
-      sendProjectDeletedEvent(projectName);
-    }
-  }
-
-  private Path getBasePath(Path repo, String projectName) {
-    Path projectPath = Paths.get(projectName);
-    return repo.getRoot()
-        .resolve(repo.subpath(0, repo.getNameCount() - projectPath.getNameCount()));
-  }
-
-  private Path renameRepository(Path directory, Path basePath, String projectName, String option)
-      throws IOException {
-    Path newRepo =
-        basePath.resolve(
-            projectName + "." + FORMAT.format(TimeMachine.now()) + ".%" + option + "%.git");
-    return Files.move(directory, newRepo, StandardCopyOption.ATOMIC_MOVE);
-  }
-
-  /**
-   * Recursively delete the specified file and its parent files until we hit the file {@code Until}
-   * or the parent file is populated. This is used when we have a tree structure such as a/b/c/d.git
-   * and a/b/e.git - if we delete a/b/c/d.git, we no longer need a/b/c/.
-   */
-  private void recursivelyDeleteEmptyParents(File file, File until) throws IOException {
-    if (file.equals(until)) {
-      return;
-    }
-    if (file.listFiles().length == 0) {
-      File parent = file.getParentFile();
-      Files.delete(file.toPath());
-      recursivelyDeleteEmptyParents(parent, until);
-    }
-  }
-
-  private void sendProjectDeletedEvent(String projectName) {
-    if (!deletedListeners.iterator().hasNext()) {
-      return;
-    }
-    ProjectDeletedListener.Event event =
-        new ProjectDeletedListener.Event() {
-          @Override
-          public String getProjectName() {
-            return projectName;
-          }
-
-          @Override
-          public NotifyHandling getNotify() {
-            return NotifyHandling.NONE;
-          }
-        };
-    for (ProjectDeletedListener l : deletedListeners) {
-      try {
-        l.onProjectDeleted(event);
-      } catch (RuntimeException e) {
-        log.atWarning().withCause(e).log("Failure in ProjectDeletedListener");
-      }
-    }
+    repositoryDelete.execute(
+        project,
+        preserveGitRepository,
+        config.shouldArchiveDeletedRepos(),
+        Optional.ofNullable(config.getArchiveFolder()),
+        deletedListeners);
   }
 }
diff --git a/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDelete.java b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDelete.java
new file mode 100644
index 0000000..91bded5
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDelete.java
@@ -0,0 +1,216 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.deleteproject.fs;
+
+import static com.google.common.io.RecursiveDeleteOption.ALLOW_INSECURE;
+
+import com.google.common.flogger.FluentLogger;
+import com.google.common.io.MoreFiles;
+import com.google.gerrit.common.UsedAt;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.api.changes.NotifyHandling;
+import com.google.gerrit.extensions.events.ProjectDeletedListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.googlesource.gerrit.plugins.deleteproject.TimeMachine;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Optional;
+import javax.inject.Inject;
+import org.apache.commons.io.FileUtils;
+import org.eclipse.jgit.errors.RepositoryNotFoundException;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.RepositoryCache;
+
+/**
+ * This class contains methods that remove a git repository from the filesystem and the jgit cache,
+ * and optionally notify downstream listeners. It can therefore be reused by other plugins who need
+ * to delete a git repository.
+ */
+public class RepositoryDelete {
+
+  private final GitRepositoryManager repoManager;
+
+  @Inject
+  public RepositoryDelete(GitRepositoryManager repoManager) {
+    this.repoManager = repoManager;
+  }
+
+  private static final FluentLogger log = FluentLogger.forEnclosingClass();
+  private static final DateTimeFormatter FORMAT =
+      DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(ZoneId.of("UTC"));
+
+  /**
+   * Removes a git repository from the filesystem and the jgit cache and optionally notifies
+   * downstream listeners. You can choose if the git repo should either be deleted or archived.
+   *
+   * <p>In order to delete the git directory, the logic will first rename the directory, a two-step
+   * process involving moving all the files in a different directory, and immediately deleting that
+   * directory. This helps release any open file handlers, which would on NFS filesystems prevent
+   * the directory from being empty (and therefore deletion would fail). For more details see <a
+   * href="https://bugs.chromium.org/p/gerrit/issues/detail?id=16730">...</a>
+   *
+   * @param project - the git repo name that is eligible for deletion
+   * @param preserveGitRepository - if true, just remove the repo from the git cache, but keep the
+   *     repo on disk.
+   * @param archiveDeletedRepos - if true, copy the repo to an archived path, and delete the
+   *     original directory.
+   * @param archivedFolder - only used when `archiveDeletedRepos` is true, provides the archived
+   *     directory.
+   * @param deletedListeners - a set of `ProjectDeletedListener`s - when provided these listeners
+   *     will be notified when a directory is deleted. This is not used for archiving.
+   * @throws RepositoryNotFoundException - if the repository does not exist
+   * @throws IOException - if any of the underlying operations during repo deletion fails
+   */
+  public void execute(
+      Project.NameKey project,
+      boolean preserveGitRepository,
+      boolean archiveDeletedRepos,
+      Optional<Path> archivedFolder,
+      DynamicSet<ProjectDeletedListener> deletedListeners)
+      throws RepositoryNotFoundException, IOException {
+    Repository repository = repoManager.openRepository(project);
+    cleanCache(repository);
+    if (!preserveGitRepository) {
+      Path repoPath = repository.getDirectory().toPath();
+      String projectName = project.get();
+      if (archiveDeletedRepos) {
+        archiveGitRepository(projectName, repoPath, archivedFolder);
+      } else {
+        deleteGitRepository(projectName, repoPath, deletedListeners);
+      }
+    }
+  }
+
+  /**
+   * Removes a git repository from the filesystem and the jgit cache. The git repo is neither
+   * preserved (ie kept on disk) nor archived, and no downstream listeners are notified.
+   *
+   * @param project - the git repo name that is eligible for deletion
+   * @throws RepositoryNotFoundException - if the repository does not exist
+   * @throws IOException - if any of the underlying operations during repo deletion fails
+   */
+  @UsedAt(UsedAt.Project.PLUGIN_PULL_REPLICATION)
+  public void execute(Project.NameKey project) throws RepositoryNotFoundException, IOException {
+    execute(project, false, false, Optional.empty(), DynamicSet.emptySet());
+  }
+
+  private static void cleanCache(Repository repository) {
+    repository.close();
+    RepositoryCache.close(repository);
+  }
+
+  private static void archiveGitRepository(
+      String projectName, Path repoPath, Optional<Path> archivedFolder) throws IOException {
+    Path basePath = getBasePath(repoPath, projectName);
+    if (archivedFolder.isEmpty()) {
+      throw new IllegalArgumentException(
+          "An archive path must be provided for the " + basePath + " repo to be archived");
+    }
+    Path renamedProjectDir = renameRepository(repoPath, basePath, projectName, "archived");
+    try {
+      Path archive = getArchivePath(archivedFolder.get(), renamedProjectDir, basePath);
+      FileUtils.copyDirectory(renamedProjectDir.toFile(), archive.toFile());
+      MoreFiles.deleteRecursively(renamedProjectDir, ALLOW_INSECURE);
+    } catch (IOException e) {
+      log.atWarning().withCause(e).log("Error trying to archive %s", renamedProjectDir);
+    }
+  }
+
+  private static Path getArchivePath(Path archivedFolder, Path renamedProjectDir, Path basePath) {
+    Path configArchiveRepo = archivedFolder.toAbsolutePath();
+    Path relativePath = basePath.relativize(renamedProjectDir);
+    return configArchiveRepo.resolve(relativePath);
+  }
+
+  private static void deleteGitRepository(
+      String projectName, Path repoPath, DynamicSet<ProjectDeletedListener> deletedListeners)
+      throws IOException {
+    // Delete the repository from disk
+    Path basePath = getBasePath(repoPath, projectName);
+    Path trash = renameRepository(repoPath, basePath, projectName, "deleted");
+    try {
+      MoreFiles.deleteRecursively(trash, ALLOW_INSECURE);
+      recursivelyDeleteEmptyParents(repoPath.toFile().getParentFile(), basePath.toFile());
+    } catch (IOException e) {
+      // Only log if delete failed - repo already moved to trash.
+      log.atWarning().withCause(e).log("Error trying to delete %s or its parents", trash);
+    } finally {
+      sendProjectDeletedEvent(projectName, deletedListeners);
+    }
+  }
+
+  private static Path getBasePath(Path repo, String projectName) {
+    Path projectPath = Paths.get(projectName);
+    return repo.getRoot()
+        .resolve(repo.subpath(0, repo.getNameCount() - projectPath.getNameCount()));
+  }
+
+  private static Path renameRepository(
+      Path directory, Path basePath, String projectName, String option) throws IOException {
+    Path newRepo =
+        basePath.resolve(
+            projectName + "." + FORMAT.format(TimeMachine.now()) + ".%" + option + "%.git");
+    return Files.move(directory, newRepo, StandardCopyOption.ATOMIC_MOVE);
+  }
+
+  /**
+   * Recursively delete the specified file and its parent files until we hit the file {@code Until}
+   * or the parent file is populated. This is used when we have a tree structure such as a/b/c/d.git
+   * and a/b/e.git - if we delete a/b/c/d.git, we no longer need a/b/c/.
+   */
+  private static void recursivelyDeleteEmptyParents(File file, File until) throws IOException {
+    if (file.equals(until)) {
+      return;
+    }
+    if (file.listFiles().length == 0) {
+      File parent = file.getParentFile();
+      Files.delete(file.toPath());
+      recursivelyDeleteEmptyParents(parent, until);
+    }
+  }
+
+  private static void sendProjectDeletedEvent(
+      String projectName, DynamicSet<ProjectDeletedListener> deletedListeners) {
+    if (!deletedListeners.iterator().hasNext()) {
+      return;
+    }
+    ProjectDeletedListener.Event event =
+        new ProjectDeletedListener.Event() {
+          @Override
+          public String getProjectName() {
+            return projectName;
+          }
+
+          @Override
+          public NotifyHandling getNotify() {
+            return NotifyHandling.NONE;
+          }
+        };
+    for (ProjectDeletedListener l : deletedListeners) {
+      try {
+        l.onProjectDeleted(event);
+      } catch (RuntimeException e) {
+        log.atWarning().withCause(e).log("Failure in ProjectDeletedListener");
+      }
+    }
+  }
+}
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
index b72ee3a..2f0e7f6 100644
--- a/src/main/resources/Documentation/about.md
+++ b/src/main/resources/Documentation/about.md
@@ -35,6 +35,28 @@
 can be configured to listen to the project deletion event and to
 replicate project deletions.
 
+Event after project deletion
+-----------------------------------
+
+This plugin generates an event after project deletion. Format of
+the event:
+
+=== Project Deleted
+
+Sent after project deletion.
+
+type:: "project-deleted"
+
+projectName:: Name of the deleted project
+
+eventCreatedOn:: Time in seconds since the UNIX epoch when this event was
+created.
+
+*NOTE*: This event will be delivered only to the unrestricted listeners.
+Unrestricted events listeners implement
+`com.google.gerrit.server.events.EventListener` without performing any
+permission checking.
+
 Access
 ------
 
diff --git a/src/test/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEventTest.java b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEventTest.java
new file mode 100644
index 0000000..07e3ee4
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/ProjectDeletedEventTest.java
@@ -0,0 +1,99 @@
+// Copyright (C) 2022 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.deleteproject;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.entities.Project.NameKey;
+import com.google.gerrit.extensions.registration.DynamicItem;
+import com.google.gerrit.server.CurrentUser;
+import com.google.gerrit.server.IdentifiedUser;
+import com.google.gerrit.server.events.EventDispatcher;
+import com.google.gerrit.server.project.ProjectResource;
+import com.google.gerrit.server.project.ProjectState;
+import com.google.inject.Provider;
+import com.googlesource.gerrit.plugins.deleteproject.DeleteProject.Input;
+import com.googlesource.gerrit.plugins.deleteproject.cache.CacheDeleteHandler;
+import com.googlesource.gerrit.plugins.deleteproject.database.DatabaseDeleteHandler;
+import com.googlesource.gerrit.plugins.deleteproject.fs.FilesystemDeleteHandler;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProjectDeletedEventTest {
+
+  private static final NameKey PROJECT_NAME_KEY = Project.nameKey("test-project");
+  private static final String INSTANCE_ID = "test-instance-id";
+
+  @Mock private DatabaseDeleteHandler dbHandler;
+  @Mock private FilesystemDeleteHandler fsHandler;
+  @Mock private CacheDeleteHandler cacheHandler;
+  @Mock private Provider<CurrentUser> userProvider;
+  @Mock private DeleteLog deleteLog;
+  @Mock private DeletePreconditions preConditions;
+  @Mock private Configuration cfg;
+  @Mock private EventDispatcher dispatcher;
+  @Mock private DynamicItem<EventDispatcher> dispatcherProvider;
+  @Mock private HideProject hideProject;
+  @Mock private IdentifiedUser currentUser;
+  @Mock private ProjectState state;
+  @Captor private ArgumentCaptor<ProjectDeletedEvent> projectDeletedEventCaptor;
+
+  private Project project = Project.builder(PROJECT_NAME_KEY).build();
+
+  private DeleteProject objectUnderTest;
+
+  @Before
+  public void setup() throws Exception {
+    when(dispatcherProvider.get()).thenReturn(dispatcher);
+    when(userProvider.get()).thenReturn(currentUser);
+    when(state.getProject()).thenReturn(project);
+    objectUnderTest =
+        new DeleteProject(
+            dbHandler,
+            fsHandler,
+            cacheHandler,
+            userProvider,
+            deleteLog,
+            preConditions,
+            cfg,
+            hideProject,
+            dispatcherProvider,
+            INSTANCE_ID);
+  }
+
+  @Test
+  public void shouldSendProjectDeletedEventAfterProjectDeletion() throws Exception {
+    Input input = new Input();
+    input.force = false;
+    input.preserve = false;
+    objectUnderTest.doDelete(new ProjectResource(state, currentUser), input);
+
+    verify(dispatcher).postEvent(eq(PROJECT_NAME_KEY), projectDeletedEventCaptor.capture());
+    ProjectDeletedEvent event = projectDeletedEventCaptor.getValue();
+    assertThat(event.instanceId).isEqualTo(INSTANCE_ID);
+    assertThat(event.getProjectNameKey()).isEqualTo(PROJECT_NAME_KEY);
+    assertThat(event.type).isEqualTo(ProjectDeletedEvent.TYPE);
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandlerTest.java b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandlerTest.java
index 9cffd14..317de9b 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandlerTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/FilesystemDeleteHandlerTest.java
@@ -14,128 +14,54 @@
 
 package com.googlesource.gerrit.plugins.deleteproject.fs;
 
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Mockito.when;
-
 import com.google.gerrit.entities.Project;
 import com.google.gerrit.extensions.events.ProjectDeletedListener;
 import com.google.gerrit.extensions.registration.DynamicSet;
-import com.google.gerrit.server.git.GitRepositoryManager;
 import com.googlesource.gerrit.plugins.deleteproject.Configuration;
-import java.io.IOException;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.PathMatcher;
-import java.util.stream.Stream;
-import org.eclipse.jgit.internal.storage.file.FileRepository;
-import org.eclipse.jgit.lib.Repository;
+import java.util.Optional;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 public class FilesystemDeleteHandlerTest {
 
-  @Mock private GitRepositoryManager repoManager;
+  @Mock private RepositoryDelete repositoryDelete;
   @Mock private ProjectDeletedListener projectDeleteListener;
   @Mock private Configuration config;
 
   @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
 
-  private DynamicSet<ProjectDeletedListener> deletedListener;
-  private FilesystemDeleteHandler fsDeleteHandler;
+  private DynamicSet<ProjectDeletedListener> deletedListeners;
   private Path basePath;
 
   @Before
   public void setUp() throws Exception {
-    basePath = tempFolder.newFolder().toPath().resolve("base");
-    deletedListener = new DynamicSet<>();
-    deletedListener.add("", projectDeleteListener);
+    basePath = tempFolder.newFolder().toPath().resolve("archive");
+    deletedListeners = new DynamicSet<>();
+    deletedListeners.add("", projectDeleteListener);
   }
 
   @Test
-  public void shouldDeleteRepository() throws Exception {
-    String repoName = "testRepo";
-    Repository repository = createRepository(repoName);
-    Project.NameKey nameKey = Project.nameKey(repoName);
-    when(repoManager.openRepository(nameKey)).thenReturn(repository);
-    when(config.shouldArchiveDeletedRepos()).thenReturn(false);
-    fsDeleteHandler = new FilesystemDeleteHandler(repoManager, deletedListener, config);
-    fsDeleteHandler.delete(nameKey, false);
-    assertThat(repository.getDirectory().exists()).isFalse();
-  }
+  public void shouldExtractArchivingParamsFromConfig() throws Exception {
+    boolean doArchive = true;
+    Project.NameKey project = Project.NameKey.parse("testProject");
+    boolean noPreserveGitRepository = false;
 
-  @Test
-  public void shouldDeleteEmptyParentFolders() throws Exception {
-    String repoName = "a/b/c";
-    Repository repository = createRepository(repoName);
-    Project.NameKey nameKey = Project.nameKey(repoName);
-    when(repoManager.openRepository(nameKey)).thenReturn(repository);
-    fsDeleteHandler = new FilesystemDeleteHandler(repoManager, deletedListener, config);
-    fsDeleteHandler.delete(nameKey, false);
-    assertThat(repository.getDirectory().exists()).isFalse();
-  }
+    Mockito.when(config.shouldArchiveDeletedRepos()).thenReturn(doArchive);
+    Mockito.when(config.getArchiveFolder()).thenReturn(basePath);
 
-  @Test
-  public void shouldKeepCommonFolders() throws Exception {
-    String repoToDeleteName = "a/b/c/d";
-    Repository repoToDelete = createRepository(repoToDeleteName);
-
-    String repoToKeepName = "a/b/e";
-    Repository repoToKeep = createRepository(repoToKeepName);
-
-    Project.NameKey nameKey = Project.nameKey(repoToDeleteName);
-    when(repoManager.openRepository(nameKey)).thenReturn(repoToDelete);
-    fsDeleteHandler = new FilesystemDeleteHandler(repoManager, deletedListener, config);
-    fsDeleteHandler.delete(nameKey, false);
-    assertThat(repoToDelete.getDirectory().exists()).isFalse();
-    assertThat(repoToKeep.getDirectory().exists()).isTrue();
-  }
-
-  @Test
-  public void shouldPreserveRepository() throws Exception {
-    String repoName = "preservedRepo";
-    Repository repository = createRepository(repoName);
-    Project.NameKey nameKey = Project.nameKey(repoName);
-    when(repoManager.openRepository(nameKey)).thenReturn(repository);
-    fsDeleteHandler = new FilesystemDeleteHandler(repoManager, deletedListener, config);
-    fsDeleteHandler.delete(nameKey, true);
-    assertThat(repository.getDirectory().exists()).isTrue();
-  }
-
-  private FileRepository createRepository(String repoName) throws IOException {
-    Path repoPath = Files.createDirectories(basePath.resolve(repoName));
-    Repository repository = new FileRepository(repoPath.toFile());
-    repository.create(true);
-    return (FileRepository) repository;
-  }
-
-  @Test
-  public void archiveRepository() throws Exception {
-    String repoName = "parent_project/p3";
-    Repository repository = createRepository(repoName);
-    Path archiveFolder = basePath.resolve("test_archive");
-    when(config.shouldArchiveDeletedRepos()).thenReturn(true);
-    when(config.getArchiveFolder()).thenReturn(archiveFolder);
-    Project.NameKey nameKey = Project.nameKey(repoName);
-    when(repoManager.openRepository(nameKey)).thenReturn(repository);
-    fsDeleteHandler = new FilesystemDeleteHandler(repoManager, deletedListener, config);
-    fsDeleteHandler.delete(nameKey, false);
-    assertThat(repository.getDirectory().exists()).isFalse();
-    String patternToVerify = archiveFolder.resolve(repoName).toString() + "*%archived%.git";
-    assertThat(pathExistsWithPattern(archiveFolder, patternToVerify)).isTrue();
-  }
-
-  private boolean pathExistsWithPattern(Path archiveFolder, String patternToVerify)
-      throws IOException {
-    PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + patternToVerify);
-    try (Stream<Path> stream = Files.walk(archiveFolder)) {
-      return stream.anyMatch(matcher::matches);
-    }
+    FilesystemDeleteHandler filesystemDeleteHandler =
+        new FilesystemDeleteHandler(repositoryDelete, deletedListeners, config);
+    filesystemDeleteHandler.delete(project, noPreserveGitRepository);
+    Mockito.verify(repositoryDelete)
+        .execute(
+            project, noPreserveGitRepository, doArchive, Optional.of(basePath), deletedListeners);
   }
 }
diff --git a/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDeleteTest.java b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDeleteTest.java
new file mode 100644
index 0000000..512b8b5
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/deleteproject/fs/RepositoryDeleteTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.googlesource.gerrit.plugins.deleteproject.fs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.when;
+
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.extensions.events.ProjectDeletedListener;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.extensions.registration.RegistrationHandle;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.Optional;
+import java.util.stream.Stream;
+import org.eclipse.jgit.internal.storage.file.FileRepository;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RepositoryDeleteTest {
+
+  private static final Optional<Path> NO_ARCHIVE_PATH = Optional.empty();
+
+  @Mock private GitRepositoryManager repoManager;
+  @Mock private ProjectDeletedListener projectDeleteListener;
+
+  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+
+  private DynamicSet<ProjectDeletedListener> deletedListeners;
+  private RegistrationHandle handle;
+  private RepositoryDelete repositoryDelete;
+  private Path basePath;
+
+  @Before
+  public void setUp() throws Exception {
+    deletedListeners = new DynamicSet<>();
+    handle = deletedListeners.add("testPlugin", projectDeleteListener);
+    basePath = tempFolder.newFolder().toPath().resolve("base");
+  }
+
+  @Test
+  public void shouldDeleteRepository() throws Exception {
+    String repoName = "testRepo";
+    Repository repository = createRepository(repoName);
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey);
+    assertThat(repository.getDirectory().exists()).isFalse();
+  }
+
+  @Test
+  public void shouldDeleteEmptyParentFolders() throws Exception {
+    String repoName = "a/b/c";
+    Repository repository = createRepository(repoName);
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey);
+    assertThat(repository.getDirectory().exists()).isFalse();
+  }
+
+  @Test
+  public void shouldKeepCommonFolders() throws Exception {
+    String repoToDeleteName = "a/b/c/d";
+    Repository repoToDelete = createRepository(repoToDeleteName);
+
+    String repoToKeepName = "a/b/e";
+    Repository repoToKeep = createRepository(repoToKeepName);
+
+    Project.NameKey nameKey = Project.nameKey(repoToDeleteName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repoToDelete);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey);
+    assertThat(repoToDelete.getDirectory().exists()).isFalse();
+    assertThat(repoToKeep.getDirectory().exists()).isTrue();
+  }
+
+  @Test
+  public void shouldPreserveRepository() throws Exception {
+    String repoName = "preservedRepo";
+    Repository repository = createRepository(repoName);
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey, true, false, NO_ARCHIVE_PATH, deletedListeners);
+    assertThat(repository.getDirectory().exists()).isTrue();
+  }
+
+  private FileRepository createRepository(String repoName) throws IOException {
+    Path repoPath = Files.createDirectories(basePath.resolve(repoName));
+    Repository repository = new FileRepository(repoPath.toFile());
+    repository.create(true);
+    return (FileRepository) repository;
+  }
+
+  @Test
+  public void archiveRepository() throws Exception {
+    String repoName = "parent_project/p3";
+    Repository repository = createRepository(repoName);
+    Path archiveFolder = basePath.resolve("test_archive");
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey, false, true, Optional.of(archiveFolder), deletedListeners);
+    assertThat(repository.getDirectory().exists()).isFalse();
+    String patternToVerify = archiveFolder.resolve(repoName).toString() + "*%archived%.git";
+    assertThat(pathExistsWithPattern(archiveFolder, patternToVerify)).isTrue();
+  }
+
+  @Test
+  public void shouldNotifyListenersOnSuccessfulRepoDeletion() throws Exception {
+    String repoName = "testRepo";
+    Repository repository = createRepository(repoName);
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    repositoryDelete.execute(nameKey, false, false, NO_ARCHIVE_PATH, deletedListeners);
+    Mockito.verify(projectDeleteListener).onProjectDeleted(any());
+  }
+
+  @Test
+  public void shouldNotNotifyListenersIfTheListenersSetIsEmpty() throws Exception {
+    String repoName = "testRepo";
+    Repository repository = createRepository(repoName);
+    Project.NameKey nameKey = Project.nameKey(repoName);
+    when(repoManager.openRepository(nameKey)).thenReturn(repository);
+    repositoryDelete = new RepositoryDelete(repoManager);
+    handle.remove();
+    repositoryDelete.execute(nameKey, false, false, NO_ARCHIVE_PATH, deletedListeners);
+    Mockito.verify(projectDeleteListener, never()).onProjectDeleted(any());
+  }
+
+  private boolean pathExistsWithPattern(Path archiveFolder, String patternToVerify)
+      throws IOException {
+    PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + patternToVerify);
+    try (Stream<Path> stream = Files.walk(archiveFolder)) {
+      return stream.anyMatch(matcher::matches);
+    }
+  }
+}