[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.getDefaultVersionByIdentifier(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.getDefaultVersionByIdentifier(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.getDefaultVersionByIdentifier(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.getDefaultVersionByIdentifier(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.getDefaultVersionByIdentifier(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,55 @@
 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.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.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));
+
+        caches.add(new GenericMapCache<>(
+                CacheMapKeys.ACTIONS,
+                Closure.class,
+                fieldRunnerProperties.getActionCacheSize()
+        ));
+        caches.add(new GenericMapCache<>(
+                CacheMapKeys.FUNCTIONS,
+                CachedFunction.class,
+                fieldRunnerProperties.getFunctionsCacheSize()
+        ));
+
+        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,90 @@
+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;
+
+@Slf4j
+public class GenericMapCache<V> implements Cache {
+    private final String name;
+    private final Class<V> valueType;
+    private final ConcurrentHashMap<String, V> map;
+
+    public GenericMapCache(String name, Class<V> valueType, int cacheSize) {
+        this.name = name;
+        this.valueType = valueType;
+        this.map = new ConcurrentHashMap<>(cacheSize);
+    }
+
+    @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);
+        try {
+            V value = map.computeIfAbsent(stringKey, cacheValue -> {
+                try {
+                    T computed = loader.call();
+                    if (computed == null) return null;
+                    return safeCast(computed);
+                }
+                catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            });
+            return (T) value;
+        } catch (RuntimeException e) {
+            Throwable cause = (e.getCause() != null) ? e.getCause() : e;
+            throw new Cache.ValueRetrievalException(stringKey, loader, cause);
+        }
+    }
+
+    @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 <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 void put(Object key, Object value) {
+        map.put(String.valueOf(key), safeCast(value));
+    }
+
+    @Override
+    public void evict(Object key) {
+        map.remove(String.valueOf(key));
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @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 default versions of Petri nets.
      */
-    private String petriNetNewest = "petriNetNewest";
+    private String petriNetDefault = "petriNetDefault";
+
+    /**
+     * Default cache name for caching the latest versions of Petri nets.
+     */
+    private String petriNetLatest = "petriNetLatest";
 
     /**
      * Default cache name for general Petri net caching.
@@ -41,20 +46,33 @@ public class CacheConfigurationProperties {
      */
     private String loadedModules = "loadedModules";
 
+    /**
+     * Default cache name for caching global functions of PetriNet global scoped functions.
+     */
+    private String globalFunctions = "globalFunctions";
+
     /**
      * A list of additional custom cache names.
      * Allows users to define their own cache names for specific use cases.
      */
     private List<String> additional = new ArrayList<>();
 
+    /**
+     * The size of pages used for caching functions when processing large sets of data.
+     * This property determines the maximum number of functions to include in a single page during caching operations.
+     * Default value is 500.
+     */
+    private int functionCachingPageSize = 500;
+
     /**
      * Retrieves a set of all configured cache names.
      * Includes the default caches and any additional user-defined cache names.
      *
      * @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, petriNetDefault,
+                petriNetLatest, petriNetCache, loadedModules, globalFunctions));
         caches.addAll(additional);
         return caches;
     }

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

@@ -54,9 +54,9 @@ public static class FieldRunnerProperties {
         private int functionsCacheSize = 500;
 
         /**
-         * The size of the cache used for maintaining field runner namespaces.
+         * The size of the cache used for managing global Petri net functions.
          */
-        private int namespaceCacheSize = 500;
+        private int globalFunctionsCacheSize = 500;
     }
 
     /**

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

@@ -1,15 +1,21 @@
 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.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
-@Component
 @Slf4j
+@Component
+@RequiredArgsConstructor
 public final class FunctionFactory {
 
+    private final IFunctionValidator functionValidator;
+
     public Function getFunction(com.netgrif.application.engine.objects.importer.model.Function function) {
+        functionValidator.checkDeprecatedAttributes(function);
         Function function1 = new Function();
 
         function1.setDefinition(function.getValue());
@@ -18,4 +24,5 @@ public Function getFunction(com.netgrif.application.engine.objects.importer.mode
 
         return function1;
     }
+
 }

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

@@ -0,0 +1,29 @@
+package com.netgrif.application.engine.importer.service;
+
+import com.netgrif.application.engine.objects.importer.model.Function;
+import com.netgrif.application.engine.objects.importer.model.Scope;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class FunctionValidator implements IFunctionValidator {
+
+    private static final String NAMESPACE = "namespace";
+
+    /**
+    * Validates and updates deprecated function attributes.
+    * <p>
+    * This method mutates the input function by replacing deprecated scope values.
+    * Specifically, it replaces the deprecated NAMESPACE scope with GLOBAL scope.
+    *
+    * @param function the function to validate and update (mutated in-place)
+    */
+    @Override
+    public void checkDeprecatedAttributes(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/importer/service/IFunctionValidator.java

@@ -0,0 +1,15 @@
+package com.netgrif.application.engine.importer.service;
+
+import com.netgrif.application.engine.objects.importer.model.Function;
+
+public interface IFunctionValidator extends IModelValidator {
+    /**
+     * Validates and updates deprecated function attributes.
+     * <p>
+     * This method mutates the input function by replacing deprecated scope values.
+     * Specifically, it replaces the deprecated NAMESPACE scope with GLOBAL scope.
+     *
+     * @param function the function to validate and update (mutated in-place)
+     */
+    void checkDeprecatedAttributes(Function function);
+}