CAMEL-19295: Basic thread-safe LRU cache

core/camel-core/src/test/java/org/apache/camel/impl/DefaultEndpointRegistryTest.java

@@ -16,9 +16,17 @@
  */
 package org.apache.camel.impl;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.ServiceStatus;
 import org.apache.camel.builder.RouteBuilder;
 import org.apache.camel.impl.engine.DefaultEndpointRegistry;
+import org.apache.camel.impl.engine.SimpleCamelContext;
 import org.apache.camel.spi.EndpointRegistry;
+import org.apache.camel.support.NormalizedUri;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -68,4 +76,50 @@ public void configure() throws Exception {
         assertTrue(reg.isStatic("file:error"));
     }
 
+    //Testing the issue https://issues.apache.org/jira/browse/CAMEL-19295
+    @Test
+    public void testConcurrency() throws InterruptedException {
+
+        SimpleCamelContext context = new SimpleCamelContext();
+        context.start();
+
+        ProducerTemplate producerTemplate = context.createProducerTemplate();
+        EndpointRegistry<NormalizedUri> endpointRegistry = context.getEndpointRegistry();
+
+        int nThreads = 4;
+        ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
+        int iterations = 500;
+
+        for (int j = 0; j < iterations; j++) {
+            CountDownLatch allThreadCompletionSemaphore = new CountDownLatch(nThreads);
+            for (int i = 0; i < nThreads; i++) {
+
+                executorService.submit(() -> {
+
+                    producerTemplate.requestBody("controlbus:route?routeId=route1&action=ACTION_STATUS&loggingLevel=off", null,
+                            ServiceStatus.class);
+                    producerTemplate.requestBody("controlbus:route?routeId=route2&action=ACTION_STATUS&loggingLevel=off", null,
+                            ServiceStatus.class);
+                    producerTemplate.requestBody("controlbus:route?routeId=route3&action=ACTION_STATUS&loggingLevel=off", null,
+                            ServiceStatus.class);
+                    producerTemplate.requestBody("controlbus:route?routeId=route4&action=ACTION_STATUS&loggingLevel=off", null,
+                            ServiceStatus.class);
+                    producerTemplate.requestBody("controlbus:route?routeId=route5&action=ACTION_STATUS&loggingLevel=off", null,
+                            ServiceStatus.class);
+
+                    allThreadCompletionSemaphore.countDown();
+
+                });
+            }
+
+            allThreadCompletionSemaphore.await();
+
+            assertTrue(endpointRegistry.values().toArray() != null);
+
+        }
+
+        executorService.shutdown();
+
+    }
+
 }

core/camel-core/src/test/java/org/apache/camel/impl/DefaultProducerCacheTest.java

@@ -189,8 +189,8 @@ public void testCacheEvictWhileInUse() throws Exception {
         // nothing has stopped yet even we have 3 producers and a cache limit of 2
         assertEquals(0, stopCounter.get());
 
-        // force evict p1 while its in use (eg simulate someone else grabbing it while evicting race condition)
-        cache.forceEvict(p1);
+        // force evict p2 while its in use (eg simulate someone else grabbing it while evicting race condition)
+        cache.forceEvict(p2);
 
         // and should still not be stopped
         assertEquals(0, stopCounter.get());

core/camel-core/src/test/java/org/apache/camel/support/DefaultLRUCacheFactoryTest.java

@@ -0,0 +1,292 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.support;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * The test class for {@link DefaultLRUCacheFactory}.
+ */
+class DefaultLRUCacheFactoryTest {
+
+    private final List<String> consumed = new ArrayList<>();
+    private final DefaultLRUCacheFactory.SimpleLRUCache<String, String> map
+            = (DefaultLRUCacheFactory.SimpleLRUCache<String, String>) new DefaultLRUCacheFactory().<String,
+                    String> createLRUCache(3, consumed::add);
+
+    @Test
+    void forbiddenOperations() {
+        assertThrows(UnsupportedOperationException.class, () -> map.values().add("foo"));
+        assertThrows(UnsupportedOperationException.class, () -> map.keySet().add("foo"));
+        assertThrows(UnsupportedOperationException.class, () -> map.entrySet().add(Map.entry("x", "y")));
+    }
+
+    @Test
+    void setValue() {
+        assertNull(map.put("1", "One"));
+        assertEquals(1, map.size());
+        assertEquals(1, map.getQueueSize());
+        map.entrySet().iterator().next().setValue("bar");
+        assertEquals(1, map.size());
+        assertEquals(2, map.getQueueSize());
+    }
+
+    @Test
+    void queueSize() {
+        assertEquals(0, map.getQueueSize());
+        map.put("1", "1");
+        assertEquals(1, map.size());
+        assertEquals(1, map.getQueueSize());
+        map.put("1", "2");
+        assertEquals(1, map.size());
+        assertEquals(2, map.getQueueSize());
+        map.put("1", "3");
+        assertEquals(1, map.size());
+        assertEquals(3, map.getQueueSize());
+        map.put("1", "4");
+        assertEquals(1, map.size());
+        assertEquals(4, map.getQueueSize());
+        map.put("1", "5");
+        assertEquals(1, map.size());
+        assertEquals(5, map.getQueueSize());
+        map.put("1", "6");
+        assertEquals(1, map.size());
+        assertEquals(6, map.getQueueSize());
+        map.put("1", "7");
+        assertEquals(1, map.size());
+        assertEquals(6, map.getQueueSize());
+        map.put("1", "8");
+        assertEquals(1, map.size());
+        assertEquals(6, map.getQueueSize());
+    }
+
+    @Test
+    void put() {
+        assertEquals(0, map.size());
+        assertNull(map.put("1", "One"));
+        assertEquals(1, map.size());
+        assertNull(map.put("2", "Two"));
+        assertEquals(2, map.size());
+        assertNull(map.put("3", "Three"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertNull(map.put("4", "Four"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("1"));
+        assertTrue(consumed.contains("One"));
+        assertEquals("Two", map.put("2", "Two v2"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertTrue(map.containsKey("2"));
+        assertEquals("Two v2", map.get("2"));
+    }
+
+    @Test
+    void putIfAbsent() {
+        assertEquals(0, map.size());
+        assertNull(map.putIfAbsent("1", "One"));
+        assertEquals(1, map.size());
+        assertNull(map.putIfAbsent("2", "Two"));
+        assertEquals(2, map.size());
+        assertNull(map.putIfAbsent("3", "Three"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertNull(map.putIfAbsent("4", "Four"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("1"));
+        assertTrue(consumed.contains("One"));
+        assertEquals("Two", map.putIfAbsent("2", "Two v2"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertTrue(map.containsKey("2"));
+        assertEquals("Two", map.get("2"));
+        assertNull(map.putIfAbsent("5", "Five"));
+        assertEquals(3, map.size());
+        assertEquals(2, consumed.size());
+        assertFalse(map.containsKey("2"));
+        assertTrue(consumed.contains("Two"));
+    }
+
+    @Test
+    void computeIfAbsent() {
+        assertEquals(0, map.size());
+        assertEquals("One", map.computeIfAbsent("1", k -> "One"));
+        assertEquals(1, map.size());
+        assertEquals("Two", map.computeIfAbsent("2", k -> "Two"));
+        assertEquals(2, map.size());
+        assertEquals("Three", map.computeIfAbsent("3", k -> "Three"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("Four", map.computeIfAbsent("4", k -> "Four"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("1"));
+        assertTrue(consumed.contains("One"));
+        assertNull(map.computeIfAbsent("1", k -> null));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertNull(map.computeIfAbsent("5", k -> null));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertEquals("Two", map.computeIfAbsent("2", k -> "Two v2"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertTrue(map.containsKey("2"));
+        assertEquals("Two", map.get("2"));
+        assertEquals("Five", map.computeIfAbsent("5", k -> "Five"));
+        assertEquals(3, map.size());
+        assertEquals(2, consumed.size());
+        assertFalse(map.containsKey("2"));
+        assertTrue(consumed.contains("Two"));
+        assertEquals("Five", map.computeIfAbsent("5", k -> null));
+        assertEquals(3, map.size());
+        assertEquals(2, consumed.size());
+    }
+
+    @Test
+    void computeIfPresent() {
+        assertEquals(0, map.size());
+        map.putIfAbsent("1", "One");
+        assertEquals(1, map.size());
+        map.putIfAbsent("2", "Two");
+        assertEquals(2, map.size());
+        map.putIfAbsent("3", "Three");
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertNull(map.computeIfPresent("4", (k, v) -> "Four"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertFalse(map.containsKey("4"));
+        assertEquals("One v2", map.computeIfPresent("1", (k, v) -> "One v2"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertTrue(map.containsKey("1"));
+        assertEquals("One v2", map.get("1"));
+        assertNull(map.computeIfPresent("1", (k, v) -> null));
+        assertEquals(2, map.size());
+        assertEquals(0, consumed.size());
+        assertFalse(map.containsKey("1"));
+    }
+
+    @Test
+    void compute() {
+        assertEquals(0, map.size());
+        assertEquals("One", map.compute("1", (k, v) -> "One"));
+        assertEquals(1, map.size());
+        assertEquals("Two", map.compute("2", (k, v) -> "Two"));
+        assertEquals(2, map.size());
+        assertEquals("Three", map.compute("3", (k, v) -> "Three"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("Four", map.compute("4", (k, v) -> "Four"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("1"));
+        assertTrue(consumed.contains("One"));
+        assertEquals("Two v2", map.compute("2", (k, v) -> "Two v2"));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertTrue(map.containsKey("2"));
+        assertEquals("Two v2", map.get("2"));
+        assertNull(map.compute("2", (k, v) -> null));
+        assertEquals(2, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("2"));
+    }
+
+    @Test
+    void merge() {
+        assertEquals(0, map.size());
+        assertEquals("One", map.merge("1", "One", String::concat));
+        assertEquals(1, map.size());
+        assertEquals("Two", map.merge("2", "Two", String::concat));
+        assertEquals(2, map.size());
+        assertEquals("Three", map.merge("3", "Three", String::concat));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("Four", map.merge("4", "Four", String::concat));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertFalse(map.containsKey("1"));
+        assertTrue(consumed.contains("One"));
+        assertEquals("TwoV2", map.merge("2", "V2", String::concat));
+        assertEquals(3, map.size());
+        assertEquals(1, consumed.size());
+        assertNull(map.merge("2", "V2", (v1, v2) -> null));
+        assertEquals(2, map.size());
+        assertEquals(1, consumed.size());
+    }
+
+    @Test
+    void replace() {
+        assertEquals(0, map.size());
+        assertNull(map.replace("1", "One"));
+        assertEquals(0, map.size());
+        map.put("1", "One");
+        assertEquals(1, map.size());
+        map.put("2", "Two");
+        assertEquals(2, map.size());
+        map.put("3", "Three");
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("One", map.replace("1", "One v2"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("Three", map.replace("3", "Three v2"));
+        assertEquals("Three v2", map.get("3"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+    }
+
+    @Test
+    void replaceWithOldValue() {
+        assertEquals(0, map.size());
+        map.put("1", "One");
+        map.put("2", "Two");
+        map.put("3", "Three");
+        assertEquals(3, map.size());
+        assertFalse(map.replace("1", "foo", "One"));
+        assertEquals(3, map.size());
+        assertFalse(map.replace("1", "foo", "One v2"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("One", map.get("1"));
+        assertTrue(map.replace("1", "One", "One v2"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertEquals("One v2", map.get("1"));
+        assertFalse(map.replace("3", "foo", "Three v2"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+        assertTrue(map.replace("3", "Three", "Three v2"));
+        assertEquals("Three v2", map.get("3"));
+        assertEquals(3, map.size());
+        assertEquals(0, consumed.size());
+    }
+}