Add a project healing endpoint

delta/app/src/main/scala/ch/epfl/bluebrain/nexus/delta/routes/SupervisionRoutes.scala

@@ -4,21 +4,22 @@ import akka.http.scaladsl.model.StatusCodes
 import akka.http.scaladsl.server._
 import cats.effect.IO
 import cats.effect.unsafe.implicits.global
+import cats.implicits.catsSyntaxApplicativeError
 import ch.epfl.bluebrain.nexus.delta.rdf.Vocabulary.contexts
 import ch.epfl.bluebrain.nexus.delta.rdf.jsonld.context.{ContextValue, RemoteContextResolution}
 import ch.epfl.bluebrain.nexus.delta.rdf.jsonld.encoder.JsonLdEncoder
 import ch.epfl.bluebrain.nexus.delta.rdf.utils.JsonKeyOrdering
-import ch.epfl.bluebrain.nexus.delta.routes.SupervisionRoutes.{allProjectsAreHealthy, unhealthyProjectsEncoder, SupervisionBundle}
+import ch.epfl.bluebrain.nexus.delta.routes.SupervisionRoutes.{allProjectsAreHealthy, healingSuccessful, unhealthyProjectsEncoder, SupervisionBundle}
 import ch.epfl.bluebrain.nexus.delta.sdk.acls.AclCheck
 import ch.epfl.bluebrain.nexus.delta.sdk.acls.model.AclAddress
 import ch.epfl.bluebrain.nexus.delta.sdk.directives.DeltaDirectives.emit
-import ch.epfl.bluebrain.nexus.delta.sdk.directives.UriDirectives.baseUriPrefix
+import ch.epfl.bluebrain.nexus.delta.sdk.directives.UriDirectives.{baseUriPrefix, projectRef}
 import ch.epfl.bluebrain.nexus.delta.sdk.directives._
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.Identities
 import ch.epfl.bluebrain.nexus.delta.sdk.marshalling.RdfMarshalling
 import ch.epfl.bluebrain.nexus.delta.sdk.model.BaseUri
-import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.supervision
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ProjectsHealth
+import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.{projects, supervision}
+import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.{ProjectHealer, ProjectRejection, ProjectsHealth}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.ProjectRef
 import ch.epfl.bluebrain.nexus.delta.sourcing.stream.SupervisedDescription
 import io.circe.generic.semiauto.deriveEncoder
@@ -29,7 +30,8 @@ class SupervisionRoutes(
     identities: Identities,
     aclCheck: AclCheck,
     supervised: IO[List[SupervisedDescription]],
-    projectsHealth: ProjectsHealth
+    projectsHealth: ProjectsHealth,
+    projectHealer: ProjectHealer
 )(implicit
     baseUri: BaseUri,
     cr: RemoteContextResolution,
@@ -41,21 +43,31 @@ class SupervisionRoutes(
     baseUriPrefix(baseUri.prefix) {
       pathPrefix("supervision") {
         extractCaller { implicit caller =>
-          get {
+          concat(
             authorizeFor(AclAddress.Root, supervision.read).apply {
               concat(
-                (pathPrefix("projections") & pathEndOrSingleSlash) {
+                (pathPrefix("projections") & get & pathEndOrSingleSlash) {
                   emit(supervised.map(SupervisionBundle))
                 },
-                (pathPrefix("projects") & pathEndOrSingleSlash) {
+                (pathPrefix("projects") & get & pathEndOrSingleSlash) {
                   onSuccess(projectsHealth.health.unsafeToFuture()) { projects =>
                     if (projects.isEmpty) emit(StatusCodes.OK, IO.pure(allProjectsAreHealthy))
                     else emit(StatusCodes.InternalServerError, IO.pure(unhealthyProjectsEncoder(projects)))
                   }
                 }
               )
+            },
+            authorizeFor(AclAddress.Root, projects.write).apply {
+              (post & pathPrefix("projects") & projectRef & pathPrefix("heal") & pathEndOrSingleSlash) { project =>
+                emit(
+                  projectHealer
+                    .heal(project)
+                    .map(_ => healingSuccessful(project))
+                    .attemptNarrow[ProjectRejection]
+                )
+              }
             }
-          }
+          )
         }
       }
     }
@@ -79,4 +91,7 @@ object SupervisionRoutes {
       Json.obj("status" := "Some projects are unhealthy.", "unhealthyProjects" := set)
     }
 
+  private def healingSuccessful(project: ProjectRef) =
+    Json.obj("message" := s"Project '$project' has been healed.")
+
 }

delta/app/src/main/scala/ch/epfl/bluebrain/nexus/delta/wiring/ProjectsModule.scala

@@ -23,7 +23,7 @@ import ch.epfl.bluebrain.nexus.delta.sdk.organizations.model.OrganizationRejecti
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.FetchContext.ContextRejection
 import ch.epfl.bluebrain.nexus.delta.sdk.projects._
 import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ProjectRejection.WrappedOrganizationRejection
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.{ApiMappings, Project, ProjectEvent, ProjectsHealth}
+import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.{ApiMappings, Project, ProjectEvent, ProjectHealer, ProjectsHealth}
 import ch.epfl.bluebrain.nexus.delta.sdk.provisioning.ProjectProvisioning
 import ch.epfl.bluebrain.nexus.delta.sdk.quotas.Quotas
 import ch.epfl.bluebrain.nexus.delta.sdk.sse.SseEncoder
@@ -79,6 +79,11 @@ object ProjectsModule extends ModuleDef {
     ProjectsHealth(errorStore)
   }
 
+  make[ProjectHealer].from(
+    (errorStore: ScopeInitializationErrorStore, scopeInitializer: ScopeInitializer, serviceAccount: ServiceAccount) =>
+      ProjectHealer(errorStore, scopeInitializer, serviceAccount)
+  )
+
   make[ProjectsStatistics].fromEffect { (xas: Transactors) =>
     ProjectsStatistics(xas)
   }

delta/app/src/main/scala/ch/epfl/bluebrain/nexus/delta/wiring/SupervisionModule.scala

@@ -10,7 +10,7 @@ import ch.epfl.bluebrain.nexus.delta.sdk.PriorityRoute
 import ch.epfl.bluebrain.nexus.delta.sdk.acls.AclCheck
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.Identities
 import ch.epfl.bluebrain.nexus.delta.sdk.model.BaseUri
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ProjectsHealth
+import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.{ProjectHealer, ProjectsHealth}
 import ch.epfl.bluebrain.nexus.delta.sourcing.stream.Supervisor
 import izumi.distage.model.definition.{Id, ModuleDef}
 
@@ -30,9 +30,16 @@ object SupervisionModule extends ModuleDef {
         baseUri: BaseUri,
         rc: RemoteContextResolution @Id("aggregate"),
         jo: JsonKeyOrdering,
-        projectsHealth: ProjectsHealth
+        projectsHealth: ProjectsHealth,
+        projectHealer: ProjectHealer
     ) =>
-      new SupervisionRoutes(identities, aclCheck, supervisor.getRunningProjections(), projectsHealth)(baseUri, rc, jo)
+      new SupervisionRoutes(
+        identities,
+        aclCheck,
+        supervisor.getRunningProjections(),
+        projectsHealth,
+        projectHealer
+      )(baseUri, rc, jo)
   }
 
   many[RemoteContextResolution].addEffect(

delta/app/src/test/scala/ch/epfl/bluebrain/nexus/delta/routes/SupervisionRoutesSpec.scala

@@ -3,18 +3,21 @@ package ch.epfl.bluebrain.nexus.delta.routes
 import akka.http.scaladsl.model.StatusCodes
 import akka.http.scaladsl.model.headers.OAuth2BearerToken
 import akka.http.scaladsl.server.Route
-import cats.effect.IO
+import cats.effect.{IO, Ref}
 import ch.epfl.bluebrain.nexus.delta.sdk.acls.AclSimpleCheck
 import ch.epfl.bluebrain.nexus.delta.sdk.acls.model.AclAddress
+import ch.epfl.bluebrain.nexus.delta.sdk.error.ServiceError.ScopeInitializationFailed
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.IdentitiesDummy
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.model.Caller
-import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.supervision
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ProjectsHealth
+import ch.epfl.bluebrain.nexus.delta.sdk.permissions.Permissions.{projects, supervision}
+import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.ProjectRejection.ProjectInitializationFailed
+import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.{ProjectHealer, ProjectsHealth}
 import ch.epfl.bluebrain.nexus.delta.sdk.utils.BaseRouteSpec
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Identity.{Anonymous, Authenticated, Group, User}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.{Label, ProjectRef}
 import ch.epfl.bluebrain.nexus.delta.sourcing.offset.Offset
 import ch.epfl.bluebrain.nexus.delta.sourcing.stream._
+import org.scalatest.Assertion
 
 import java.time.Instant
 
@@ -42,25 +45,45 @@ class SupervisionRoutesSpec extends BaseRouteSpec {
   private val description2 =
     SupervisedDescription(metadata, ExecutionStrategy.TransientSingleNode, 0, ExecutionStatus.Running, progress)
 
-  def projectsHealth(unhealthyProjects: Set[ProjectRef]) =
+  private def projectsHealth(unhealthyProjects: Set[ProjectRef]) =
     new ProjectsHealth {
       override def health: IO[Set[ProjectRef]] = IO.pure(unhealthyProjects)
     }
 
-  private def routesTemplate(unhealthyProjects: Set[ProjectRef]) = Route.seal(
+  // A project healer that can be used to assert that the heal method was called on a specific project
+  class MockProjectHealer extends ProjectHealer {
+    private val healerWasExecuted                                = Ref.unsafe[IO, Set[ProjectRef]](Set.empty)
+    override def heal(project: ProjectRef): IO[Unit]             = healerWasExecuted.update(_ + project)
+    def assertHealWasCalledOn(project: ProjectRef): Assertion    =
+      healerWasExecuted.get.map(_ should contain(project)).accepted
+    def assertHealWasNotCalledOn(project: ProjectRef): Assertion =
+      healerWasExecuted.get.map(_ should not contain project).accepted
+  }
+
+  private val failingHealer = new ProjectHealer {
+    override def heal(project: ProjectRef): IO[Unit] =
+      IO.raiseError(ProjectInitializationFailed(ScopeInitializationFailed("failure details")))
+  }
+
+  private val noopHealer = new ProjectHealer {
+    override def heal(project: ProjectRef): IO[Unit] = IO.unit
+  }
+
+  private def routesTemplate(unhealthyProjects: Set[ProjectRef], healer: ProjectHealer) = Route.seal(
     new SupervisionRoutes(
       identities,
       aclCheck,
       IO.pure { List(description1, description2) },
-      projectsHealth(unhealthyProjects)
+      projectsHealth(unhealthyProjects),
+      healer
     ).routes
   )
 
-  private val routes = routesTemplate(Set.empty)
+  private val routes = routesTemplate(Set.empty, noopHealer)
 
   override def beforeAll(): Unit = {
     super.beforeAll()
-    aclCheck.append(AclAddress.Root, superviser -> Set(supervision.read)).accepted
+    aclCheck.append(AclAddress.Root, superviser -> Set(supervision.read, projects.write)).accepted
   }
 
   "The supervision projection endpoint" should {
@@ -89,14 +112,14 @@ class SupervisionRoutesSpec extends BaseRouteSpec {
     }
 
     "return a successful http code when there are no unhealthy projects" in {
-      val routesWithHealthyProjects = routesTemplate(Set.empty)
+      val routesWithHealthyProjects = routesTemplate(Set.empty, noopHealer)
       Get("/v1/supervision/projects") ~> asSuperviser ~> routesWithHealthyProjects ~> check {
         response.status shouldEqual StatusCodes.OK
       }
     }
 
     "return an error code when there are unhealthy projects" in {
-      val routesWithUnhealthyProjects = routesTemplate(unhealthyProjects)
+      val routesWithUnhealthyProjects = routesTemplate(unhealthyProjects, noopHealer)
       Get("/v1/supervision/projects") ~> asSuperviser ~> routesWithUnhealthyProjects ~> check {
         response.status shouldEqual StatusCodes.InternalServerError
         response.asJson shouldEqual
@@ -114,4 +137,51 @@ class SupervisionRoutesSpec extends BaseRouteSpec {
 
   }
 
+  "The projects healing endpoint" should {
+    "be forbidden without projects/write permission" in {
+      val projectHealer    = new MockProjectHealer
+      val project          = ProjectRef(Label.unsafe("myorg"), Label.unsafe("myproject"))
+      val routesWithHealer = routesTemplate(Set.empty, projectHealer)
+
+      Post(s"/v1/supervision/projects/$project/heal") ~> routesWithHealer ~> check {
+        response.shouldBeForbidden
+      }
+      projectHealer.assertHealWasNotCalledOn(project)
+    }
+
+    "succeed and execute the healer" in {
+      val projectHealer    = new MockProjectHealer
+      val project          = ProjectRef(Label.unsafe("myorg"), Label.unsafe("myproject"))
+      val routesWithHealer = routesTemplate(Set.empty, projectHealer)
+
+      Post(s"/v1/supervision/projects/$project/heal") ~> asSuperviser ~> routesWithHealer ~> check {
+        response.status shouldEqual StatusCodes.OK
+        response.asJson shouldEqual
+          json"""
+            {
+                "message" : "Project 'myorg/myproject' has been healed."
+            }
+              """
+      }
+      projectHealer.assertHealWasCalledOn(project)
+    }
+
+    "return an error if the healing failed" in {
+      val routesWithFailingHealer = routesTemplate(Set.empty, failingHealer)
+      Post("/v1/supervision/projects/myorg/myproject/heal") ~> asSuperviser ~> routesWithFailingHealer ~> check {
+        response.status shouldEqual StatusCodes.InternalServerError
+        response.asJson shouldEqual
+          json"""
+            {
+              "@context" : "https://bluebrain.github.io/nexus/contexts/error.json",
+              "@type" : "ProjectInitializationFailed",
+              "reason" : "The project has been successfully created but it could not be initialized correctly",
+              "details" : "failure details"
+            }
+              """
+      }
+    }
+
+  }
+
 }

delta/plugins/blazegraph/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/blazegraph/BlazegraphScopeInitialization.scala

@@ -10,10 +10,9 @@ import ch.epfl.bluebrain.nexus.delta.plugins.blazegraph.model._
 import ch.epfl.bluebrain.nexus.delta.sdk.error.ServiceError.ScopeInitializationFailed
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.model.ServiceAccount
 import ch.epfl.bluebrain.nexus.delta.sdk.organizations.model.Organization
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.Project
 import ch.epfl.bluebrain.nexus.delta.sdk.{Defaults, ScopeInitialization}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Identity.Subject
-import ch.epfl.bluebrain.nexus.delta.sourcing.model.{EntityType, Identity, IriFilter}
+import ch.epfl.bluebrain.nexus.delta.sourcing.model._
 
 /**
   * The default creation of the default SparqlView as part of the project initialization.
@@ -46,16 +45,16 @@ class BlazegraphScopeInitialization(
     permission = permissions.query
   )
 
-  override def onProjectCreation(project: Project, subject: Identity.Subject): IO[Unit] =
+  override def onProjectCreation(project: ProjectRef, subject: Identity.Subject): IO[Unit] =
     views
-      .create(defaultViewId, project.ref, defaultValue)
+      .create(defaultViewId, project, defaultValue)
       .void
       .handleErrorWith {
         case _: ResourceAlreadyExists   => IO.unit // nothing to do, view already exits
         case _: ProjectContextRejection => IO.unit // project or org are likely deprecated
         case rej                        =>
           val str =
-            s"Failed to create the default SparqlView for project '${project.ref}' due to '${rej.getMessage}'."
+            s"Failed to create the default SparqlView for project '$project' due to '${rej.getMessage}'."
           logger.error(str) >> IO.raiseError(ScopeInitializationFailed(str))
       }
       .span("createDefaultSparqlView")

delta/plugins/blazegraph/src/test/scala/ch/epfl/bluebrain/nexus/delta/plugins/blazegraph/BlazegraphScopeInitializationSpec.scala

@@ -65,7 +65,7 @@ class BlazegraphScopeInitializationSpec
 
     "create a default SparqlView on newly created project" in {
       views.fetch(defaultViewId, project.ref).rejectedWith[ViewNotFound]
-      init.onProjectCreation(project, bob).accepted
+      init.onProjectCreation(project.ref, bob).accepted
       val resource = views.fetch(defaultViewId, project.ref).accepted
       resource.value match {
         case v: IndexingBlazegraphView  =>
@@ -85,7 +85,7 @@ class BlazegraphScopeInitializationSpec
 
     "not create a default SparqlView if one already exists" in {
       views.fetch(defaultViewId, project.ref).accepted.rev shouldEqual 1L
-      init.onProjectCreation(project, bob).accepted
+      init.onProjectCreation(project.ref, bob).accepted
       views.fetch(defaultViewId, project.ref).accepted.rev shouldEqual 1L
     }
   }

delta/plugins/elasticsearch/src/main/scala/ch/epfl/bluebrain/nexus/delta/plugins/elasticsearch/ElasticSearchScopeInitialization.scala

@@ -10,11 +10,10 @@ import ch.epfl.bluebrain.nexus.delta.plugins.elasticsearch.model.{defaultViewId,
 import ch.epfl.bluebrain.nexus.delta.sdk.error.ServiceError.ScopeInitializationFailed
 import ch.epfl.bluebrain.nexus.delta.sdk.identities.model.ServiceAccount
 import ch.epfl.bluebrain.nexus.delta.sdk.organizations.model.Organization
-import ch.epfl.bluebrain.nexus.delta.sdk.projects.model.Project
 import ch.epfl.bluebrain.nexus.delta.sdk.views.PipeStep
 import ch.epfl.bluebrain.nexus.delta.sdk.{Defaults, ScopeInitialization}
 import ch.epfl.bluebrain.nexus.delta.sourcing.model.Identity.Subject
-import ch.epfl.bluebrain.nexus.delta.sourcing.model.{EntityType, Identity}
+import ch.epfl.bluebrain.nexus.delta.sourcing.model.{EntityType, Identity, ProjectRef}
 import ch.epfl.bluebrain.nexus.delta.sourcing.stream.pipes.{DefaultLabelPredicates, SourceAsText}
 
 /**
@@ -49,16 +48,16 @@ class ElasticSearchScopeInitialization(
       permission = permissions.query
     )
 
-  override def onProjectCreation(project: Project, subject: Identity.Subject): IO[Unit] =
+  override def onProjectCreation(project: ProjectRef, subject: Identity.Subject): IO[Unit] =
     views
-      .create(defaultViewId, project.ref, defaultValue)
+      .create(defaultViewId, project, defaultValue)
       .void
       .handleErrorWith {
         case _: ResourceAlreadyExists   => IO.unit // nothing to do, view already exits
         case _: ProjectContextRejection => IO.unit // project or org are likely deprecated
         case rej                        =>
           val str =
-            s"Failed to create the default ElasticSearchView for project '${project.ref}' due to '${rej.getMessage}'."
+            s"Failed to create the default ElasticSearchView for project '$project' due to '${rej.getMessage}'."
           logger.error(str) >> IO.raiseError(ScopeInitializationFailed(str))
       }
       .span("createDefaultElasticSearchView")

delta/plugins/elasticsearch/src/test/scala/ch/epfl/bluebrain/nexus/delta/plugins/elasticsearch/ElasticSearchScopeInitializationSpec.scala

@@ -65,7 +65,7 @@ class ElasticSearchScopeInitializationSpec
 
     "create a default ElasticSearchView on a newly created project" in {
       views.fetch(defaultViewId, project.ref).rejectedWith[ViewNotFound]
-      init.onProjectCreation(project, bob).accepted
+      init.onProjectCreation(project.ref, bob).accepted
       val resource = views.fetch(defaultViewId, project.ref).accepted
       resource.value match {
         case v: IndexingElasticSearchView  =>
@@ -87,7 +87,7 @@ class ElasticSearchScopeInitializationSpec
 
     "not create a default ElasticSearchView if one already exists" in {
       views.fetch(defaultViewId, project.ref).accepted.rev shouldEqual 1L
-      init.onProjectCreation(project, bob).accepted
+      init.onProjectCreation(project.ref, bob).accepted
       views.fetch(defaultViewId, project.ref).accepted.rev shouldEqual 1L
     }