[NAE-2212] Cluster scope process function caches

application-engine/src/main/java/com/netgrif/application/engine/configuration/CacheConfiguration.java

@@ -1,15 +1,18 @@
 package com.netgrif.application.engine.configuration;
 
+import com.netgrif.application.engine.configuration.cache.WorkerConcurrentCacheManager;
 import com.netgrif.application.engine.configuration.properties.CacheConfigurationProperties;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurerSupport;
 import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
 import org.springframework.cache.interceptor.CacheResolver;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 
+import java.util.Set;
+
+
 @Configuration
 @EnableCaching
 public class CacheConfiguration extends CachingConfigurerSupport {
@@ -24,7 +27,7 @@ public CacheConfiguration(CacheConfigurationProperties properties) {
     @Primary
     @Override
     public CacheManager cacheManager() {
-        return new ConcurrentMapCacheManager(properties.getAllCaches().toArray(String[]::new));
+        return new WorkerConcurrentCacheManager(Set.of(properties.getNamespaceFunctions()), properties.getAllCaches().toArray(String[]::new));
     }
 
     @Bean

application-engine/src/main/java/com/netgrif/application/engine/configuration/cache/ReadOnlyCache.java

@@ -0,0 +1,42 @@
+package com.netgrif.application.engine.configuration.cache;
+
+import org.springframework.cache.Cache;
+
+import java.util.concurrent.Callable;
+
+public class ReadOnlyCache implements Cache {
+
+    private final Cache cacheDelegate;
+
+    public ReadOnlyCache(Cache cacheDelegate) {
+        this.cacheDelegate = cacheDelegate;
+    }
+
+    @Override
+    public String getName() { return cacheDelegate.getName(); }
+
+    @Override
+    public Object getNativeCache() { return cacheDelegate.getNativeCache(); }
+
+    @Override
+    public ValueWrapper get(Object key) { return cacheDelegate.get(key); }
+
+    @Override
+    public <T> T get(Object key, Class<T> type) { return cacheDelegate.get(key, type); }
+
+    @Override
+    public <T> T get(Object key, Callable<T> loader) { return cacheDelegate.get(key, loader); }
+
+    @Override
+    public void put(Object key, Object value) { cacheDelegate.put(key, value); }
+
+    @Override
+    public void evict(Object key) {
+        throw new UnsupportedOperationException("Evict not allowed on worker for " + getName());
+    }
+
+    @Override
+    public void clear() {
+        throw new UnsupportedOperationException("Clear not allowed on worker for " + getName());
+    }
+}

application-engine/src/main/java/com/netgrif/application/engine/configuration/cache/WorkerConcurrentCacheManager.java

@@ -0,0 +1,39 @@
+package com.netgrif.application.engine.configuration.cache;
+
+import org.springframework.cache.Cache;
+import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
+
+import java.util.Objects;
+import java.util.Set;
+
+public class WorkerConcurrentCacheManager extends ConcurrentMapCacheManager {
+    private final Set<String> readOnlyCacheNames;
+
+    public WorkerConcurrentCacheManager() {
+        super();
+        this.readOnlyCacheNames = Set.of();
+    }
+
+    public WorkerConcurrentCacheManager(Set<String> readOnlyCacheNames) {
+        super();
+        this.readOnlyCacheNames = Set.copyOf(
+                Objects.requireNonNull(readOnlyCacheNames, "readOnlyCacheNames must not be null.")
+        );
+    }
+
+    public WorkerConcurrentCacheManager(Set<String> readOnlyCacheNames, String... cacheNames) {
+        super(cacheNames);
+        this.readOnlyCacheNames = Set.copyOf(
+                Objects.requireNonNull(readOnlyCacheNames, "readOnlyCacheNames must not be null.")
+        );
+    }
+
+    @Override
+    protected Cache createConcurrentMapCache(String name) {
+        Cache base = super.createConcurrentMapCache(name);
+        if (readOnlyCacheNames != null && readOnlyCacheNames.contains(name)) {
+            return new ReadOnlyCache(base);
+        }
+        return base;
+    }
+}

application-engine/src/main/java/com/netgrif/application/engine/configuration/properties/CacheConfigurationProperties.java

@@ -41,6 +41,11 @@ public class CacheConfigurationProperties {
      */
     private String loadedModules = "loadedModules";
 
+    /**
+     * Default cache name for caching namespace functions.
+     */
+    private String namespaceFunctions = "namespaceFunctions";
+
     /**
      * A list of additional custom cache names.
      * Allows users to define their own cache names for specific use cases.
@@ -54,7 +59,7 @@ public class CacheConfigurationProperties {
      * @return a {@link Set} of all cache names.
      */
     public Set<String> getAllCaches() {
-        Set<String> caches = new LinkedHashSet<>(Arrays.asList(petriNetById, petriNetByIdentifier, petriNetNewest, petriNetCache, loadedModules));
+        Set<String> caches = new LinkedHashSet<>(Arrays.asList(petriNetById, petriNetByIdentifier, petriNetNewest, petriNetCache, loadedModules, namespaceFunctions));
         caches.addAll(additional);
         return caches;
     }

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/FieldActionsCacheService.java

@@ -15,6 +15,9 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
@@ -30,7 +33,6 @@ public class FieldActionsCacheService implements IFieldActionsCacheService {
     private final RunnerConfigurationProperties.FieldRunnerProperties properties;
 
     private IPetriNetService petriNetService;
-
     private Map<String, Closure> actionsCache;
     private Map<String, List<CachedFunction>> namespaceFunctionsCache;
     private Map<String, CachedFunction> functionsCache;
@@ -96,6 +98,28 @@ public List<CachedFunction> getCachedFunctions(List<com.netgrif.application.engi
         return cachedFunctions;
     }
 
+    @Override
+    public void cacheAllPetriNetsFunctions() {
+        Pageable pageable = PageRequest.of(0, 500);
+        Page<PetriNet> page = petriNetService.getAll(pageable);
+
+        while (!page.isEmpty()) {
+            for (PetriNet petriNet : page) {
+                try {
+                    cachePetriNetFunctions(petriNet);
+                } catch (Exception e) {
+                    log.warn("Failed to cache functions for PetriNet id={}", petriNet.getStringId(), e);
+                }
+            }
+
+            if (!page.hasNext()) {
+                break;
+            }
+            pageable = pageable.next();
+            page = petriNetService.getAll(pageable);
+        }
+    }
+
     @Override
     public void evaluateFunctions(List<Function> functions) {
         evaluateCachedFunctions(functions.stream().map(function -> CachedFunction.build(shell, function)).collect(Collectors.toList()));

application-engine/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IFieldActionsCacheService.java

@@ -27,5 +27,7 @@ public interface IFieldActionsCacheService {
 
     void clearNamespaceFunctionCache();
 
+    void cacheAllPetriNetsFunctions();
+
     void clearFunctionCache();
 }