avoid marking project as indexed in the webapp if not known

fixes #4799

Author: vladak

opengrok-indexer/src/main/java/org/opengrok/indexer/index/IndexDatabase.java

@@ -38,6 +38,7 @@
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
@@ -423,44 +424,21 @@ private void markProjectIndexed(Project project) {
             return;
         }
 
-        // Also need to store the correct value in configuration
-        // when indexer writes it to a file.
+        // Also need to store the correct value in configuration when indexer writes it to a file.
         project.setIndexed(true);
 
         if (env.getConfigURI() == null) {
             return;
         }
 
-        Response response;
-        try {
-            response = ClientBuilder.newBuilder().connectTimeout(env.getConnectTimeout(), TimeUnit.SECONDS).build()
-                    .target(env.getConfigURI())
-                    .path("api")
-                    .path("v1")
-                    .path("projects")
-                    .path(Util.uriEncode(project.getName()))
-                    .path("indexed")
-                    .request()
-                    .headers(getWebAppHeaders())
-                    .put(Entity.text(""));
-        } catch (RuntimeException e) {
-            LOGGER.log(Level.WARNING, String.format("Could not notify the webapp that project %s was indexed",
-                    project), e);
+        // If this project is not known to the webapp yet, there is no point in setting its indexed property.
+        Collection<String> webappProjects = IndexerUtil.getProjects(env.getConfigURI());
+        if (!webappProjects.contains(project.getName())) {
+            LOGGER.log(Level.FINEST, "Project {0} is not known to the webapp", project);
             return;
         }
 
-        if (response.getStatus() == Response.Status.ACCEPTED.getStatusCode()) {
-            try {
-                response = waitForAsyncApi(response);
-            } catch (InterruptedException e) {
-                LOGGER.log(Level.WARNING, "interrupted while waiting for API response", e);
-            }
-        }
-
-        if (response.getStatusInfo().getFamily() != Response.Status.Family.SUCCESSFUL) {
-            LOGGER.log(Level.WARNING, "Could not notify the webapp that project {0} was indexed: {1}",
-                    new Object[] {project, response});
-        }
+        IndexerUtil.markProjectIndexed(env.getConfigURI(), project);
     }
 
     private static List<Repository> getRepositoriesForProject(Project project) {

opengrok-indexer/src/main/java/org/opengrok/indexer/index/IndexerUtil.java

@@ -18,11 +18,14 @@
  */
 
 /*
- * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
  */
 package org.opengrok.indexer.index;
 
 import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.core.GenericType;
+import jakarta.ws.rs.core.MediaType;
+import org.opengrok.indexer.configuration.Project;
 import org.opengrok.indexer.configuration.RuntimeEnvironment;
 
 import jakarta.ws.rs.ProcessingException;
@@ -35,11 +38,21 @@
 import jakarta.ws.rs.core.MultivaluedHashMap;
 import jakarta.ws.rs.core.MultivaluedMap;
 import jakarta.ws.rs.core.Response;
+import org.opengrok.indexer.logger.LoggerFactory;
+import org.opengrok.indexer.web.Util;
 
+import java.util.Collection;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.opengrok.indexer.web.ApiUtils.waitForAsyncApi;
 
 public class IndexerUtil {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(IndexerUtil.class);
+
     private IndexerUtil() {
     }
 
@@ -57,24 +70,24 @@ public static MultivaluedMap<String, Object> getWebAppHeaders() {
     }
 
     /**
-     * Enable projects in the remote host application.
+     * Enable projects in the remote application.
      * <p>
      * NOTE: performs a check if the projects are already enabled,
      * before making the change request
      *
-     * @param host the url to the remote host
+     * @param webappUri the url to the remote web application
      * @throws ResponseProcessingException in case processing of a received HTTP response fails
      * @throws ProcessingException         in case the request processing or subsequent I/O operation fails
      * @throws WebApplicationException     in case the response status code of the response returned by the server is not successful
      */
-    public static void enableProjects(final String host) throws
+    public static void enableProjects(final String webappUri) throws
             ResponseProcessingException,
             ProcessingException,
             WebApplicationException {
 
         try (Client client = ClientBuilder.newBuilder().
                 connectTimeout(RuntimeEnvironment.getInstance().getConnectTimeout(), TimeUnit.SECONDS).build()) {
-            final Invocation.Builder request = client.target(host)
+            final Invocation.Builder request = client.target(webappUri)
                     .path("api")
                     .path("v1")
                     .path("configuration")
@@ -92,4 +105,58 @@ public static void enableProjects(final String host) throws
             }
         }
     }
+
+    /**
+     * Mark project as indexed via API call. Assumes the project is already known to the webapp.
+     * @param webappUri URI for the webapp
+     * @param project project to mark as indexed
+     */
+    public static void markProjectIndexed(String webappUri, Project project) {
+        Response response;
+        try (Client client = ClientBuilder.newBuilder().
+                connectTimeout(RuntimeEnvironment.getInstance().getConnectTimeout(), TimeUnit.SECONDS).build()) {
+            response = client.target(webappUri)
+                    .path("api")
+                    .path("v1")
+                    .path("projects")
+                    .path(Util.uriEncode(project.getName()))
+                    .path("indexed")
+                    .request()
+                    .headers(getWebAppHeaders())
+                    .put(Entity.text(""));
+
+            if (response.getStatus() == Response.Status.ACCEPTED.getStatusCode()) {
+                try {
+                    response = waitForAsyncApi(response);
+                } catch (InterruptedException e) {
+                    LOGGER.log(Level.WARNING, "interrupted while waiting for API response", e);
+                }
+            }
+
+            if (response.getStatusInfo().getFamily() != Response.Status.Family.SUCCESSFUL) {
+                LOGGER.log(Level.WARNING, "Could not notify the webapp that project {0} was indexed: {1}",
+                        new Object[] {project, response});
+            }
+        } catch (RuntimeException e) {
+            LOGGER.log(Level.WARNING, String.format("Could not notify the webapp that project %s was indexed",
+                    project), e);
+        }
+    }
+
+    /**
+     * @param webappUri URI for the webapp
+     * @return list of projects known to the webapp
+     */
+    public static Collection<String> getProjects(String webappUri) {
+        try (Client client = ClientBuilder.newBuilder().
+                connectTimeout(RuntimeEnvironment.getInstance().getConnectTimeout(), TimeUnit.SECONDS).build()) {
+            final Invocation.Builder request = client.target(webappUri)
+                    .path("api")
+                    .path("v1")
+                    .path("projects")
+                    .request(MediaType.APPLICATION_JSON)
+                    .headers(getWebAppHeaders());
+            return request.get(new GenericType<List<String>>(){});
+        }
+    }
 }

opengrok-web/src/main/java/org/opengrok/web/api/v1/controller/ProjectsController.java

@@ -358,7 +358,7 @@ public Response markIndexed(@Context HttpServletRequest request, @PathParam("pro
                                     Repository repo = getRepository(ri, CommandTimeoutType.RESTFUL);
 
                                     if (repo != null && repo.getCurrentVersion() != null &&
-                                            repo.getCurrentVersion().length() > 0) {
+                                            !repo.getCurrentVersion().isEmpty()) {
                                         // getRepository() always creates fresh instance
                                         // of the Repository object so there is no need
                                         // to call setCurrentVersion() on it.
@@ -420,8 +420,7 @@ public Object get(@PathParam("project") String projectName, @PathParam("field")
 
         Project project = env.getProjects().get(projectName);
         if (project == null) {
-            throw new WebApplicationException(
-                    "cannot find project '" + projectName + "' to get a property", Response.Status.BAD_REQUEST);
+            throw new NotFoundException(String.format("cannot find project '%s' to get a property", projectName));
         }
         return ClassUtil.getFieldValue(project, field);
     }