[brooklyn-server] 01/03: allow type lookups as part of getImmediately (non-blocking / non-locking)

[heneveld]

This is an automated email from the ASF dual-hosted git repository.

heneveld pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/brooklyn-server.git

commit 5908566ec7659efae90b77fdd9c4cec7a0c4c99a
Author: Alex Heneveld <alex.henev...@cloudsoftcorp.com>
AuthorDate: Wed Nov 11 17:39:13 2020 +0000

    allow type lookups as part of getImmediately (non-blocking / non-locking)
---
 .../core/typereg/BasicBrooklynTypeRegistry.java    | 28 +++++++++++++++-------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git 
a/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
 
b/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
index d9a21d6..7b93ff7 100644
--- 
a/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
+++ 
b/core/src/main/java/org/apache/brooklyn/core/typereg/BasicBrooklynTypeRegistry.java
@@ -18,11 +18,8 @@
  */
 package org.apache.brooklyn.core.typereg;
 
-import java.util.Collection;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
+import java.util.concurrent.Callable;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.stream.Collectors;
@@ -98,17 +95,30 @@ public class BasicBrooklynTypeRegistry implements 
BrooklynTypeRegistry {
     private Iterable<RegisteredType> getAllWithoutCatalog(Predicate<? super 
RegisteredType> filter) {
         // TODO optimisation? make indexes and look up?
         Ordering<RegisteredType> typeOrder = 
Ordering.from(RegisteredTypeNameThenBestFirstComparator.INSTANCE);
-        return Locks.withLock(localRegistryLock.readLock(), 
-            () -> localRegisteredTypesAndContainingBundles.values().stream().
-                flatMap(m -> { return 
typeOrder.sortedCopy(m.values()).stream(); 
}).filter(filter::apply).collect(Collectors.toList()) );
+        return withOptionalReadLock(() -> 
localRegisteredTypesAndContainingBundles.values().stream().
+                flatMap(m -> {
+                    return typeOrder.sortedCopy(m.values()).stream();
+                }).filter(filter::apply).collect(Collectors.toList()));
     }
 
     private Maybe<RegisteredType> getExactWithoutLegacyCatalog(String 
symbolicName, String version, RegisteredTypeLoadingContext constraint) {
-        RegisteredType item = Locks.withLock(localRegistryLock.readLock(), 
+        RegisteredType item = withOptionalReadLock(
             ()-> 
getBestValue(localRegisteredTypesAndContainingBundles.get(symbolicName+":"+version))
 );
         return RegisteredTypes.tryValidate(item, constraint);
     }
 
+    private <T> T withOptionalReadLock(Callable<T> call) {
+        if (Thread.currentThread().isInterrupted()) {
+            // if we're doing get immediately bypass the lock
+            try {
+                return call.call();
+            } catch (Exception e) {
+                throw Exceptions.propagate(e);
+            }
+        } else {
+            return Locks.withLock(localRegistryLock.readLock(), call);
+        }
+    }
     private RegisteredType getBestValue(Map<String, RegisteredType> m) {
         if (m==null) return null;
         if (m.isEmpty()) return null;