[NAE-2182] Clearing actions cache

application-engine/pom.xml

@@ -270,18 +270,6 @@
             <version>${junit-jupiter.version}</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
         <!-- Groovy -->
         <!-- https://mvnrepository.com/artifact/org.codehaus.groovy/groovy-all -->
         <dependency>

application-engine/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy

@@ -2444,9 +2444,13 @@ class ActionDelegate {
                 return [(role.importId + ":" + GLOBAL_ROLE), ("$role.name (🌍 Global role)" as String)]
             } else {
                 if (!temp.containsKey(entry.value)) {
-                    temp.put(entry.value, petriNetService.getNewestVersionByIdentifier(entry.value))
+                    temp.put(entry.value, petriNetService.getActiveVersionByIdentifier(entry.value))
                 }
                 PetriNet net = temp[entry.value]
+                if (net == null) {
+                    throw new IllegalArgumentException("The process with identifier [%s] could not be found when collecting roles."
+                            .formatted(entry.value))
+                }
                 ProcessRole role = net.roles.find { it.value.importId == entry.key }.value
                 return [(role.importId + ":" + net.identifier), ("$role.name ($net.title)" as String)]
             }

application-engine/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/FieldActionsRunner.groovy

@@ -77,7 +77,7 @@ abstract class FieldActionsRunner {
         actionsCacheService.getCachedFunctions(functions).each {
             actionDelegate.metaClass."${it.function.name}" << it.code
         }
-        actionsCacheService.getNamespaceFunctionCache().each { entry ->
+        actionsCacheService.getGlobalFunctionsCache().each { entry ->
             def namespace = [:]
             entry.getValue().each {
                 namespace["${it.function.name}"] = it.code.rehydrate(actionDelegate, it.code.owner, it.code.thisObject)

application-engine/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/delegate/RoleActionDelegate.groovy

@@ -51,7 +51,10 @@ class RoleActionDelegate extends AbstractActionDelegate<RoleContext> {
     }
 
     AbstractUser assignRole(String roleImportId, String petriNetIdentifier, AbstractUser user = affectedUser) {
-        PetriNet petriNet = petriNetService.getNewestVersionByIdentifier(petriNetIdentifier)
+        PetriNet petriNet = petriNetService.getActiveVersionByIdentifier(petriNetIdentifier)
+        if (petriNet == null) {
+            throw new IllegalArgumentException("The process with identifier [%s] could not be found".formatted(petriNetIdentifier))
+        }
         assignRole(roleImportId, user, petriNet)
     }
 
@@ -75,7 +78,10 @@ class RoleActionDelegate extends AbstractActionDelegate<RoleContext> {
     }
 
     AbstractUser removeRole(String roleImportId, String petriNetIdentifier, AbstractUser user = affectedUser) {
-        PetriNet petriNet = petriNetService.getNewestVersionByIdentifier(petriNetIdentifier)
+        PetriNet petriNet = petriNetService.getActiveVersionByIdentifier(petriNetIdentifier)
+        if (petriNet == null) {
+            throw new IllegalArgumentException("The process with identifier [%s] could not be found".formatted(petriNetIdentifier))
+        }
         removeRole(roleImportId, user, petriNet)
     }
 

application-engine/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy

@@ -128,7 +128,7 @@ class ImportHelper {
     }
 
     Optional<PetriNet> upsertNet(String filename, String identifier, VersionType release = VersionType.MAJOR, LoggedUser author = ActorTransformer.toLoggedUser(userService.getSystem())) {
-        PetriNet petriNet = petriNetService.getNewestVersionByIdentifier(identifier)
+        PetriNet petriNet = petriNetService.getActiveVersionByIdentifier(identifier)
         if (!petriNet) {
             return createNet(filename, release, author)
         }
@@ -249,7 +249,7 @@ class ImportHelper {
     }
 
     Optional<PetriNet> importProcessOnce(String message, String netIdentifier, String netFileName) {
-        PetriNet filter = petriNetService.getNewestVersionByIdentifier(netIdentifier)
+        PetriNet filter = petriNetService.getActiveVersionByIdentifier(netIdentifier)
         if (filter != null) {
             log.info("${message} has already been imported.")
             return Optional.of(filter)

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

@@ -1,30 +1,65 @@
 package com.netgrif.application.engine.configuration;
 
 import com.netgrif.application.engine.configuration.properties.CacheConfigurationProperties;
+import com.netgrif.application.engine.configuration.properties.RunnerConfigurationProperties;
+import com.netgrif.application.engine.elastic.service.executors.MaxSizeHashMap;
+import com.netgrif.application.engine.workflow.domain.CachedFunction;
+import groovy.lang.Closure;
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.Cache;
 import org.springframework.cache.CacheManager;
-import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.CachingConfigurer;
 import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
+import org.springframework.cache.concurrent.ConcurrentMapCache;
 import org.springframework.cache.interceptor.CacheResolver;
+import org.springframework.cache.support.SimpleCacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 
+
+import java.util.*;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
 @Configuration
 @EnableCaching
-public class CacheConfiguration extends CachingConfigurerSupport {
-
+@RequiredArgsConstructor
+public class CacheConfiguration implements CachingConfigurer {
+    private final RunnerConfigurationProperties.FieldRunnerProperties fieldRunnerProperties;
     private final CacheConfigurationProperties properties;
 
-    public CacheConfiguration(CacheConfigurationProperties properties) {
-        this.properties = properties;
-    }
-
     @Bean
     @Primary
     @Override
     public CacheManager cacheManager() {
-        return new ConcurrentMapCacheManager(properties.getAllCaches().toArray(String[]::new));
+        Set<String> cacheNames = properties.getAllCaches();
+        List<Cache> caches = cacheNames.stream()
+                .map(ConcurrentMapCache::new)
+                .collect(Collectors.toCollection(ArrayList::new));
+
+
+        Supplier<Map<String, Closure>> actionsFactory =
+                () -> Collections.synchronizedMap(new MaxSizeHashMap<>(fieldRunnerProperties.getActionCacheSize()));
+
+        caches.add(new GenericMapCache<>(
+                CacheMapKeys.ACTIONS,
+                Closure.class,
+                actionsFactory
+        ));
+
+        Supplier<Map<String, CachedFunction>> functionsFactory =
+                () -> Collections.synchronizedMap(new MaxSizeHashMap<>(fieldRunnerProperties.getFunctionsCacheSize()));
+
+        caches.add(new GenericMapCache<>(
+                CacheMapKeys.FUNCTIONS,
+                CachedFunction.class,
+                functionsFactory
+        ));
+
+        SimpleCacheManager cacheManager = new SimpleCacheManager();
+        cacheManager.setCaches(caches);
+        return cacheManager;
     }
 
     @Bean

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

@@ -0,0 +1,7 @@
+package com.netgrif.application.engine.configuration;
+
+public final class CacheMapKeys {
+    private CacheMapKeys() {}
+    public static final String ACTIONS = "actions";
+    public static final String FUNCTIONS = "functions";
+}

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

@@ -0,0 +1,111 @@
+package com.netgrif.application.engine.configuration;
+
+import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.cache.Cache;
+import org.springframework.cache.support.SimpleValueWrapper;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+
+@Slf4j
+public class GenericMapCache<V> implements Cache {
+    private final String name;
+    private final Class<V> valueType;
+    private final java.util.function.Supplier<Map<String, V>> mapFactory;
+    private final AtomicReference<Map<String, V>> atomicMapRef;
+
+    private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();
+
+    public GenericMapCache(String name, Class<V> valueType, java.util.function.Supplier<Map<String, V>> mapFactory) {
+        this.name = name;
+        this.valueType = valueType;
+        this.mapFactory = mapFactory;
+        this.atomicMapRef = new AtomicReference<>(mapFactory.get());
+    }
+
+    @Override public @NotNull String getName() { return name; }
+
+    @Override public @NotNull Object getNativeCache() { return Map.copyOf(map()); }
+
+    @Override
+    public <T> T get(Object key, Callable<T> loader) {
+        final String stringKey = String.valueOf(key);
+
+        Object mapValue = map().get(stringKey);
+        if (mapValue != null) {
+            return (T) mapValue;
+        }
+
+        Object lock = locks.computeIfAbsent(stringKey, lockKey -> new Object());
+        try {
+            synchronized (lock) {
+                Object mapLockValue = map().get(stringKey);
+                if (mapLockValue != null) {
+                    return (T) mapLockValue;
+                }
+
+                T computed = loader.call();
+                if (computed == null) {
+                    return null;
+                }
+
+                V value = safeCast(computed);
+                map().put(stringKey, value);
+                return (T) value;
+            }
+        } catch (Exception ex) {
+            throw new Cache.ValueRetrievalException(stringKey, loader, ex);
+        } finally {
+            locks.remove(stringKey, lock);
+        }
+    }
+
+    @Override
+    public ValueWrapper get(Object key) {
+        String stringKey = String.valueOf(key);
+        Object valueObject = map().get(stringKey);
+        return valueObject != null ? new SimpleValueWrapper(valueObject) : null;
+    }
+
+    @Override
+    public synchronized <T> T get(Object key, Class<T> type) {
+        String stringKey = String.valueOf(key);
+        Object valueObject = map().get(stringKey);
+        return valueObject != null ? type.cast(valueObject) : null;
+    }
+
+    @Override
+    public synchronized void put(Object key, Object value) {
+        map().put(String.valueOf(key), safeCast(value));
+    }
+
+    @Override
+    public synchronized void evict(Object key) {
+        map().remove(String.valueOf(key));
+    }
+
+    @Override
+    public synchronized void clear() {
+        this.atomicMapRef.set(mapFactory.get());
+    }
+
+    private Map<String, V> map() {
+        return atomicMapRef.get();
+    }
+
+    @SuppressWarnings("unchecked")
+    private V safeCast(Object object) {
+        if (object == null) {
+            return null;
+        }
+
+        if (!valueType.isInstance(object)) {
+            throw new ClassCastException("Expected " + valueType.getName() + " but was " + object.getClass().getName());
+        }
+
+        return (V) object;
+    }
+}

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

@@ -27,9 +27,14 @@ public class CacheConfigurationProperties {
     private String petriNetByIdentifier = "petriNetByIdentifier";
 
     /**
-     * Default cache name for caching the newest versions of Petri nets.
+     * Default cache name for caching the active versions of Petri nets.
      */
-    private String petriNetNewest = "petriNetNewest";
+    private String petriNetActive = "petriNetActive";
+
+    /**
+     * Default cache name for caching the latest versions of Petri nets.
+     */
+    private String petriNetLatest = "petriNetLatest";
 
     /**
      * Default cache name for general Petri net caching.
@@ -41,6 +46,11 @@ public class CacheConfigurationProperties {
      */
     private String loadedModules = "loadedModules";
 
+    /**
+     * Default cache name for caching namespace functions.
+     */
+    private String globalFunctions = "globalFunctions";
+
     /**
      * A list of additional custom cache names.
      * Allows users to define their own cache names for specific use cases.
@@ -54,7 +64,8 @@ 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, petriNetActive,
+                petriNetLatest, petriNetCache, loadedModules, globalFunctions));
         caches.addAll(additional);
         return caches;
     }

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

@@ -56,7 +56,7 @@ public static class FieldRunnerProperties {
         /**
          * The size of the cache used for maintaining field runner namespaces.
          */
-        private int namespaceCacheSize = 500;
+        private int globalFunctionsCacheSize = 500;
     }
 
     /**

application-engine/src/main/java/com/netgrif/application/engine/importer/service/FunctionFactory.java

@@ -1,5 +1,6 @@
 package com.netgrif.application.engine.importer.service;
 
+import com.netgrif.application.engine.objects.importer.model.Scope;
 import com.netgrif.application.engine.objects.petrinet.domain.Function;
 import com.netgrif.application.engine.objects.petrinet.domain.FunctionScope;
 import lombok.extern.slf4j.Slf4j;
@@ -9,7 +10,10 @@
 @Slf4j
 public final class FunctionFactory {
 
+    private static final String NAMESPACE = "namespace";
+
     public Function getFunction(com.netgrif.application.engine.objects.importer.model.Function function) {
+        checkDeprecatedAttributes(function);
         Function function1 = new Function();
 
         function1.setDefinition(function.getValue());
@@ -18,4 +22,11 @@ public Function getFunction(com.netgrif.application.engine.objects.importer.mode
 
         return function1;
     }
+
+    private void checkDeprecatedAttributes(com.netgrif.application.engine.objects.importer.model.Function function) {
+        if (function.getScope() != null && function.getScope().value().equals(NAMESPACE)) {
+            log.warn("Function scope [NAMESPACE] is deprecated. Replacing with [GLOBAL].]");
+            function.setScope(Scope.GLOBAL);
+        }
+    }
 }

application-engine/src/main/java/com/netgrif/application/engine/menu/services/DashboardItemServiceImpl.java

@@ -8,6 +8,7 @@
 import com.netgrif.application.engine.objects.auth.domain.AbstractUser;
 import com.netgrif.application.engine.objects.auth.domain.ActorTransformer;
 import com.netgrif.application.engine.objects.auth.domain.LoggedUser;
+import com.netgrif.application.engine.objects.petrinet.domain.PetriNet;
 import com.netgrif.application.engine.objects.petrinet.domain.throwable.TransitionNotExecutableException;
 import com.netgrif.application.engine.objects.utils.MenuItemUtils;
 import com.netgrif.application.engine.objects.workflow.domain.Case;
@@ -62,7 +63,11 @@ public Case getOrCreate(DashboardItemBody body) throws TransitionNotExecutableEx
         }
 
         LoggedUser loggedUser = ActorTransformer.toLoggedUser(userService.getLoggedOrSystem());
-        itemCase = workflowService.createCase(petriNetService.getNewestVersionByIdentifier(DashboardItemConstants.PROCESS_IDENTIFIER).getStringId(), body.getName().getDefaultValue(), "", loggedUser).getCase();
+        PetriNet petriNet = petriNetService.getActiveVersionByIdentifier(DashboardItemConstants.PROCESS_IDENTIFIER);
+        if (petriNet == null) {
+            throw new IllegalStateException("Dashboard item process not found or not active");
+        }
+        itemCase = workflowService.createCase(petriNet.getStringId(), body.getName().getDefaultValue(), "", loggedUser).getCase();
         ToDataSetOutcome outcome = body.toDataSet();
         itemCase = setDataWithExecute(itemCase, DashboardItemConstants.TASK_CONFIGURE, outcome.getDataSet());
         return itemCase;

application-engine/src/main/java/com/netgrif/application/engine/menu/services/DashboardManagementServiceImpl.java

@@ -9,6 +9,7 @@
 import com.netgrif.application.engine.objects.auth.domain.ActorTransformer;
 import com.netgrif.application.engine.objects.auth.domain.LoggedUser;
 import com.netgrif.application.engine.objects.petrinet.domain.I18nString;
+import com.netgrif.application.engine.objects.petrinet.domain.PetriNet;
 import com.netgrif.application.engine.objects.petrinet.domain.throwable.TransitionNotExecutableException;
 import com.netgrif.application.engine.objects.utils.MenuItemUtils;
 import com.netgrif.application.engine.objects.workflow.domain.Case;
@@ -64,7 +65,11 @@ public Case createDashboardManagement(DashboardManagementBody body) throws Trans
         }
         addReferencedMenuItems(body);
         LoggedUser loggedUser = ActorTransformer.toLoggedUser(userService.getLoggedOrSystem());
-        managementCase = workflowService.createCase(petriNetService.getNewestVersionByIdentifier(DashboardManagementConstants.PROCESS_IDENTIFIER).getStringId(), body.getName().getDefaultValue(), "", loggedUser).getCase();
+        PetriNet petriNet = petriNetService.getActiveVersionByIdentifier(DashboardManagementConstants.PROCESS_IDENTIFIER);
+        if (petriNet == null) {
+            throw new IllegalStateException("Dashboard management process not found or not active");
+        }
+        managementCase = workflowService.createCase(petriNet.getStringId(), body.getName().getDefaultValue(), "", loggedUser).getCase();
         ToDataSetOutcome outcome = body.toDataSet();
         managementCase = setDataWithExecute(managementCase, DashboardItemConstants.TASK_CONFIGURE, outcome.getDataSet());
         return managementCase;