Fix PortfolioMetricsUpdateTask refreshing too many project metrics concurrently

src/main/java/org/dependencytrack/tasks/metrics/PortfolioMetricsUpdateTask.java

@@ -25,7 +25,6 @@
 import net.javacrumbs.shedlock.core.LockConfiguration;
 import net.javacrumbs.shedlock.core.LockExtender;
 import net.javacrumbs.shedlock.core.LockingTaskExecutor;
-import org.apache.commons.collections4.ListUtils;
 import org.dependencytrack.event.CallbackEvent;
 import org.dependencytrack.event.PortfolioMetricsUpdateEvent;
 import org.dependencytrack.event.ProjectMetricsUpdateEvent;
@@ -36,6 +35,8 @@
 import javax.jdo.PersistenceManager;
 import javax.jdo.Query;
 import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
@@ -45,7 +46,6 @@
 import static org.dependencytrack.util.LockProvider.isTaskLockToBeExtended;
 import static org.dependencytrack.util.TaskUtil.getLockConfigForTask;
 
-
 /**
  * A {@link Subscriber} task that updates portfolio metrics.
  *
@@ -87,7 +87,7 @@
     }
 
     private static void refreshProjectMetrics() throws Exception {
-        try (final var qm = new QueryManager().withL2CacheDisabled()) {
+        try (final var qm = new QueryManager()) {
             final PersistenceManager pm = qm.getPersistenceManager();
 
             LOGGER.debug("Fetching first " + BATCH_SIZE + " projects");
@@ -100,7 +100,7 @@
                 final long lastId = activeProjects.get(activeProjects.size() - 1).id();
 
                 // Distribute the batch across at most MAX_CONCURRENCY events, and process them asynchronously.
-                final List<List<ProjectProjection>> partitions = ListUtils.partition(activeProjects, MAX_CONCURRENCY);
+                final List<List<ProjectProjection>> partitions = partition(activeProjects, MAX_CONCURRENCY);
                 final var countDownLatch = new CountDownLatch(partitions.size());
 
                 for (final List<ProjectProjection> partition : partitions) {
@@ -145,6 +145,9 @@
         }
     }
 
+    public record ProjectProjection(long id, UUID uuid) {
+    }
+
     private static List<ProjectProjection> fetchNextActiveProjectsPage(final PersistenceManager pm, final Long lastId) throws Exception {
         try (final Query<Project> query = pm.newQuery(Project.class)) {
             if (lastId == null) {
@@ -160,7 +163,24 @@
         }
     }
 
-    public record ProjectProjection(long id, UUID uuid) {
+    static <T> List<List<T>> partition(final List<T> list, int numPartitions) {
+        if (list == null || list.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        final int listSize = list.size();
+        final var partitions = new ArrayList<List<T>>(numPartitions);
+        int partitionSize = (int) Math.ceil((double) listSize / numPartitions);
+
+        int i = 0, elementsLeft = listSize;
+        while (i < listSize && numPartitions != 0) {
+            partitions.add(list.subList(i, i + partitionSize));
+            i = i + partitionSize;
+            elementsLeft = elementsLeft - partitionSize;
+            partitionSize = (int) Math.ceil((double) elementsLeft / --numPartitions);
+        }
+
+        return partitions;
     }
 
 }

src/test/java/org/dependencytrack/tasks/metrics/PortfolioMetricsUpdateTaskTest.java

@@ -40,10 +40,12 @@
 import org.junit.Test;
 
 import java.time.Instant;
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.dependencytrack.tasks.metrics.PortfolioMetricsUpdateTask.partition;
 
 @NotThreadSafe
 public class PortfolioMetricsUpdateTaskTest extends AbstractMetricsUpdateTaskTest {
@@ -363,4 +365,36 @@ public void testUpdateMetricsPolicyViolations() {
         assertThat(componentSuppressed.getLastInheritedRiskScore()).isZero();
     }
 
+    @Test
+    public void testPartitionWithNull() {
+        final List<Integer> list = null;
+        final List<List<Integer>> partitions = partition(list, 4);
+        assertThat(partitions).isEmpty();
+    }
+
+    @Test
+    public void testPartitionWithEmptyList() {
+        final List<Integer> list = Collections.emptyList();
+        final List<List<Integer>> partitions = partition(list, 4);
+        assertThat(partitions).isEmpty();
+    }
+
+    @Test
+    public void testPartitionWithSmallList() {
+        final List<Integer> list = List.of(1, 2);
+        final List<List<Integer>> partitions = partition(list, 4);
+        assertThat(partitions).hasSize(2);
+    }
+
+    @Test
+    public void testPartitionWithUnevenSizeList() {
+        final List<Integer> list = List.of(1, 2, 3, 4, 5);
+        final List<List<Integer>> partitions = partition(list, 4);
+        assertThat(partitions).satisfiesExactlyInAnyOrder(
+                partition -> assertThat(partition).hasSize(2),
+                partition -> assertThat(partition).hasSize(1),
+                partition -> assertThat(partition).hasSize(1),
+                partition -> assertThat(partition).hasSize(1));
+    }
+
 }