From 25fa27e850be5adae5b388ce347e09f7eca84708 Mon Sep 17 00:00:00 2001 From: Paul Ferraro Date: Thu, 1 Mar 2018 15:57:51 -0500 Subject: [PATCH] WFLY-9940 Reduce metaspace usage in wildfly-clustering-web modules. --- .../InfinispanRouteLocatorBuilder.java | 16 +++++---- ...InfinispanRouteLocatorBuilderProvider.java | 23 +++++++----- .../session/InfinispanSessionManager.java | 18 ++++++++-- ...nfinispanSessionManagerFactoryBuilder.java | 15 ++++---- .../RouteRegistryEntryProviderBuilder.java | 10 ++++-- .../session/SessionExpirationScheduler.java | 22 +++++++----- .../session/fine/FineSessionAttributes.java | 4 ++- .../fine/FineSessionAttributesFactory.java | 8 +++-- .../session/SessionAttributeImmutability.java | 12 +++++-- ...ibutableSessionIdentifierCodecBuilder.java | 12 +++++-- ...SessionIdentifierCodecBuilderProvider.java | 18 ++++++---- ...ributableSessionManagerFactoryBuilder.java | 16 +++++---- ...eSessionManagerFactoryBuilderProvider.java | 20 ++++++----- .../web/undertow/session/RouteBuilder.java | 11 ++++-- ...stributableSingleSignOnManagerBuilder.java | 35 +++++++++++-------- ...bleSingleSignOnManagerBuilderProvider.java | 18 ++++++---- .../web/undertow/sso/SSOManagerBuilder.java | 10 +++--- .../sso/SessionIdGeneratorBuilder.java | 16 +++++---- .../undertow/sso/SessionListenerBuilder.java | 15 ++++---- .../sso/SessionManagerRegistryBuilder.java | 13 ++++--- .../elytron/DistributableSingleSignOn.java | 9 +++-- ...stributableSingleSignOnManagerBuilder.java | 29 +++++++++------ ...bleSingleSignOnManagerBuilderProvider.java | 17 +++++---- 23 files changed, 233 insertions(+), 134 deletions(-) diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilder.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilder.java index b529f2f68bc6..1aa04f58e898 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilder.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilder.java @@ -21,8 +21,6 @@ */ package org.wildfly.clustering.web.infinispan.session; -import java.util.stream.Stream; - import org.infinispan.Cache; import org.infinispan.remoting.transport.Address; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; @@ -36,6 +34,7 @@ import org.wildfly.clustering.infinispan.spi.InfinispanCacheRequirement; import org.wildfly.clustering.registry.Registry; import org.wildfly.clustering.service.Builder; +import org.wildfly.clustering.service.CompositeDependency; import org.wildfly.clustering.service.InjectedValueDependency; import org.wildfly.clustering.service.ValueDependency; import org.wildfly.clustering.spi.ClusteringCacheRequirement; @@ -46,7 +45,7 @@ * Service providing an Infinispan-based {@link RouteLocator}. * @author Paul Ferraro */ -public class InfinispanRouteLocatorBuilder implements CapabilityServiceBuilder, InfinispanRouteLocatorConfiguration { +public class InfinispanRouteLocatorBuilder implements CapabilityServiceBuilder, InfinispanRouteLocatorConfiguration, Value { private final String containerName = InfinispanSessionManagerFactoryBuilder.DEFAULT_CACHE_CONTAINER; private final String serverName; @@ -64,6 +63,11 @@ public InfinispanRouteLocatorBuilder(String serverName, String deploymentName) { this.deploymentName = deploymentName; } + @Override + public RouteLocator getValue() { + return new InfinispanRouteLocator(this); + } + @Override public ServiceName getServiceName() { return ServiceName.JBOSS.append("clustering", "web", "locator", this.deploymentName); @@ -79,10 +83,8 @@ public Builder configure(CapabilityServiceSupport support) { @Override public ServiceBuilder build(ServiceTarget target) { - Value value = () -> new InfinispanRouteLocator(this); - ServiceBuilder builder = target.addService(this.getServiceName(), new ValueService<>(value)); - Stream.of(this.factory, this.registry, this.cache).forEach(dependency -> dependency.register(builder)); - return builder.setInitialMode(ServiceController.Mode.ON_DEMAND); + ServiceBuilder builder = target.addService(this.getServiceName(), new ValueService<>(this)).setInitialMode(ServiceController.Mode.ON_DEMAND); + return new CompositeDependency(this.factory, this.registry, this.cache).register(builder); } @Override diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilderProvider.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilderProvider.java index 502894390d64..313655bbcdaa 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilderProvider.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanRouteLocatorBuilderProvider.java @@ -25,8 +25,10 @@ import java.util.LinkedList; import java.util.List; import java.util.ServiceLoader; +import java.util.function.Consumer; import org.infinispan.configuration.cache.CacheMode; +import org.infinispan.configuration.cache.ConfigurationBuilder; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.msc.service.ServiceName; import org.kohsuke.MetaInfServices; @@ -46,7 +48,7 @@ * @author Paul Ferraro */ @MetaInfServices(RouteLocatorBuilderProvider.class) -public class InfinispanRouteLocatorBuilderProvider implements RouteLocatorBuilderProvider { +public class InfinispanRouteLocatorBuilderProvider implements RouteLocatorBuilderProvider, Consumer { @Override public CapabilityServiceBuilder getRouteLocatorBuilder(String serverName, String deploymentName) { @@ -60,14 +62,7 @@ public Collection> getRouteLocatorConfigurationBuild List> builders = new LinkedList<>(); builders.add(new RouteRegistryEntryProviderBuilder(serverName, routeDependency)); - builders.add(new TemplateConfigurationBuilder(ServiceName.parse(InfinispanCacheRequirement.CONFIGURATION.resolve(containerName, serverName)), containerName, serverName, null, builder -> { - CacheMode mode = builder.clustering().cacheMode(); - builder.clustering().cacheMode(mode.isClustered() ? CacheMode.REPL_SYNC : CacheMode.LOCAL); - // don't use DefaultConsistentHashFactory for REPL caches (WFLY-9276) - builder.clustering().hash().consistentHashFactory(null); - builder.clustering().l1().disable(); - builder.persistence().clearStores(); - })); + builders.add(new TemplateConfigurationBuilder(ServiceName.parse(InfinispanCacheRequirement.CONFIGURATION.resolve(containerName, serverName)), containerName, serverName, null, this)); builders.add(new CacheBuilder<>(ServiceName.parse(InfinispanCacheRequirement.CACHE.resolve(containerName, serverName)), containerName, serverName)); ServiceNameRegistry registry = requirement -> ServiceName.parse(requirement.resolve(containerName, serverName)); for (CacheBuilderProvider provider : ServiceLoader.load(DistributedCacheBuilderProvider.class, DistributedCacheBuilderProvider.class.getClassLoader())) { @@ -76,4 +71,14 @@ public Collection> getRouteLocatorConfigurationBuild return builders; } + + @Override + public void accept(ConfigurationBuilder builder) { + CacheMode mode = builder.clustering().cacheMode(); + builder.clustering().cacheMode(mode.isClustered() ? CacheMode.REPL_SYNC : CacheMode.LOCAL); + // don't use DefaultConsistentHashFactory for REPL caches (WFLY-9276) + builder.clustering().hash().consistentHashFactory(null); + builder.clustering().l1().disable(); + builder.persistence().clearStores(); + } } diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManager.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManager.java index 60d5531d9d38..7d6996747318 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManager.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManager.java @@ -22,6 +22,7 @@ package org.wildfly.clustering.web.infinispan.session; import java.time.Duration; +import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; @@ -306,7 +307,9 @@ void triggerPrePassivationEvents(ImmutableSession session) { List listeners = findListeners(session); if (!listeners.isEmpty()) { HttpSessionEvent event = new HttpSessionEvent(new ImmutableHttpSessionAdapter(session, this.context)); - listeners.forEach(listener -> listener.sessionWillPassivate(event)); + for (HttpSessionActivationListener listener : listeners) { + listener.sessionWillPassivate(event); + } } } @@ -314,13 +317,22 @@ void triggerPostActivationEvents(ImmutableSession session) { List listeners = findListeners(session); if (!listeners.isEmpty()) { HttpSessionEvent event = new HttpSessionEvent(new ImmutableHttpSessionAdapter(session, this.context)); - listeners.forEach(listener -> listener.sessionDidActivate(event)); + for (HttpSessionActivationListener listener : listeners) { + listener.sessionDidActivate(event); + } } } private static List findListeners(ImmutableSession session) { ImmutableSessionAttributes attributes = session.getAttributes(); - return attributes.getAttributeNames().stream().map(name -> attributes.getAttribute(name)).filter(attribute -> attribute instanceof HttpSessionActivationListener).map(attribute -> (HttpSessionActivationListener) attribute).collect(Collectors.toList()); + List listeners = new ArrayList<>(attributes.getAttributeNames().size()); + for (String name : attributes.getAttributeNames()) { + Object attribute = attributes.getAttribute(name); + if (attribute instanceof HttpSessionActivationListener) { + listeners.add((HttpSessionActivationListener) attribute); + } + } + return listeners; } // Session decorator that performs scheduling on close(). diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManagerFactoryBuilder.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManagerFactoryBuilder.java index e6cda547e56e..bc575bba307a 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManagerFactoryBuilder.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/InfinispanSessionManagerFactoryBuilder.java @@ -23,7 +23,6 @@ import java.util.function.Consumer; import java.util.function.Supplier; -import java.util.stream.Stream; import org.infinispan.Cache; import org.infinispan.configuration.cache.ConfigurationBuilder; @@ -48,6 +47,7 @@ import org.wildfly.clustering.infinispan.spi.service.TemplateConfigurationBuilder; import org.wildfly.clustering.marshalling.spi.Marshallability; import org.wildfly.clustering.service.Builder; +import org.wildfly.clustering.service.CompositeDependency; import org.wildfly.clustering.service.InjectedValueDependency; import org.wildfly.clustering.service.SuppliedValueService; import org.wildfly.clustering.service.ValueDependency; @@ -58,7 +58,7 @@ import org.wildfly.clustering.web.infinispan.logging.InfinispanWebLogger; import org.wildfly.clustering.web.session.SessionManagerFactory; -public class InfinispanSessionManagerFactoryBuilder implements CapabilityServiceBuilder>, InfinispanSessionManagerFactoryConfiguration { +public class InfinispanSessionManagerFactoryBuilder implements CapabilityServiceBuilder>, InfinispanSessionManagerFactoryConfiguration, Supplier> { public static final String DEFAULT_CACHE_CONTAINER = "web"; @SuppressWarnings("rawtypes") @@ -107,6 +107,11 @@ public InfinispanSessionManagerFactoryBuilder(SessionManagerFactoryConfiguration this.cacheBuilder = new CacheBuilder<>(ServiceName.parse(InfinispanCacheRequirement.CACHE.resolve(this.containerName, cacheName)), this.containerName, cacheName); } + @Override + public SessionManagerFactory get() { + return new InfinispanSessionManagerFactory<>(this); + } + @Override public ServiceName getServiceName() { return ServiceName.JBOSS.append("clustering", "web", this.configuration.getDeploymentName()); @@ -128,13 +133,11 @@ public ServiceBuilder> build(ServiceT this.configurationBuilder.build(target).install(); this.cacheBuilder.build(target).install(); - Supplier> value = () -> new InfinispanSessionManagerFactory<>(this); - ServiceBuilder> builder = target.addService(this.getServiceName(), new SuppliedValueService<>(Functions.identity(), value, Consumers.close())) + ServiceBuilder> builder = target.addService(this.getServiceName(), new SuppliedValueService<>(Functions.identity(), this, Consumers.close())) .addDependency(this.cacheBuilder.getServiceName(), Cache.class, this.cache) .setInitialMode(ServiceController.Mode.ON_DEMAND) ; - Stream.of(this.group, this.affinityFactory, this.dispatcherFactory).forEach(dependency -> dependency.register(builder)); - return builder; + return new CompositeDependency(this.group, this.affinityFactory, this.dispatcherFactory).register(builder); } @Override diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/RouteRegistryEntryProviderBuilder.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/RouteRegistryEntryProviderBuilder.java index a12fe6ad4f21..497e8df30f84 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/RouteRegistryEntryProviderBuilder.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/RouteRegistryEntryProviderBuilder.java @@ -39,7 +39,7 @@ * Service that provides the {@link Map.Entry} for the routing {@link org.wildfly.clustering.registry.Registry}. * @author Paul Ferraro */ -public class RouteRegistryEntryProviderBuilder implements CapabilityServiceBuilder> { +public class RouteRegistryEntryProviderBuilder implements CapabilityServiceBuilder>, Function> { private final String serverName; private final ValueDependency route; @@ -49,6 +49,11 @@ public RouteRegistryEntryProviderBuilder(String serverName, ValueDependency apply(String route) { + return new AbstractMap.SimpleImmutableEntry<>(route, null); + } + @Override public ServiceName getServiceName() { return ServiceName.parse(ClusteringCacheRequirement.REGISTRY_ENTRY.resolve(InfinispanSessionManagerFactoryBuilder.DEFAULT_CACHE_CONTAINER, this.serverName)); @@ -56,7 +61,6 @@ public ServiceName getServiceName() { @Override public ServiceBuilder> build(ServiceTarget target) { - Function> mapper = route -> new AbstractMap.SimpleImmutableEntry<>(route, null); - return this.route.register(target.addService(this.getServiceName(), new MappedValueService<>(mapper, this.route))).setInitialMode(ServiceController.Mode.ON_DEMAND); + return this.route.register(target.addService(this.getServiceName(), new MappedValueService<>(this, this.route))).setInitialMode(ServiceController.Mode.ON_DEMAND); } } diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/SessionExpirationScheduler.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/SessionExpirationScheduler.java index e4caaec75e6f..405595a870a4 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/SessionExpirationScheduler.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/SessionExpirationScheduler.java @@ -117,16 +117,20 @@ public void cancel(Locality locality) { @Override public void close() { this.executor.shutdown(); - this.expirationFutures.values().forEach(future -> future.cancel(false)); - this.expirationFutures.values().stream().filter(future -> !future.isDone()).forEach(future -> { - try { - future.get(); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - } catch (ExecutionException e) { - // Ignore + for (Future future : this.expirationFutures.values()) { + future.cancel(true); + } + for (Future future : this.expirationFutures.values()) { + if (!future.isDone()) { + try { + future.get(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } catch (ExecutionException e) { + // Ignore + } } - }); + } this.expirationFutures.clear(); } diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributes.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributes.java index c707f68a2221..cfcf4e995a1a 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributes.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributes.java @@ -113,7 +113,9 @@ public Object getAttribute(String name) { @Override public void close() { if (!this.properties.isTransactional()) { - this.mutations.values().forEach(Mutator::mutate); + for (Mutator mutator : this.mutations.values()) { + mutator.mutate(); + } } this.mutations.clear(); } diff --git a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributesFactory.java b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributesFactory.java index 306b38d1b3b0..1903814d5de2 100644 --- a/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributesFactory.java +++ b/clustering/web/infinispan/src/main/java/org/wildfly/clustering/web/infinispan/session/fine/FineSessionAttributesFactory.java @@ -92,7 +92,9 @@ public SessionAttributeNamesEntry findValue(String id) { public boolean remove(String id) { SessionAttributeNamesEntry entry = this.namesCache.getAdvancedCache().withFlags(Flag.FORCE_SYNCHRONOUS).remove(new SessionAttributeNamesKey(id)); if (entry == null) return false; - entry.getNames().values().forEach(attributeId -> this.attributeCache.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).remove(new SessionAttributeKey(id, attributeId))); + for (Integer attributeId : entry.getNames().values()) { + this.attributeCache.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).remove(new SessionAttributeKey(id, attributeId)); + } return true; } @@ -101,13 +103,13 @@ public boolean evict(String id) { SessionAttributeNamesKey key = new SessionAttributeNamesKey(id); SessionAttributeNamesEntry entry = this.namesCache.getAdvancedCache().withFlags(EVICTION_FLAGS).get(key); if (entry != null) { - entry.getNames().entrySet().stream().forEach(attribute -> { + for (Map.Entry attribute : entry.getNames().entrySet()) { try { this.attributeCache.evict(new SessionAttributeKey(id, attribute.getValue())); } catch (Throwable e) { InfinispanWebLogger.ROOT_LOGGER.failedToPassivateSessionAttribute(e, id, attribute.getKey()); } - }); + } this.namesCache.getAdvancedCache().withFlags(Flag.FAIL_SILENTLY).evict(key); } return (entry != null); diff --git a/clustering/web/spi/src/main/java/org/wildfly/clustering/web/session/SessionAttributeImmutability.java b/clustering/web/spi/src/main/java/org/wildfly/clustering/web/session/SessionAttributeImmutability.java index 40808c7abdaa..3d410fb037c9 100644 --- a/clustering/web/spi/src/main/java/org/wildfly/clustering/web/session/SessionAttributeImmutability.java +++ b/clustering/web/spi/src/main/java/org/wildfly/clustering/web/session/SessionAttributeImmutability.java @@ -37,7 +37,10 @@ public enum SessionAttributeImmutability implements Predicate { @Override public boolean test(Object object) { // Skip Collection test, we override this below to extend the immutability test for collection elements. - return EnumSet.complementOf(EnumSet.of(Immutability.COLLECTION)).stream().anyMatch(predicate -> predicate.test(object)); + for (Immutability immutability : EnumSet.complementOf(EnumSet.of(Immutability.COLLECTION))) { + if (immutability.test(object)) return true; + } + return false; } }, COLLECTION() { @@ -54,6 +57,11 @@ public boolean test(Object object) { }, ; - public static final Predicate INSTANCE = object -> EnumSet.allOf(SessionAttributeImmutability.class).stream().anyMatch(predicate -> predicate.test(object)); + public static final Predicate INSTANCE = object -> { + for (SessionAttributeImmutability immutability : EnumSet.allOf(SessionAttributeImmutability.class)) { + if (immutability.test(object)) return true; + } + return false; + }; static final Predicate COLLECTION_INSTANCE = new CollectionImmutability(INSTANCE); } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilder.java index 683ca58fa85b..2b055a4b363a 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilder.java @@ -21,6 +21,8 @@ */ package org.wildfly.clustering.web.undertow.session; +import java.util.function.Function; + import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.controller.capability.CapabilityServiceSupport; import org.jboss.as.web.session.RoutingSupport; @@ -41,7 +43,7 @@ * Builds a distributable {@link SessionIdentifierCodec} service. * @author Paul Ferraro */ -public class DistributableSessionIdentifierCodecBuilder implements CapabilityServiceBuilder { +public class DistributableSessionIdentifierCodecBuilder implements CapabilityServiceBuilder, Function { private final ServiceName name; private final CapabilityServiceBuilder locatorBuilder; @@ -49,10 +51,14 @@ public class DistributableSessionIdentifierCodecBuilder implements CapabilitySer public DistributableSessionIdentifierCodecBuilder(ServiceName name, String serverName, String deploymentName, RouteLocatorBuilderProvider provider) { this.name = name; - this.locatorBuilder = provider.getRouteLocatorBuilder(serverName, deploymentName); } + @Override + public SessionIdentifierCodec apply(RouteLocator locator) { + return new DistributableSessionIdentifierCodec(locator, this.routing); + } + @Override public ServiceName getServiceName() { return this.name; @@ -68,7 +74,7 @@ public Builder configure(CapabilityServiceSupport suppor public ServiceBuilder build(ServiceTarget target) { this.locatorBuilder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); InjectedValue locatorValue = new InjectedValue<>(); - Service service = new MappedValueService<>(locator -> new DistributableSessionIdentifierCodec(locator, this.routing), locatorValue); + Service service = new MappedValueService<>(this, locatorValue); return target.addService(this.name, service) .addDependency(this.locatorBuilder.getServiceName(), RouteLocator.class, locatorValue) .setInitialMode(ServiceController.Mode.ON_DEMAND) diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilderProvider.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilderProvider.java index e22faadeeea0..fe4858ea56b4 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilderProvider.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionIdentifierCodecBuilderProvider.java @@ -24,9 +24,7 @@ import java.util.Collection; import java.util.LinkedList; -import java.util.Optional; import java.util.ServiceLoader; -import java.util.stream.StreamSupport; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.web.session.SessionIdentifierCodec; @@ -43,12 +41,18 @@ @MetaInfServices(org.wildfly.extension.undertow.session.DistributableSessionIdentifierCodecBuilderProvider.class) public class DistributableSessionIdentifierCodecBuilderProvider implements org.wildfly.extension.undertow.session.DistributableSessionIdentifierCodecBuilderProvider { - private static final Optional PROVIDER = StreamSupport.stream(ServiceLoader.load(RouteLocatorBuilderProvider.class, RouteLocatorBuilderProvider.class.getClassLoader()).spliterator(), false).findFirst(); + private static final RouteLocatorBuilderProvider PROVIDER = loadProvider(); + + private static RouteLocatorBuilderProvider loadProvider() { + for (RouteLocatorBuilderProvider provider : ServiceLoader.load(RouteLocatorBuilderProvider.class, RouteLocatorBuilderProvider.class.getClassLoader())) { + return provider; + } + return null; + } @Override public CapabilityServiceBuilder getDeploymentBuilder(ServiceName name, String serverName, String deploymentName) { - Optional> builder = PROVIDER.map(provider -> new DistributableSessionIdentifierCodecBuilder(name, serverName, deploymentName, provider)); - return builder.orElse(new SimpleSessionIdentifierCodecBuilder(name, serverName)); + return (PROVIDER != null) ? new DistributableSessionIdentifierCodecBuilder(name, serverName, deploymentName, PROVIDER) : new SimpleSessionIdentifierCodecBuilder(name, serverName); } @Override @@ -57,7 +61,9 @@ public Collection> getServerBuilders(String serverNa CapabilityServiceBuilder routeBuilder = new RouteBuilder(serverName); builders.add(routeBuilder); ValueDependency routeDependency = new InjectedValueDependency<>(routeBuilder, String.class); - PROVIDER.ifPresent(provider -> builders.addAll(provider.getRouteLocatorConfigurationBuilders(serverName, routeDependency))); + if (PROVIDER != null) { + builders.addAll(PROVIDER.getRouteLocatorConfigurationBuilders(serverName, routeDependency)); + } return builders; } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilder.java index e531ba98c93a..0753dea54381 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilder.java @@ -61,7 +61,7 @@ * Distributable {@link SessionManagerFactory} builder for Undertow. * @author Paul Ferraro */ -public class DistributableSessionManagerFactoryBuilder implements CapabilityServiceBuilder { +public class DistributableSessionManagerFactoryBuilder implements CapabilityServiceBuilder, Function, SessionManagerFactory> { static final Map strategies = new EnumMap<>(ReplicationGranularity.class); static { @@ -149,6 +149,11 @@ public LocalContextFactory getLocalContextFactory() { this.factoryBuilder = provider.getBuilder(configuration); } + @Override + public SessionManagerFactory apply(org.wildfly.clustering.web.session.SessionManagerFactory factory) { + return new DistributableSessionManagerFactory(factory, this.config); + } + @Override public ServiceName getServiceName() { return this.name; @@ -160,15 +165,14 @@ public Builder configure(CapabilityServiceSupport support return this; } + @SuppressWarnings("unchecked") @Override public ServiceBuilder build(ServiceTarget target) { this.factoryBuilder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); - @SuppressWarnings("rawtypes") - InjectedValue sessionManagerFactoryValue = new InjectedValue<>(); - @SuppressWarnings("unchecked") - Service service = new MappedValueService<>(sessionManagerFactory -> new DistributableSessionManagerFactory(sessionManagerFactory, this.config), sessionManagerFactoryValue); + InjectedValue> sessionManagerFactoryValue = new InjectedValue<>(); + Service service = new MappedValueService<>(this, sessionManagerFactoryValue); return target.addService(this.name, service) - .addDependency(this.factoryBuilder.getServiceName(), org.wildfly.clustering.web.session.SessionManagerFactory.class, sessionManagerFactoryValue) + .addDependency(this.factoryBuilder.getServiceName(), (Class>) (Class) org.wildfly.clustering.web.session.SessionManagerFactory.class, sessionManagerFactoryValue) .setInitialMode(ServiceController.Mode.ON_DEMAND); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilderProvider.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilderProvider.java index 3be037b76d52..52de7906d197 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilderProvider.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/DistributableSessionManagerFactoryBuilderProvider.java @@ -22,14 +22,13 @@ package org.wildfly.clustering.web.undertow.session; -import java.util.Optional; import java.util.ServiceLoader; -import java.util.stream.StreamSupport; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.clustering.controller.SimpleCapabilityServiceBuilder; import org.jboss.msc.service.ServiceName; import org.kohsuke.MetaInfServices; +import org.wildfly.clustering.ee.Batch; import org.wildfly.clustering.web.session.SessionManagerFactoryBuilderProvider; import org.wildfly.extension.undertow.logging.UndertowLogger; import org.wildfly.extension.undertow.session.DistributableSessionManagerConfiguration; @@ -43,16 +42,21 @@ @MetaInfServices(org.wildfly.extension.undertow.session.DistributableSessionManagerFactoryBuilderProvider.class) public class DistributableSessionManagerFactoryBuilderProvider implements org.wildfly.extension.undertow.session.DistributableSessionManagerFactoryBuilderProvider { - @SuppressWarnings("rawtypes") - private static final Optional PROVIDER = StreamSupport.stream(ServiceLoader.load(SessionManagerFactoryBuilderProvider.class, SessionManagerFactoryBuilderProvider.class.getClassLoader()).spliterator(), false).findFirst(); + private static final SessionManagerFactoryBuilderProvider PROVIDER = loadProvider(); + + private static SessionManagerFactoryBuilderProvider loadProvider() { + for (SessionManagerFactoryBuilderProvider provider : ServiceLoader.load(SessionManagerFactoryBuilderProvider.class, SessionManagerFactoryBuilderProvider.class.getClassLoader())) { + return provider; + } + return null; + } @Override public CapabilityServiceBuilder getBuilder(ServiceName name, DistributableSessionManagerConfiguration configuration) { - @SuppressWarnings("unchecked") - Optional> builder = PROVIDER.map(provider -> new DistributableSessionManagerFactoryBuilder(name, configuration, provider)); - return builder.orElseGet(() -> { + if (PROVIDER == null) { UndertowLogger.ROOT_LOGGER.clusteringNotSupported(); return new SimpleCapabilityServiceBuilder<>(name, new InMemorySessionManagerFactory(configuration.getMaxActiveSessions())); - }); + } + return new DistributableSessionManagerFactoryBuilder(name, configuration, PROVIDER); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/RouteBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/RouteBuilder.java index 9fc1df27c6fe..b2476916fdd4 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/RouteBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/session/RouteBuilder.java @@ -22,6 +22,8 @@ package org.wildfly.clustering.web.undertow.session; +import java.util.function.Function; + import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.controller.capability.CapabilityServiceSupport; import org.jboss.msc.service.Service; @@ -40,7 +42,7 @@ * Builds a service providing the route of a server. * @author Paul Ferraro */ -public class RouteBuilder implements CapabilityServiceBuilder { +public class RouteBuilder implements CapabilityServiceBuilder, Function { private final String serverName; @@ -50,6 +52,11 @@ public RouteBuilder(String serverName) { this.serverName = serverName; } + @Override + public String apply(Server server) { + return server.getRoute(); + } + @Override public ServiceName getServiceName() { return ServiceName.JBOSS.append("clustering", "web", "route", this.serverName); @@ -63,7 +70,7 @@ public Builder configure(CapabilityServiceSupport support) { @Override public ServiceBuilder build(ServiceTarget target) { - Service service = new MappedValueService<>(server -> server.getRoute(), this.server); + Service service = new MappedValueService<>(this, this.server); return this.server.register(target.addService(this.getServiceName(), service)).setInitialMode(ServiceController.Mode.ON_DEMAND); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilder.java index b47ddba97539..f352483c29c3 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilder.java @@ -29,7 +29,6 @@ import java.util.Arrays; import java.util.Collection; -import java.util.stream.Stream; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.controller.capability.CapabilityServiceSupport; @@ -41,6 +40,7 @@ import org.jboss.msc.value.Value; import org.wildfly.clustering.ee.Batch; import org.wildfly.clustering.service.Builder; +import org.wildfly.clustering.service.CompositeDependency; import org.wildfly.clustering.service.InjectedValueDependency; import org.wildfly.clustering.service.ValueDependency; import org.wildfly.clustering.web.sso.SSOManager; @@ -52,16 +52,16 @@ * Builds a distributable {@link SingleSignOnManagerFactory} service. * @author Paul Ferraro */ -public class DistributableSingleSignOnManagerBuilder implements CapabilityServiceBuilder { +public class DistributableSingleSignOnManagerBuilder implements CapabilityServiceBuilder, Value { private final ServiceName name; - @SuppressWarnings("rawtypes") - private final ValueDependency manager; + private final ValueDependency> manager; private final ValueDependency registry; private final Collection> builders; + @SuppressWarnings("unchecked") public DistributableSingleSignOnManagerBuilder(ServiceName name, String serverName, String hostName, SSOManagerFactoryBuilderProvider provider) { this.name = name; @@ -69,14 +69,12 @@ public DistributableSingleSignOnManagerBuilder(ServiceName name, String serverNa ServiceName generatorServiceName = this.name.append("generator"); CapabilityServiceBuilder generatorBuilder = new SessionIdGeneratorBuilder(generatorServiceName, serverName); - @SuppressWarnings("rawtypes") - ValueDependency factoryDependency = new InjectedValueDependency<>(factoryBuilder, SSOManagerFactory.class); + ValueDependency> factoryDependency = new InjectedValueDependency<>(factoryBuilder, (Class>) (Class) SSOManagerFactory.class); ValueDependency generatorDependency = new InjectedValueDependency<>(generatorServiceName, SessionIdGenerator.class); ServiceName managerServiceName = this.name.append("manager"); CapabilityServiceBuilder> managerBuilder = new SSOManagerBuilder<>(managerServiceName, factoryDependency, generatorDependency, () -> null); - @SuppressWarnings("rawtypes") - ValueDependency managerDependency = new InjectedValueDependency<>(managerServiceName, SSOManager.class); + ValueDependency> managerDependency = new InjectedValueDependency<>(managerServiceName, (Class>) (Class) SSOManager.class); ServiceName listenerServiceName = this.name.append("listener"); CapabilityServiceBuilder listenerBuilder = new SessionListenerBuilder(listenerServiceName, managerDependency); @@ -84,12 +82,17 @@ public DistributableSingleSignOnManagerBuilder(ServiceName name, String serverNa ServiceName registryServiceName = this.name.append("registry"); CapabilityServiceBuilder registryBuilder = new SessionManagerRegistryBuilder(registryServiceName, serverName, hostName, listenerDependency); - this.manager = new InjectedValueDependency<>(managerBuilder, SSOManager.class); + this.manager = new InjectedValueDependency<>(managerBuilder, (Class>) (Class) SSOManager.class); this.registry = new InjectedValueDependency<>(registryBuilder, SessionManagerRegistry.class); this.builders = Arrays.asList(factoryBuilder, generatorBuilder, managerBuilder, listenerBuilder, registryBuilder); } + @Override + public SingleSignOnManager getValue() { + return new DistributableSingleSignOnManager(this.manager.getValue(), this.registry.getValue()); + } + @Override public ServiceName getServiceName() { return this.name; @@ -97,16 +100,18 @@ public ServiceName getServiceName() { @Override public Builder configure(CapabilityServiceSupport support) { - this.builders.forEach(builder -> builder.configure(support)); + for (CapabilityServiceBuilder builder : this.builders) { + builder.configure(support); + } return this; } @Override public ServiceBuilder build(ServiceTarget target) { - this.builders.forEach(builder -> builder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install()); - Value manager = () -> new DistributableSingleSignOnManager(this.manager.getValue(), this.registry.getValue()); - ServiceBuilder builder = target.addService(this.name, new ValueService<>(manager)).setInitialMode(ServiceController.Mode.ON_DEMAND); - Stream.of(this.manager, this.registry).forEach(dependency -> dependency.register(builder)); - return builder; + for (CapabilityServiceBuilder builder : this.builders) { + builder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); + } + ServiceBuilder builder = target.addService(this.name, new ValueService<>(this)).setInitialMode(ServiceController.Mode.ON_DEMAND); + return new CompositeDependency(this.manager, this.registry).register(builder); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilderProvider.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilderProvider.java index 87e35e71e870..5020d70bf5d4 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilderProvider.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/DistributableSingleSignOnManagerBuilderProvider.java @@ -22,14 +22,13 @@ package org.wildfly.clustering.web.undertow.sso; -import java.util.Optional; import java.util.ServiceLoader; -import java.util.stream.StreamSupport; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.clustering.controller.SimpleCapabilityServiceBuilder; import org.jboss.msc.service.ServiceName; import org.kohsuke.MetaInfServices; +import org.wildfly.clustering.ee.Batch; import org.wildfly.clustering.web.sso.SSOManagerFactoryBuilderProvider; import org.wildfly.extension.undertow.security.sso.DistributableHostSingleSignOnManagerBuilderProvider; @@ -41,13 +40,18 @@ */ @MetaInfServices(DistributableHostSingleSignOnManagerBuilderProvider.class) public class DistributableSingleSignOnManagerBuilderProvider implements DistributableHostSingleSignOnManagerBuilderProvider { - @SuppressWarnings("rawtypes") - private static final Optional PROVIDER = StreamSupport.stream(ServiceLoader.load(SSOManagerFactoryBuilderProvider.class, SSOManagerFactoryBuilderProvider.class.getClassLoader()).spliterator(), false).findFirst(); + + private static final SSOManagerFactoryBuilderProvider PROVIDER = loadProvider(); + + private static SSOManagerFactoryBuilderProvider loadProvider() { + for (SSOManagerFactoryBuilderProvider provider : ServiceLoader.load(SSOManagerFactoryBuilderProvider.class, SSOManagerFactoryBuilderProvider.class.getClassLoader())) { + return provider; + } + return null; + } @Override public CapabilityServiceBuilder getBuilder(ServiceName name, String serverName, String hostName) { - @SuppressWarnings("unchecked") - Optional> builder = PROVIDER.map(provider -> new DistributableSingleSignOnManagerBuilder(name, serverName, hostName, provider)); - return builder.orElse(new SimpleCapabilityServiceBuilder<>(name, new InMemorySingleSignOnManager())); + return (PROVIDER != null) ? new DistributableSingleSignOnManagerBuilder(name, serverName, hostName, PROVIDER) : new SimpleCapabilityServiceBuilder<>(name, new InMemorySingleSignOnManager()); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SSOManagerBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SSOManagerBuilder.java index c514e346f2d6..febaf74a0684 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SSOManagerBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SSOManagerBuilder.java @@ -25,7 +25,6 @@ import java.io.Externalizable; import java.io.Serializable; import java.util.function.Function; -import java.util.stream.Stream; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.marshalling.MarshallingConfiguration; @@ -48,6 +47,7 @@ import org.wildfly.clustering.marshalling.jboss.SimpleMarshallingConfigurationRepository; import org.wildfly.clustering.marshalling.jboss.SimpleMarshallingContextFactory; import org.wildfly.clustering.marshalling.spi.MarshalledValueFactory; +import org.wildfly.clustering.service.CompositeDependency; import org.wildfly.clustering.service.ValueDependency; import org.wildfly.clustering.web.IdentifierFactory; import org.wildfly.clustering.web.LocalContextFactory; @@ -90,15 +90,14 @@ public MarshallingConfiguration apply(Module module) { } private final ServiceName name; - @SuppressWarnings("rawtypes") - private final ValueDependency factory; + private final ValueDependency> factory; private final ValueDependency generator; private final LocalContextFactory localContextFactory; private volatile SSOManager manager; private volatile MarshallingContext context; - public SSOManagerBuilder(ServiceName name, @SuppressWarnings("rawtypes") ValueDependency factory, ValueDependency generator, LocalContextFactory localContextFactory) { + public SSOManagerBuilder(ServiceName name, ValueDependency> factory, ValueDependency generator, LocalContextFactory localContextFactory) { this.name = name; this.factory = factory; this.generator = generator; @@ -113,8 +112,7 @@ public ServiceName getServiceName() { @Override public ServiceBuilder> build(ServiceTarget target) { ServiceBuilder> builder = target.addService(this.getServiceName(), this); - Stream.of(this.factory, this.generator).forEach(dependency -> dependency.register(builder)); - return builder; + return new CompositeDependency(this.factory, this.generator).register(builder); } @Override diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionIdGeneratorBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionIdGeneratorBuilder.java index 30e80a9e551f..3023dd0d6fd5 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionIdGeneratorBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionIdGeneratorBuilder.java @@ -43,7 +43,7 @@ /** * @author Paul Ferraro */ -public class SessionIdGeneratorBuilder implements CapabilityServiceBuilder { +public class SessionIdGeneratorBuilder implements CapabilityServiceBuilder, Function { private final ServiceName name; private final String serverName; @@ -55,6 +55,13 @@ public SessionIdGeneratorBuilder(ServiceName name, String serverName) { this.serverName = serverName; } + @Override + public SessionIdGenerator apply(Server server) { + SecureRandomSessionIdGenerator generator = new SecureRandomSessionIdGenerator(); + generator.setLength(server.getServletContainer().getSessionIdLength()); + return generator; + } + @Override public ServiceName getServiceName() { return this.name; @@ -68,12 +75,7 @@ public Builder configure(CapabilityServiceSupport support) { @Override public ServiceBuilder build(ServiceTarget target) { - Function mapper = server -> { - SecureRandomSessionIdGenerator generator = new SecureRandomSessionIdGenerator(); - generator.setLength(server.getServletContainer().getSessionIdLength()); - return generator; - }; - Service service = new MappedValueService<>(mapper, this.server); + Service service = new MappedValueService<>(this, this.server); return this.server.register(target.addService(this.getServiceName(), service)); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionListenerBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionListenerBuilder.java index e66a4304d7bf..9e494344f6d2 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionListenerBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionListenerBuilder.java @@ -44,10 +44,9 @@ public class SessionListenerBuilder implements CapabilityServiceBuilder, Value, SessionListener { private final ServiceName name; - @SuppressWarnings("rawtypes") - private final ValueDependency manager; + private final ValueDependency> manager; - public SessionListenerBuilder(ServiceName name, @SuppressWarnings("rawtypes") ValueDependency manager) { + public SessionListenerBuilder(ServiceName name, ValueDependency> manager) { this.name = name; this.manager = manager; } @@ -73,9 +72,13 @@ public void sessionIdChanged(Session session, String oldSessionId) { try (Batch batch = manager.getBatcher().createBatch()) { Sessions sessions = manager.findSessionsContaining(oldSessionId); if (sessions != null) { - String deployment = sessions.getDeployments().stream().filter(key -> sessions.getSession(key) != null).findFirst().get(); - sessions.removeSession(deployment); - sessions.addSession(deployment, session.getId()); + for (String deployment : sessions.getDeployments()) { + if (sessions.getSession(deployment) != null) { + sessions.removeSession(deployment); + sessions.addSession(deployment, session.getId()); + break; + } + } } } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionManagerRegistryBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionManagerRegistryBuilder.java index 66d1ecac87c1..630d47f43aca 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionManagerRegistryBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/SessionManagerRegistryBuilder.java @@ -23,7 +23,6 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; -import java.util.stream.Stream; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.controller.capability.CapabilityServiceSupport; @@ -36,6 +35,7 @@ import org.jboss.msc.service.StartException; import org.jboss.msc.service.StopContext; import org.wildfly.clustering.service.Builder; +import org.wildfly.clustering.service.CompositeDependency; import org.wildfly.clustering.service.InjectedValueDependency; import org.wildfly.clustering.service.ValueDependency; import org.wildfly.clustering.web.undertow.UndertowBinaryRequirement; @@ -86,8 +86,7 @@ public Builder configure(CapabilityServiceSupport suppor @Override public ServiceBuilder build(ServiceTarget target) { ServiceBuilder builder = target.addService(this.name, this).setInitialMode(ServiceController.Mode.ON_DEMAND); - Stream.of(this.listener, this.service, this.host).forEach(dependency -> dependency.register(builder)); - return builder; + return new CompositeDependency(this.listener, this.service, this.host).register(builder); } @Override @@ -98,12 +97,16 @@ public SessionManagerRegistry getValue() { @Override public void start(StartContext context) throws StartException { this.service.getValue().registerListener(this); - this.host.getValue().getDeployments().forEach(deployment -> this.addDeployment(deployment)); + for (Deployment deployment : this.host.getValue().getDeployments()) { + this.addDeployment(deployment); + } } @Override public void stop(StopContext context) { - this.host.getValue().getDeployments().forEach(deployment -> this.removeDeployment(deployment)); + for (Deployment deployment : this.host.getValue().getDeployments()) { + this.removeDeployment(deployment); + } this.service.getValue().unregisterListener(this); } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOn.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOn.java index d9c21a1f3477..03699742b9f4 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOn.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOn.java @@ -25,10 +25,9 @@ import java.net.URI; import java.util.AbstractMap; import java.util.Collections; +import java.util.HashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; -import java.util.function.Function; -import java.util.stream.Collectors; import org.wildfly.clustering.ee.Batch; import org.wildfly.clustering.ee.BatchContext; @@ -84,7 +83,11 @@ public SecurityIdentity getIdentity() { public Map> getParticipants() { try (BatchContext context = this.batcher.resumeBatch(this.batch)) { Sessions> sessions = this.sso.getSessions(); - return Collections.unmodifiableMap(sessions.getDeployments().stream().collect(Collectors.toMap(Function.identity(), deployment -> sessions.getSession(deployment)))); + Map> participants = new HashMap<>(); + for (String deployment : sessions.getDeployments()) { + participants.put(deployment, sessions.getSession(deployment)); + } + return Collections.unmodifiableMap(participants); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilder.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilder.java index ba5240a7f5c8..d31de93dfbc3 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilder.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilder.java @@ -26,6 +26,8 @@ import java.util.Arrays; import java.util.Collection; import java.util.Map; +import java.util.Map.Entry; +import java.util.function.Function; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.controller.capability.CapabilityServiceSupport; @@ -51,29 +53,33 @@ /** * @author Paul Ferraro */ -public class DistributableSingleSignOnManagerBuilder implements CapabilityServiceBuilder { +public class DistributableSingleSignOnManagerBuilder implements CapabilityServiceBuilder, Function, LocalSSOContext, Batch>, SingleSignOnManager> { private final ServiceName name; - @SuppressWarnings("rawtypes") - private final ValueDependency manager; + private final ValueDependency, LocalSSOContext, Batch>> manager; private final Collection> builders; + @SuppressWarnings("unchecked") public DistributableSingleSignOnManagerBuilder(ServiceName name, String securityDomainName, SessionIdGenerator generator, SSOManagerFactoryBuilderProvider provider) { this.name = name; CapabilityServiceBuilder, Batch>> factoryBuilder = provider.>getBuilder(securityDomainName); - @SuppressWarnings("rawtypes") - ValueDependency factoryDependency = new InjectedValueDependency<>(factoryBuilder, SSOManagerFactory.class); + ValueDependency, Batch>> factoryDependency = new InjectedValueDependency<>(factoryBuilder, (Class, Batch>>) (Class) SSOManagerFactory.class); ValueDependency generatorDependency = new ImmediateValueDependency<>(generator); ServiceName managerServiceName = this.name.append("manager"); CapabilityServiceBuilder, LocalSSOContext, Batch>> managerBuilder = new SSOManagerBuilder<>(managerServiceName, factoryDependency, generatorDependency, new LocalSSOContextFactory()); - this.manager = new InjectedValueDependency<>(managerServiceName, SSOManager.class); + this.manager = new InjectedValueDependency<>(managerServiceName, (Class, LocalSSOContext, Batch>>) (Class) SSOManager.class); this.builders = Arrays.asList(factoryBuilder, managerBuilder); } + @Override + public SingleSignOnManager apply(SSOManager, LocalSSOContext, Batch> manager) { + return new DistributableSingleSignOnManager(manager); + } + @Override public ServiceName getServiceName() { return this.name; @@ -81,15 +87,18 @@ public ServiceName getServiceName() { @Override public Builder configure(CapabilityServiceSupport support) { - this.builders.forEach(builder -> builder.configure(support)); + for (CapabilityServiceBuilder builder : this.builders) { + builder.configure(support); + } return this; } @Override public ServiceBuilder build(ServiceTarget target) { - this.builders.forEach(builder -> builder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install()); - @SuppressWarnings("unchecked") - Service service = new MappedValueService<>(manager -> new DistributableSingleSignOnManager(manager), this.manager); + for (CapabilityServiceBuilder builder : this.builders) { + builder.build(target).setInitialMode(ServiceController.Mode.ON_DEMAND).install(); + } + Service service = new MappedValueService<>(this, this.manager); return this.manager.register(target.addService(this.name, service)).setInitialMode(ServiceController.Mode.ON_DEMAND); } } diff --git a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilderProvider.java b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilderProvider.java index 1fa1e079d9d8..9ff6349dba33 100644 --- a/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilderProvider.java +++ b/clustering/web/undertow/src/main/java/org/wildfly/clustering/web/undertow/sso/elytron/DistributableSingleSignOnManagerBuilderProvider.java @@ -22,15 +22,14 @@ package org.wildfly.clustering.web.undertow.sso.elytron; -import java.util.Optional; import java.util.ServiceLoader; import java.util.concurrent.ConcurrentHashMap; -import java.util.stream.StreamSupport; import org.jboss.as.clustering.controller.CapabilityServiceBuilder; import org.jboss.as.clustering.controller.SimpleCapabilityServiceBuilder; import org.jboss.msc.service.ServiceName; import org.kohsuke.MetaInfServices; +import org.wildfly.clustering.ee.Batch; import org.wildfly.clustering.web.sso.SSOManagerFactoryBuilderProvider; import org.wildfly.extension.undertow.security.sso.DistributableSecurityDomainSingleSignOnManagerBuilderProvider; import org.wildfly.security.http.util.sso.DefaultSingleSignOnManager; @@ -44,13 +43,17 @@ @MetaInfServices(DistributableSecurityDomainSingleSignOnManagerBuilderProvider.class) public class DistributableSingleSignOnManagerBuilderProvider implements DistributableSecurityDomainSingleSignOnManagerBuilderProvider { - @SuppressWarnings("rawtypes") - private static final Optional PROVIDER = StreamSupport.stream(ServiceLoader.load(SSOManagerFactoryBuilderProvider.class, SSOManagerFactoryBuilderProvider.class.getClassLoader()).spliterator(), false).findFirst(); + private static final SSOManagerFactoryBuilderProvider PROVIDER = loadProvider(); + + private static SSOManagerFactoryBuilderProvider loadProvider() { + for (SSOManagerFactoryBuilderProvider provider : ServiceLoader.load(SSOManagerFactoryBuilderProvider.class, SSOManagerFactoryBuilderProvider.class.getClassLoader())) { + return provider; + } + return null; + } @Override public CapabilityServiceBuilder getBuilder(ServiceName name, String securityDomainName, SessionIdGenerator generator) { - @SuppressWarnings("unchecked") - Optional> builder = PROVIDER.map(provider -> new DistributableSingleSignOnManagerBuilder(name, securityDomainName, generator, provider)); - return builder.orElse(new SimpleCapabilityServiceBuilder<>(name, new DefaultSingleSignOnManager(new ConcurrentHashMap<>(), generator::createSessionId))); + return (PROVIDER != null) ? new DistributableSingleSignOnManagerBuilder(name, securityDomainName, generator, PROVIDER) : new SimpleCapabilityServiceBuilder<>(name, new DefaultSingleSignOnManager(new ConcurrentHashMap<>(), generator::createSessionId)); } }