added under maintenance check on frontend calls.

AlexSilaghiWBT · AlexSilaghiWBT · commit 9d342fad2405 · 2025-11-13T12:00:02.000+02:00
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/GatewayController.java b/src/main/java/edu/stanford/protege/webprotege/gateway/GatewayController.java
@@ -74,8 +74,15 @@ public RpcResponse execute(@RequestBody RpcRequest request,
             CorrelationMDCUtil.setCorrelationId(UUID.randomUUID().toString());
             var result = rpcRequestProcessor.processRequest(request, accessToken, new UserId(userId));
             return result.get(timeoutInMs, TimeUnit.MILLISECONDS);
+        } catch (ProjectUnderMaintenanceException e) {
+            logger.info("Project is under maintenance. UserId: {}  Request: {}", userId, request);
+            throw e;
         } catch (ExecutionException e) {
-            if(e.getCause() instanceof CommandExecutionException ex) {
+            if(e.getCause() instanceof ProjectUnderMaintenanceException ex) {
+                logger.info("Project is under maintenance (from ExecutionException). UserId: {}  Request: {}", userId, request);
+                throw ex;
+            }
+            else if(e.getCause() instanceof CommandExecutionException ex) {
                 logger.info("Error with cause that is a CommandExecutionException.  Mapping to a ResponseStatusException: {}", ex.getStatus());
                 throw new ResponseStatusException(ex.getStatus(), e.getMessage());
             }
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/MessengerImpl.java b/src/main/java/edu/stanford/protege/webprotege/gateway/MessengerImpl.java
@@ -1,16 +1,17 @@
 package edu.stanford.protege.webprotege.gateway;
 
+import edu.stanford.protege.webprotege.common.ProjectId;
 import edu.stanford.protege.webprotege.common.UserId;
+import edu.stanford.protege.webprotege.gateway.websocket.ProjectMaintenanceState;
+import edu.stanford.protege.webprotege.ipc.ExecutionContext;
 import edu.stanford.protege.webprotege.ipc.Headers;
+import java.util.UUID;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.amqp.AmqpException;
 import org.springframework.amqp.core.MessageBuilder;
 import org.springframework.amqp.rabbit.AsyncRabbitTemplate;
 
 import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
 /**
@@ -23,10 +24,12 @@ public class MessengerImpl implements Messenger {
     private final static Logger LOGGER = LoggerFactory.getLogger(MessengerImpl.class);
 
     private final AsyncRabbitTemplate asyncRabbitTemplate;
+    private final ProjectMaintenanceState maintenanceState;
 
 
-    public MessengerImpl(AsyncRabbitTemplate asyncRabbitTemplate) {
+    public MessengerImpl(AsyncRabbitTemplate asyncRabbitTemplate, ProjectMaintenanceState maintenanceState) {
         this.asyncRabbitTemplate = asyncRabbitTemplate;
+        this.maintenanceState = maintenanceState;
     }
 
     /**
@@ -45,8 +48,14 @@ public CompletableFuture<Msg> sendAndReceive(RpcRequest rpcRequest, String acces
         headers.put(Headers.CORRELATION_ID, CorrelationMDCUtil.getCorrelationId());
         LOGGER.info("Setting correlationId : " + CorrelationMDCUtil.getCorrelationId());
         if (rpcRequest.params().has("projectId")) {
-            var projectId = rpcRequest.params().get("projectId").asText();
-            headers.put(Headers.PROJECT_ID, projectId);
+            var projectIdString = rpcRequest.params().get("projectId").asText();
+            headers.put(Headers.PROJECT_ID, projectIdString);
+            
+            var projectId = ProjectId.valueOf(projectIdString);
+            var executionContext = new ExecutionContext(userId, accessToken, UUID.randomUUID().toString());
+            if (maintenanceState.isUnderMaintenance(projectId, executionContext)) {
+                throw new ProjectUnderMaintenanceException(projectIdString);
+            }
         }
         LOGGER.info("User {} is sending: {}",userId.value(), rpcRequest.methodName());
         return asyncRabbitTemplate.sendAndReceive("webprotege-exchange", method, rabbitRequest)
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/ProjectUnderMaintenanceException.java b/src/main/java/edu/stanford/protege/webprotege/gateway/ProjectUnderMaintenanceException.java
@@ -0,0 +1,15 @@
+package edu.stanford.protege.webprotege.gateway;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.server.ResponseStatusException;
+
+/**
+ * Exception thrown when a project is under maintenance and requests cannot be processed.
+ */
+public class ProjectUnderMaintenanceException extends ResponseStatusException {
+
+    public ProjectUnderMaintenanceException(String projectId) {
+        super(HttpStatus.SERVICE_UNAVAILABLE, "Project " + projectId + " is currently under maintenance");
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/RpcRequestProcessor.java b/src/main/java/edu/stanford/protege/webprotege/gateway/RpcRequestProcessor.java
@@ -76,7 +76,9 @@ private CompletableFuture<RpcResponse> sendMessage(RpcRequest request, String ac
                     payload, userId);
             return reply
                     .exceptionally(e -> {
-                        // Convert all exceptions to a ResponseStatusException
+                        if (e instanceof ProjectUnderMaintenanceException) {
+                            throw (ProjectUnderMaintenanceException) e;
+                        }
                         logger.error("Error during send and receive: {}.  Returning failed future with ResponseStatusException HTTP 500 Internal Server Error", e.getMessage(), e);
                         throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage(), e);
                     })
@@ -90,6 +92,8 @@ private CompletableFuture<RpcResponse> sendMessage(RpcRequest request, String ac
                             return CompletableFuture.failedFuture(new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage(), e));
                         }
                     });
+        } catch (ProjectUnderMaintenanceException e) {
+            return CompletableFuture.failedFuture(e);
         } catch (Exception e) {
             return CompletableFuture.failedFuture(new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage(), e));
         }
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/WebprotegeGwtApiGatewayApplication.java b/src/main/java/edu/stanford/protege/webprotege/gateway/WebprotegeGwtApiGatewayApplication.java
@@ -53,7 +53,7 @@ RpcRequestProcessor rpcRequestProcessor(@Value("${spring.application.name}") Str
 
 	@Bean
 	@Lazy
-	MessengerImpl messageHandler(AsyncRabbitTemplate rabbitTemplate) {
-		return new MessengerImpl(rabbitTemplate);
+	MessengerImpl messageHandler(AsyncRabbitTemplate rabbitTemplate, edu.stanford.protege.webprotege.gateway.websocket.ProjectMaintenanceState maintenanceState) {
+		return new MessengerImpl(rabbitTemplate, maintenanceState);
 	}
 }
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/ProjectMaintenanceState.java b/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/ProjectMaintenanceState.java
@@ -0,0 +1,67 @@
+package edu.stanford.protege.webprotege.gateway.websocket;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import edu.stanford.protege.webprotege.common.ProjectId;
+import edu.stanford.protege.webprotege.ipc.ExecutionContext;
+import edu.stanford.protege.webprotege.ipc.impl.CommandExecutorImpl;
+import edu.stanford.protege.webprotege.projects.GetProjectDetailsAction;
+import edu.stanford.protege.webprotege.projects.GetProjectDetailsResult;
+import edu.stanford.protege.webprotege.projects.ProjectDetails;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.amqp.rabbit.AsyncRabbitTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
+
+@Component
+public class ProjectMaintenanceState {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(ProjectMaintenanceState.class);
+
+    private final ConcurrentMap<ProjectId, Boolean> maintenanceState = new ConcurrentHashMap<>();
+    private final CommandExecutorImpl<GetProjectDetailsAction, GetProjectDetailsResult> getProjectDetailsExecutor;
+
+    public ProjectMaintenanceState(ObjectMapper objectMapper, AsyncRabbitTemplate asyncRabbitTemplate) {
+        this.getProjectDetailsExecutor = new CommandExecutorImpl<>(GetProjectDetailsResult.class);
+        this.getProjectDetailsExecutor.setAsyncRabbitTemplate(asyncRabbitTemplate);
+        this.getProjectDetailsExecutor.setObjectMapper(objectMapper);
+    }
+
+    public void setUnderMaintenance(ProjectId projectId, boolean underMaintenance) {
+        maintenanceState.put(projectId, underMaintenance);
+    }
+
+    public boolean isUnderMaintenance(ProjectId projectId, ExecutionContext executionContext) {
+        Boolean cachedValue = maintenanceState.get(projectId);
+        if (cachedValue != null) {
+            return cachedValue;
+        }
+
+        try {
+            GetProjectDetailsResult result = getProjectDetailsExecutor.execute(
+                    new GetProjectDetailsAction(projectId),
+                    executionContext
+            ).get();
+
+            ProjectDetails projectDetails = result.projectDetails();
+            boolean underMaintenance = projectDetails.underMaintenance();
+            
+            maintenanceState.put(projectId, underMaintenance);
+            
+            LOGGER.info("Fetched maintenance state for project {} from backend: {}", projectId.id(), underMaintenance);
+            return underMaintenance;
+
+        } catch (InterruptedException | ExecutionException e) {
+            LOGGER.error("Error fetching project details for project {} from backend", projectId.id(), e);
+            // În caz de eroare, returnăm false (nu este sub maintenance)
+            return false;
+        }
+    }
+    public void removeProject(ProjectId projectId) {
+        maintenanceState.remove(projectId);
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/ProjectUnderMaintenanceEventHandler.java b/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/ProjectUnderMaintenanceEventHandler.java
@@ -0,0 +1,49 @@
+package edu.stanford.protege.webprotege.gateway.websocket;
+
+import edu.stanford.protege.webprotege.gateway.websocket.config.events.ProjectUnderMaintenanceUpdateEvent;
+import edu.stanford.protege.webprotege.ipc.EventHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Nonnull;
+
+@Component
+public class ProjectUnderMaintenanceEventHandler implements EventHandler<ProjectUnderMaintenanceUpdateEvent> {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(ProjectUnderMaintenanceEventHandler.class);
+
+    private final ProjectMaintenanceState maintenanceState;
+
+    public ProjectUnderMaintenanceEventHandler(ProjectMaintenanceState maintenanceState) {
+        this.maintenanceState = maintenanceState;
+    }
+
+    @Nonnull
+    @Override
+    public String getChannelName() {
+        return ProjectUnderMaintenanceUpdateEvent.CHANNEL;
+    }
+
+    @Nonnull
+    @Override
+    public String getHandlerName() {
+        return this.getClass().getName();
+    }
+
+    @Override
+    public Class<ProjectUnderMaintenanceUpdateEvent> getEventClass() {
+        return ProjectUnderMaintenanceUpdateEvent.class;
+    }
+
+    @Override
+    public void handleEvent(ProjectUnderMaintenanceUpdateEvent event) {
+        try {
+            maintenanceState.setUnderMaintenance(event.projectId(), event.underMaintenance());
+            LOGGER.info("Project {} maintenance state updated to: {}", event.projectId().id(), event.underMaintenance());
+        } catch (Exception e) {
+            LOGGER.error("Error handling ProjectUnderMaintenanceUpdateEvent for project {}", event.projectId().id(), e);
+        }
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/config/ObjectMapperConfiguration.java b/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/config/ObjectMapperConfiguration.java
@@ -12,6 +12,7 @@
 import edu.stanford.protege.webprotege.event.*;
 import edu.stanford.protege.webprotege.frame.*;
 import edu.stanford.protege.webprotege.gateway.websocket.config.events.ParentsChangedEvent;
+import edu.stanford.protege.webprotege.gateway.websocket.config.events.ProjectUnderMaintenanceUpdateEvent;
 import edu.stanford.protege.webprotege.gateway.websocket.config.events.UpdateUiHistoryEvent;
 import edu.stanford.protege.webprotege.hierarchy.EntityHierarchyChangedEvent;
 import edu.stanford.protege.webprotege.issues.CommentPostedEvent;
@@ -330,7 +331,8 @@ public ObjectMapper objectMapper() {
                     EntityTagsChangedEvent.class,
                     ProjectTagsChangedEvent.class,
                     WatchAddedEvent.class,
-                    WatchRemovedEvent.class);
+                    WatchRemovedEvent.class,
+                    ProjectUnderMaintenanceUpdateEvent.class);
 
             mapper.registerModule(module);
 
diff --git a/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/config/events/ProjectUnderMaintenanceUpdateEvent.java b/src/main/java/edu/stanford/protege/webprotege/gateway/websocket/config/events/ProjectUnderMaintenanceUpdateEvent.java
@@ -0,0 +1,31 @@
+package edu.stanford.protege.webprotege.gateway.websocket.config.events;
+
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import edu.stanford.protege.webprotege.common.EventId;
+import edu.stanford.protege.webprotege.common.ProjectEvent;
+import edu.stanford.protege.webprotege.common.ProjectId;
+import org.jetbrains.annotations.NotNull;
+
+@JsonTypeName(ProjectUnderMaintenanceUpdateEvent.CHANNEL)
+public record ProjectUnderMaintenanceUpdateEvent(ProjectId projectId, EventId eventId, boolean underMaintenance) implements ProjectEvent {
+
+    public final static String CHANNEL = "webprotege.events.projects.ProjectUnderMaintenanceUpdateEvent";
+
+    @NotNull
+    @Override
+    public ProjectId projectId() {
+        return projectId;
+    }
+
+    @NotNull
+    @Override
+    public EventId eventId() {
+        return eventId;
+    }
+
+    @Override
+    public String getChannel() {
+        return CHANNEL;
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/projects/GetProjectDetailsAction.java b/src/main/java/edu/stanford/protege/webprotege/projects/GetProjectDetailsAction.java
@@ -0,0 +1,34 @@
+package edu.stanford.protege.webprotege.projects;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import edu.stanford.protege.webprotege.common.ProjectId;
+import edu.stanford.protege.webprotege.common.ProjectRequest;
+
+import javax.annotation.Nonnull;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+@JsonTypeName("webprotege.projects.GetProjectDetails")
+public record GetProjectDetailsAction(ProjectId projectId) implements ProjectRequest<GetProjectDetailsResult> {
+
+    public static final String CHANNEL = "webprotege.projects.GetProjectDetails";
+
+    @JsonCreator
+    public GetProjectDetailsAction(@JsonProperty("projectId") ProjectId projectId) {
+        this.projectId = checkNotNull(projectId);
+    }
+
+    @Nonnull
+    @Override
+    public ProjectId projectId() {
+        return projectId;
+    }
+
+    @Override
+    public String getChannel() {
+        return CHANNEL;
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/projects/GetProjectDetailsResult.java b/src/main/java/edu/stanford/protege/webprotege/projects/GetProjectDetailsResult.java
@@ -0,0 +1,19 @@
+package edu.stanford.protege.webprotege.projects;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import edu.stanford.protege.webprotege.common.Response;
+
+
+import javax.annotation.Nonnull;
+
+@JsonTypeName("webprotege.projects.GetProjectDetails")
+public record GetProjectDetailsResult(@JsonProperty("projectDetails") @Nonnull ProjectDetails projectDetails) implements Response {
+
+    @JsonCreator
+    public static GetProjectDetailsResult get(@JsonProperty("projectDetails") @Nonnull ProjectDetails projectDetails) {
+        return new GetProjectDetailsResult(projectDetails);
+    }
+}
+
diff --git a/src/main/java/edu/stanford/protege/webprotege/projects/ProjectDetails.java b/src/main/java/edu/stanford/protege/webprotege/projects/ProjectDetails.java
@@ -0,0 +1,41 @@
+package edu.stanford.protege.webprotege.projects;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import edu.stanford.protege.webprotege.common.DictionaryLanguage;
+import edu.stanford.protege.webprotege.common.ProjectId;
+import edu.stanford.protege.webprotege.common.UserId;
+import edu.stanford.protege.webprotege.lang.DisplayNameSettings;
+import edu.stanford.protege.webprotege.projectsettings.EntityDeprecationSettings;
+
+import javax.annotation.Nonnull;
+import java.time.Instant;
+
+public record ProjectDetails(
+        @JsonProperty("_id") @Nonnull ProjectId projectId,
+        @JsonProperty("displayName") @Nonnull String displayName,
+        @JsonProperty("description") @Nonnull String description,
+        @JsonProperty("owner") @Nonnull UserId owner,
+        @JsonProperty("inTrash") boolean inTrash,
+        @JsonProperty("defaultLanguage") @Nonnull DictionaryLanguage dictionaryLanguage,
+        @JsonProperty("defaultDisplayNameSettings") @Nonnull DisplayNameSettings displayNameSettings,
+        @JsonProperty("createdAt") @Nonnull Instant createdAt,
+        @JsonProperty("createdBy") @Nonnull UserId createdBy,
+        @JsonProperty("modifiedAt") @Nonnull Instant lastModifiedAt,
+        @JsonProperty("modifiedBy") @Nonnull UserId lastModifiedBy,
+        @JsonProperty("entityDeprecationSettings") @Nonnull EntityDeprecationSettings entityDeprecationSettings,
+        @JsonProperty("underMaintenance") boolean underMaintenance
+) {
+    /**
+     * Gets the timestamp of when the project was created as milliseconds since epoch.
+     */
+    public long getCreatedAt() {
+        return createdAt.toEpochMilli();
+    }
+
+    /**
+     * Gets the timestamp of when the project was last modified as milliseconds since epoch.
+     */
+    public long getLastModifiedAt() {
+        return lastModifiedAt.toEpochMilli();
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ RpcRequestProcessor rpcRequestProcessor(@Value("${spring.application.name}") Str`
`53`	`53`
`54`	`54`	`@Bean`
`55`	`55`	`@Lazy`
`56`		`- MessengerImpl messageHandler(AsyncRabbitTemplate rabbitTemplate) {`
`57`		`- return new MessengerImpl(rabbitTemplate);`
	`56`	`+ MessengerImpl messageHandler(AsyncRabbitTemplate rabbitTemplate, edu.stanford.protege.webprotege.gateway.websocket.ProjectMaintenanceState maintenanceState) {`
	`57`	`+ return new MessengerImpl(rabbitTemplate, maintenanceState);`
`58`	`58`	`}`
`59`	`59`	`}`