Merge pull request wildfly#19272 from bstansberry/WFLY-20997

[WFLY-20997][WFLY-21007] Upgrade wildfly-clustering to 8.0.1.Final; fix marshalling classloading issues during undeploy

Author: bstansberry

clustering/common/src/main/java/org/jboss/as/clustering/service/DecoratedService.java

@@ -14,34 +14,22 @@
 import org.jboss.as.server.suspend.ServerSuspendController;
 import org.jboss.as.server.suspend.SuspendableActivity;
 import org.jboss.as.server.suspend.SuspendableActivityRegistry;
-import org.wildfly.clustering.server.manager.Service;
+import org.wildfly.clustering.server.service.Service;
 
 /**
  * A {@link Service} decorator that auto-stops on server suspend and auto-starts on server resume.
  * @author Paul Ferraro
  */
-public class SuspendableService implements Service {
+public class SuspendableService implements Service, SuspendableActivity {
 
     private final Service service;
     private final SuspendableActivityRegistry registry;
-    private final SuspendableActivity activity;
+    private final Executor executor;
 
     public SuspendableService(Service service, SuspendableActivityRegistry registry, Executor executor) {
         this.service = service;
         this.registry = registry;
-        this.activity = new SuspendableActivity() {
-            @Override
-            public CompletionStage<Void> suspend(ServerSuspendContext context) {
-                // Avoid spurious stop on startup during activity registration
-                if (context.isStarting()) return SuspendableActivity.COMPLETED;
-                return CompletableFuture.runAsync(service::stop, executor);
-            }
-
-            @Override
-            public CompletionStage<Void> resume(ServerResumeContext context) {
-                return CompletableFuture.runAsync(service::start, executor);
-            }
-        };
+        this.executor = executor;
     }
 
     @Override
@@ -51,19 +39,29 @@ public boolean isStarted() {
 
     @Override
     public void start() {
-        this.registry.registerActivity(this.activity);
-        // Only start now if we are not suspended
+        this.registry.registerActivity(this);
+        // If we are suspended, defer start until SuspendableActivity.resume(...)
         if (this.registry.getState() == ServerSuspendController.State.RUNNING) {
             this.service.start();
         }
     }
 
     @Override
     public void stop() {
-        // Only stop if we are not already suspended
+        // If we are suspended, SuspendableActivity.suspend(...) will have already stopped the service
         if (this.registry.getState() == ServerSuspendController.State.RUNNING) {
             this.service.stop();
         }
-        this.registry.unregisterActivity(this.activity);
+        this.registry.unregisterActivity(this);
+    }
+
+    @Override
+    public CompletionStage<Void> suspend(ServerSuspendContext context) {
+        return this.service.isStarted() ? CompletableFuture.runAsync(this.service::stop, this.executor) : SuspendableActivity.COMPLETED;
+    }
+
+    @Override
+    public CompletionStage<Void> resume(ServerResumeContext context) {
+        return !this.service.isStarted() ? CompletableFuture.runAsync(this.service::start, this.executor) : SuspendableActivity.COMPLETED;
     }
 }

clustering/common/src/main/java/org/jboss/as/clustering/service/SuspendableService.java

@@ -82,10 +82,6 @@
             <groupId>org.wildfly.clustering</groupId>
             <artifactId>wildfly-clustering-server-spi</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.wildfly.common</groupId>
-            <artifactId>wildfly-common</artifactId>
-        </dependency>
         <dependency>
             <groupId>org.wildfly.security</groupId>
             <artifactId>wildfly-elytron-security-manager</artifactId>

clustering/ejb/cache/pom.xml

@@ -9,20 +9,19 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
-import java.util.function.Consumer;
 
 import org.jboss.logging.Logger;
 import org.wildfly.clustering.cache.CacheEntryCreator;
 import org.wildfly.clustering.cache.CacheEntryMutator;
 import org.wildfly.clustering.cache.CacheEntryMutatorFactory;
 import org.wildfly.clustering.cache.CacheEntryRemover;
 import org.wildfly.clustering.ejb.bean.BeanInstance;
+import org.wildfly.clustering.function.Consumer;
 import org.wildfly.clustering.marshalling.MarshalledValue;
 import org.wildfly.clustering.marshalling.MarshalledValueFactory;
 import org.wildfly.clustering.server.cache.Cache;
 import org.wildfly.clustering.server.cache.CacheStrategy;
 import org.wildfly.clustering.server.manager.Manager;
-import org.wildfly.common.function.Functions;
 
 /**
  * A manager for bean groups that leverages a {@link Manager} to handle bean group lifecycle.
@@ -47,9 +46,9 @@ public DefaultBeanGroupManager(DefaultBeanGroupManagerConfiguration<K, V, C> con
         this.mutatorFactory = configuration.getMutatorFactory();
         this.factory = configuration.getMarshalledValueFactory();
         boolean persistent = configuration.getCacheProperties().isPersistent();
-        this.postActivateTask = persistent ? new MapValuesTask<>(BeanInstance::postActivate) : Functions.discardingConsumer();
-        this.prePassivateTask = persistent ? new MapValuesTask<>(BeanInstance::prePassivate) : Functions.discardingConsumer();
-        this.cache = CacheStrategy.CONCURRENT.createCache(Functions.discardingConsumer(), new NewBeanGroupCloseTask<>(configuration.getRemover()));
+        this.postActivateTask = persistent ? new MapValuesTask<>(BeanInstance::postActivate) : Consumer.empty();
+        this.prePassivateTask = persistent ? new MapValuesTask<>(BeanInstance::prePassivate) : Consumer.empty();
+        this.cache = CacheStrategy.CONCURRENT.createCache(Consumer.empty(), new NewBeanGroupCloseTask<>(configuration.getRemover()));
         this.beanGroupFactory = (id, closeTask) -> {
             Map<K, V> instances = new ConcurrentHashMap<>();
             MarshalledValue<Map<K, V>, C> newValue = this.factory.createMarshalledValue(instances);

clustering/ejb/cache/src/main/java/org/wildfly/clustering/ejb/cache/bean/DefaultBeanGroupManager.java

@@ -6,25 +6,24 @@
 package org.wildfly.clustering.ejb.cache.timer;
 
 import java.time.Duration;
-import java.util.function.Supplier;
 
 import org.wildfly.clustering.cache.function.RemappingFunction;
+import org.wildfly.clustering.function.Supplier;
 import org.wildfly.clustering.server.offset.Offset;
 import org.wildfly.clustering.server.offset.OffsetValue;
-import org.wildfly.common.function.Functions;
 
 /**
  * @author Paul Ferraro
  * @param <C> the timer context type
  */
-public class TimerMetaDataEntryFunction<C> extends RemappingFunction<RemappableTimerMetaDataEntry<C>, Supplier<Offset<Duration>>> {
+public class TimerMetaDataEntryFunction<C> extends RemappingFunction<RemappableTimerMetaDataEntry<C>, java.util.function.Supplier<Offset<Duration>>> {
 
     public TimerMetaDataEntryFunction(OffsetValue<Duration> lastTimeoutDelta) {
         super(lastTimeoutDelta::getOffset);
     }
 
     TimerMetaDataEntryFunction(Offset<Duration> lastTimeoutOffsetDelta) {
-        super(Functions.constantSupplier(lastTimeoutOffsetDelta));
+        super(Supplier.of(lastTimeoutOffsetDelta));
     }
 
     Offset<Duration> getOffset() {

clustering/ejb/cache/src/main/java/org/wildfly/clustering/ejb/cache/timer/TimerMetaDataEntryFunction.java

@@ -53,10 +53,6 @@
             <groupId>org.wildfly.clustering</groupId>
             <artifactId>wildfly-clustering-marshalling-protostream</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.wildfly.common</groupId>
-            <artifactId>wildfly-common</artifactId>
-        </dependency>
 
         <!-- External test dependencies -->
         <dependency>

clustering/ejb/client/pom.xml

@@ -0,0 +1,57 @@
+/*
+ * Copyright The WildFly Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.wildfly.clustering.ejb.infinispan.bean;
+
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import org.wildfly.clustering.cache.batch.Batch;
+import org.wildfly.clustering.ejb.bean.Bean;
+import org.wildfly.clustering.ejb.bean.BeanInstance;
+import org.wildfly.clustering.ejb.cache.bean.BeanFactory;
+import org.wildfly.clustering.ejb.infinispan.logging.InfinispanEjbLogger;
+
+/**
+ * The bean expiration task triggered by the expiration scheduler.
+ * @author Paul Ferraro
+ */
+public class BeanExpirationTask<K, V extends BeanInstance<K>, M> implements Predicate<K> {
+    private final BeanFactory<K, V, M> beanFactory;
+    private final Supplier<Batch> batchFactory;
+    private final Consumer<V> expirationListener;
+
+    BeanExpirationTask(BeanFactory<K, V, M> beanFactory, Supplier<Batch> batchFactory, Consumer<V> expirationListener) {
+        this.beanFactory = beanFactory;
+        this.batchFactory = batchFactory;
+        this.expirationListener = expirationListener;
+    }
+
+    @Override
+    public boolean test(K id) {
+        InfinispanEjbLogger.ROOT_LOGGER.tracef("Expiring stateful session bean %s", id);
+        try (Batch batch = this.batchFactory.get()) {
+            try {
+                M value = this.beanFactory.tryValue(id);
+                if (value != null) {
+                    try (Bean<K, V> bean = this.beanFactory.createBean(id, value)) {
+                        // Ensure bean is actually expired
+                        if (bean.getMetaData().isExpired()) {
+                            bean.remove(this.expirationListener);
+                        }
+                    }
+                }
+                return true;
+            } catch (RuntimeException e) {
+                batch.discard();
+                throw e;
+            }
+        } catch (RuntimeException e) {
+            InfinispanEjbLogger.ROOT_LOGGER.failedToExpireBean(e, id);
+            return false;
+        }
+    }
+}

clustering/ejb/infinispan/src/main/java/org/wildfly/clustering/ejb/infinispan/bean/BeanExpirationScheduler.java

@@ -41,7 +41,7 @@ public InfinispanBeanGroupListener(EmbeddedCacheConfiguration configuration, C c
         this.context = context;
         // We only need to listen for activation/passivation events for non-persistent caches
         // pre-passivate/post-activate callbacks for persistent caches are triggered via GroupManager
-        this.executor = !configuration.getCacheProperties().isPersistent() ? configuration.getBlockingManager().asExecutor(this.getClass().getName()) : null;
+        this.executor = !configuration.getCacheProperties().isPersistent() ? configuration.getExecutor() : null;
         this.postActivateListenerRegistration = (this.executor != null) ? new PostActivateBlockingListener<>(configuration.getCache(), this::postActivate).register(BeanGroupKey.class) : null;
         this.prePassivateListenerRegistration = (this.executor != null) ? new PrePassivateBlockingListener<>(configuration.getCache(), this::prePassivate).register(BeanGroupKey.class) : null;
     }