From 8f5cdd0ad1a90ef5e936954bfed88a731acb9f8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?David=20Mat=C4=9Bj=C4=8Dek?= Date: Sat, 15 Oct 2022 16:51:57 +0200 Subject: [PATCH] Value object for context types and more clear usage MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: David Matějček --- .../concurrent/runtime/ConcurrentRuntime.java | 25 +++----- .../concurrent/runtime/ContextSetup.java | 59 ++++++++--------- .../runtime/ContextSetupProviderImpl.java | 14 +++-- .../ContextServiceDefinitionDeployer.java | 2 +- .../runtime/deployer/cfg/CfgParser.java | 47 ++++++++++---- .../deployer/cfg/ConcurrentServiceCfg.java | 13 ++-- .../deployer/cfg/ContextServiceCfg.java | 24 ++++--- .../cfg/ManagedExecutorServiceCfg.java | 4 +- .../ManagedScheduledExecutorServiceCfg.java | 5 +- .../deployer/cfg/ManagedThreadFactoryCfg.java | 6 +- .../runtime/ConcurrentRuntimeTest.java | 10 +-- .../runtime/deployer/cfg/CfgParserTest.java | 17 ++--- .../types/ConcurrencyContextType.java | 35 +++++++++++ .../deployment/types/CustomContextType.java | 63 +++++++++++++++++++ .../StandardContextType.java | 36 +++++------ 15 files changed, 245 insertions(+), 115 deletions(-) create mode 100644 appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/ConcurrencyContextType.java create mode 100644 appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/CustomContextType.java rename appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/{annotation/handlers => types}/StandardContextType.java (72%) diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java index ffbc01bfcfd..0f2a5a358f6 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java @@ -19,7 +19,7 @@ import com.sun.enterprise.config.serverbeans.Applications; import com.sun.enterprise.deployment.annotation.handlers.ContextualResourceDefinition; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; import com.sun.enterprise.transaction.api.JavaEETransactionManager; import jakarta.inject.Inject; @@ -35,8 +35,6 @@ import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; -import java.util.stream.Collectors; - import javax.naming.InitialContext; import javax.naming.NamingException; @@ -62,8 +60,8 @@ import org.glassfish.resourcebase.resources.naming.ResourceNamingService; import org.jvnet.hk2.annotations.Service; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Classloader; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.WorkArea; +import static com.sun.enterprise.deployment.types.StandardContextType.*; +import static com.sun.enterprise.deployment.types.StandardContextType.WorkArea; import static java.util.Collections.emptySet; /** @@ -245,10 +243,7 @@ public ContextServiceImpl findOrCreateContextService(ContextualResourceDefinitio if (lookup2 != null) { return lookup2; } - // Create default - Set provided = Set.of(StandardContextType.Classloader, StandardContextType.JNDI, - StandardContextType.Security, StandardContextType.WorkArea).stream().map(Enum::name) - .collect(Collectors.toSet()); + Set provided = Set.of(Classloader, JNDI, Security, WorkArea); ConcurrentServiceCfg config = new ConcurrentServiceCfg(jndiName, provided, null); return contextServiceMap.computeIfAbsent(jndiName, n -> createContextService(jndiName, config, true)); } @@ -262,8 +257,8 @@ public synchronized ContextServiceImpl getContextService(ContextServiceCfg confi public synchronized ContextServiceImpl createContextService(ContextServiceCfg config) { LOG.log(Level.FINE, "createContextService(config={0})", config); - boolean keepTxUnchanged = config.getUnchangedContexts().contains(WorkArea.name()); - boolean clearTx = config.getClearedContexts().contains(WorkArea.name()); + boolean keepTxUnchanged = config.getUnchangedContexts().contains(WorkArea); + boolean clearTx = config.getClearedContexts().contains(WorkArea); TransactionSetupProvider txSetupProvider = createTxSetupProvider(keepTxUnchanged, clearTx); ContextSetupProvider ctxSetupProvider = new ContextSetupProviderImpl(config.getPropagatedContexts(), config.getClearedContexts(), config.getUnchangedContexts()); @@ -333,12 +328,12 @@ private ContextServiceImpl createContextService(String contextServiceJndiName, C LOG.log(Level.FINE, "createContextService(contextServiceJndiName={0}, config={1}, cleanupTransaction={2})", new Object[] {contextServiceJndiName, config, cleanupTransaction}); // if the context service is not known, create it - Set propagated = config.getContextInfo(); - final Set cleared; + final Set propagated = config.getContextInfo(); + final Set cleared; final boolean clearTx; - if (cleanupTransaction && !propagated.contains(WorkArea.name())) { + if (cleanupTransaction && !propagated.contains(WorkArea)) { // pass the cleanup transaction in list of cleared handlers - cleared = Set.of(WorkArea.name()); + cleared = Set.of(WorkArea); clearTx = true; } else { cleared = emptySet(); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetup.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetup.java index ba2f8f851e7..1967b708559 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetup.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetup.java @@ -17,7 +17,9 @@ package org.glassfish.concurrent.runtime; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; +import com.sun.enterprise.deployment.types.CustomContextType; +import com.sun.enterprise.deployment.types.StandardContextType; import jakarta.enterprise.concurrent.spi.ThreadContextProvider; import jakarta.enterprise.concurrent.spi.ThreadContextSnapshot; @@ -27,13 +29,13 @@ import java.lang.System.Logger.Level; import java.util.ArrayList; import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.ServiceLoader; import java.util.Set; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.standardize; import static java.util.ServiceLoader.load; /** @@ -43,16 +45,16 @@ public class ContextSetup implements Serializable { private static final long serialVersionUID = 7817957604183520917L; private static final Logger LOG = System.getLogger(ContextSetup.class.getName()); - private final Set contextPropagate; - private final Set contextClear; - private final Set contextUnchanged; - private transient Map allThreadContextProviders; + private final Set contextPropagate; + private final Set contextClear; + private final Set contextUnchanged; + private transient Map allThreadContextProviders; - public ContextSetup(Set propagated, Set cleared, Set unchanged) { - this.contextPropagate = standardize(propagated); - this.contextClear = standardize(cleared); - this.contextUnchanged = standardize(unchanged); + public ContextSetup(Set propagated, Set cleared, Set unchanged) { + this.contextPropagate = new HashSet<>(propagated); + this.contextClear = new HashSet<>(cleared); + this.contextUnchanged = new HashSet<>(unchanged); } @@ -64,17 +66,17 @@ public void reloadProviders(final ClassLoader loader) { public boolean isPropagated(StandardContextType contextType) { - return contextPropagate.contains(contextType.name()); + return contextPropagate.contains(contextType); } public boolean isClear(StandardContextType contextType) { - return contextClear.contains(contextType.name()); + return contextClear.contains(contextType); } public boolean isUnchanged(StandardContextType contextType) { - return contextUnchanged.contains(contextType.name()); + return contextUnchanged.contains(contextType); } @@ -98,39 +100,39 @@ public String toString() { } - private static Map loadAllProviders(ClassLoader loader) { + private static Map loadAllProviders(ClassLoader loader) { LOG.log(Level.TRACE, "Using classloader: {0}", loader); ServiceLoader services = load(ThreadContextProvider.class, loader); - Map providers = new HashMap<>(); + Map providers = new HashMap<>(); for (ThreadContextProvider service : services) { - String serviceName = service.getThreadContextType(); - providers.put(serviceName, service); + CustomContextType ctxType = new CustomContextType(service.getThreadContextType()); + providers.put(ctxType, service); } LOG.log(Level.DEBUG, "Detected ThreadContextProvider implementations: {0}", providers); return providers; } - private static void addRemaining(Set propagated, Set clear, Set unchanged, - Map allThreadContextProviders) { - Set remaining = chooseSet(propagated, clear, unchanged); + private static void addRemaining(Set propagated, Set clear, + Set unchanged, Map allThreadContextProviders) { + Set remaining = chooseSet(propagated, clear, unchanged); for (StandardContextType contextType : StandardContextType.values()) { if (contextType == StandardContextType.Remaining) { continue; } - final String name = contextType.name(); - addIfNotInAnotherSet(name, remaining, propagated, clear, unchanged); + addIfNotInAnotherSet(contextType, remaining, propagated, clear, unchanged); } - for (String name : allThreadContextProviders.keySet()) { + for (CustomContextType name : allThreadContextProviders.keySet()) { addIfNotInAnotherSet(name, remaining, propagated, clear, unchanged); } } - private static Set chooseSet(Set propagated, Set clear, Set unchanged) { - if (clear.contains(StandardContextType.Remaining.name())) { + private static Set chooseSet(Set propagated, + Set clear, Set unchanged) { + if (clear.contains(StandardContextType.Remaining)) { return clear; - } else if (unchanged.contains(StandardContextType.Remaining.name())) { + } else if (unchanged.contains(StandardContextType.Remaining)) { return unchanged; } else { return propagated; @@ -138,8 +140,9 @@ private static Set chooseSet(Set propagated, Set clear, } - private static void addIfNotInAnotherSet(String name, Set remaining, Set propagated, - Set clear, Set unchanged) { + private static void addIfNotInAnotherSet(ConcurrencyContextType name, Set remaining, + Set propagated, Set clear, + Set unchanged) { if (propagated.contains(name) || clear.contains(name) || unchanged.contains(name)) { return; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetupProviderImpl.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetupProviderImpl.java index 45fc2836904..9e82a590d0c 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetupProviderImpl.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ContextSetupProviderImpl.java @@ -19,7 +19,8 @@ import com.sun.enterprise.config.serverbeans.Application; import com.sun.enterprise.config.serverbeans.Applications; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; +import com.sun.enterprise.deployment.types.StandardContextType; import com.sun.enterprise.security.SecurityContext; import com.sun.enterprise.transaction.api.JavaEETransactionManager; import com.sun.enterprise.util.Utility; @@ -44,10 +45,10 @@ import org.glassfish.enterprise.concurrent.spi.ContextSetupProvider; import org.glassfish.internal.deployment.Deployment; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Classloader; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.JNDI; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Security; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.WorkArea; +import static com.sun.enterprise.deployment.types.StandardContextType.Classloader; +import static com.sun.enterprise.deployment.types.StandardContextType.JNDI; +import static com.sun.enterprise.deployment.types.StandardContextType.Security; +import static com.sun.enterprise.deployment.types.StandardContextType.WorkArea; import static jakarta.enterprise.concurrent.ManagedTask.SUSPEND; import static jakarta.enterprise.concurrent.ManagedTask.TRANSACTION; import static jakarta.enterprise.concurrent.ManagedTask.USE_TRANSACTION_OF_EXECUTION_THREAD; @@ -75,7 +76,8 @@ public class ContextSetupProviderImpl implements ContextSetupProvider { private final ContextSetup setup; - public ContextSetupProviderImpl(Set propagated, Set cleared, Set unchanged) { + public ContextSetupProviderImpl(Set propagated, Set cleared, + Set unchanged) { this.setup = new ContextSetup(propagated, cleared, unchanged); ConcurrentRuntime runtime = ConcurrentRuntime.getRuntime(); this.invocationManager = runtime.getInvocationManager(); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ContextServiceDefinitionDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ContextServiceDefinitionDeployer.java index 482a06676c3..2b6a722d20d 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ContextServiceDefinitionDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ContextServiceDefinitionDeployer.java @@ -22,7 +22,7 @@ import com.sun.enterprise.deployment.ContextServiceDefinitionDescriptor; import com.sun.enterprise.deployment.ResourceDescriptor; import com.sun.enterprise.deployment.annotation.handlers.ContextServiceDefinitionData; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.StandardContextType; import jakarta.enterprise.concurrent.ContextService; import jakarta.inject.Inject; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParser.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParser.java index a28648ab114..7ea731e09dc 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParser.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParser.java @@ -16,9 +16,15 @@ package org.glassfish.concurrent.runtime.deployer.cfg; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; +import com.sun.enterprise.deployment.types.CustomContextType; +import com.sun.enterprise.deployment.types.StandardContextType; +import jakarta.enterprise.concurrent.ContextServiceDefinition; + +import java.util.Arrays; import java.util.HashSet; +import java.util.List; import java.util.Set; /** @@ -31,21 +37,40 @@ private CfgParser() { } - static Set parseContextInfo(String contextInfo, String contextInfoEnabled) { - Set contextTypeArray = new HashSet<>(); + static Set parseContextInfo(String contextInfo, String contextInfoEnabled) { if (contextInfo == null || !Boolean.TRUE.toString().equalsIgnoreCase(contextInfoEnabled)) { - return StandardContextType.names(); + return Set.of(StandardContextType.values()); } - String[] strings = contextInfo.split(","); - for (String string : strings) { - String contextType = string.trim(); - if (contextType.isEmpty()) { + List strings = Arrays.asList(contextInfo.split(",")); + return standardize(strings); + } + + + /** + * Converts strings from annotations and xml to enums. + * If the provided context name is not supported, it is returned without changes. + * + * @param contexts + * @return set of enum names. + */ + public static Set standardize(Iterable contexts) { + Set result = new HashSet<>(); + for (String input : contexts) { + final String context = input.trim(); + if (context.isEmpty()) { continue; } - StandardContextType standardContextType = StandardContextType.parse(contextType); - contextTypeArray.add(standardContextType == null ? contextType : standardContextType.name()); + if (ContextServiceDefinition.TRANSACTION.equalsIgnoreCase(context)) { + result.add(StandardContextType.WorkArea); + } + if (ContextServiceDefinition.APPLICATION.equals(context)) { + result.add(StandardContextType.Classloader); + result.add(StandardContextType.JNDI); + } + StandardContextType contextType = StandardContextType.parse(context); + result.add(contextType == null ? new CustomContextType(context) : contextType); } - return contextTypeArray; + return result; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ConcurrentServiceCfg.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ConcurrentServiceCfg.java index a9504f445ab..5e270c9689c 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ConcurrentServiceCfg.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ConcurrentServiceCfg.java @@ -17,7 +17,8 @@ package org.glassfish.concurrent.runtime.deployer.cfg; -import com.sun.enterprise.deployment.annotation.handlers.StandardContextType; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; +import com.sun.enterprise.deployment.types.StandardContextType; import java.io.Serializable; import java.util.Collections; @@ -27,7 +28,7 @@ public final class ConcurrentServiceCfg implements Serializable { private static final long serialVersionUID = -9039607497553448223L; private final String jndiName; - private final Set contextInfo; + private final Set contextInfo; private final String context; public ConcurrentServiceCfg(String jndiName) { @@ -35,14 +36,14 @@ public ConcurrentServiceCfg(String jndiName) { } - public ConcurrentServiceCfg(String jndiName, Set contextInfo) { + public ConcurrentServiceCfg(String jndiName, Set contextInfo) { this.jndiName = jndiName; this.contextInfo = contextInfo; this.context = null; } - public ConcurrentServiceCfg(String jndiName, Set contextInfo, String context) { + public ConcurrentServiceCfg(String jndiName, Set contextInfo, String context) { this.jndiName = jndiName; this.contextInfo = contextInfo; this.context = context; @@ -51,7 +52,7 @@ public ConcurrentServiceCfg(String jndiName, Set contextInfo, String con public ConcurrentServiceCfg(String jndiName, StandardContextType contextInfo, String context) { this.jndiName = jndiName; - this.contextInfo = Set.of(contextInfo.name()); + this.contextInfo = Set.of(contextInfo); this.context = context; } @@ -61,7 +62,7 @@ public String getJndiName() { } - public Set getContextInfo() { + public Set getContextInfo() { return contextInfo; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ContextServiceCfg.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ContextServiceCfg.java index b00765ea9db..9084f4a8771 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ContextServiceCfg.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ContextServiceCfg.java @@ -17,6 +17,7 @@ package org.glassfish.concurrent.runtime.deployer.cfg; import com.sun.enterprise.deployment.annotation.handlers.ContextServiceDefinitionData; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; import java.io.Serializable; import java.util.HashSet; @@ -24,9 +25,6 @@ import org.glassfish.concurrent.config.ContextService; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.standardize; -import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseContextInfo; - /** * @author David Matejcek @@ -35,20 +33,20 @@ public class ContextServiceCfg implements Serializable { private static final long serialVersionUID = -2284599070400343119L; private final ConcurrentServiceCfg serviceConfig; - private final Set propagatedContexts; - private final Set clearedContexts; - private final Set unchangedContexts; + private final Set propagatedContexts; + private final Set clearedContexts; + private final Set unchangedContexts; public ContextServiceCfg(ContextServiceDefinitionData data) { this.serviceConfig = new ConcurrentServiceCfg(data.getName()); - this.propagatedContexts = standardize(data.getPropagated()); - this.clearedContexts = standardize(data.getCleared()); - this.unchangedContexts = standardize(data.getUnchanged()); + this.propagatedContexts = CfgParser.standardize(data.getPropagated()); + this.clearedContexts = CfgParser.standardize(data.getCleared()); + this.unchangedContexts = CfgParser.standardize(data.getUnchanged()); } public ContextServiceCfg(ContextService data) { - this.propagatedContexts = parseContextInfo(data.getContextInfo(), data.getContextInfoEnabled()); + this.propagatedContexts = CfgParser.parseContextInfo(data.getContextInfo(), data.getContextInfoEnabled()); this.serviceConfig = new ConcurrentServiceCfg(data.getJndiName(), propagatedContexts); this.clearedContexts = new HashSet<>(); this.unchangedContexts = new HashSet<>(); @@ -60,17 +58,17 @@ public ConcurrentServiceCfg getServiceConfig() { } - public Set getPropagatedContexts() { + public Set getPropagatedContexts() { return propagatedContexts; } - public Set getClearedContexts() { + public Set getClearedContexts() { return clearedContexts; } - public Set getUnchangedContexts() { + public Set getUnchangedContexts() { return unchangedContexts; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedExecutorServiceCfg.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedExecutorServiceCfg.java index 96c9d7de169..48f28ce99d1 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedExecutorServiceCfg.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedExecutorServiceCfg.java @@ -17,6 +17,8 @@ package org.glassfish.concurrent.runtime.deployer.cfg; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; + import java.io.Serializable; import java.util.Set; @@ -47,7 +49,7 @@ public class ManagedExecutorServiceCfg implements Serializable { private final long threadLifeTimeSeconds; public ManagedExecutorServiceCfg(ManagedExecutorService config) { - Set propagated = parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); + Set propagated = parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); serviceConfig = new ConcurrentServiceCfg(config.getJndiName(), propagated, config.getContext()); hungAfterSeconds = parseInt(config.getHungAfterSeconds(), 0); hungLoggerPrintOnce = Boolean.valueOf(config.getHungLoggerPrintOnce()); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedScheduledExecutorServiceCfg.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedScheduledExecutorServiceCfg.java index 08b361dd218..7c7c01cbbcc 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedScheduledExecutorServiceCfg.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedScheduledExecutorServiceCfg.java @@ -17,11 +17,14 @@ package org.glassfish.concurrent.runtime.deployer.cfg; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; + import java.io.Serializable; import java.util.Set; import org.glassfish.concurrent.config.ManagedScheduledExecutorService; +import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseContextInfo; import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseInt; import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseLong; @@ -44,7 +47,7 @@ public class ManagedScheduledExecutorServiceCfg implements Serializable { private final long threadLifeTimeSeconds; public ManagedScheduledExecutorServiceCfg(ManagedScheduledExecutorService config) { - Set propagated = CfgParser.parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); + Set propagated = parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); serviceConfig = new ConcurrentServiceCfg(config.getJndiName(), propagated, config.getContext()); hungAfterSeconds = parseInt(config.getHungAfterSeconds(), 0); hungLoggerPrintOnce = Boolean.valueOf(config.getHungLoggerPrintOnce()); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedThreadFactoryCfg.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedThreadFactoryCfg.java index 335f93564e7..c89a1855021 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedThreadFactoryCfg.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/cfg/ManagedThreadFactoryCfg.java @@ -16,10 +16,14 @@ package org.glassfish.concurrent.runtime.deployer.cfg; +import com.sun.enterprise.deployment.types.ConcurrencyContextType; + import java.io.Serializable; import java.util.Set; import org.glassfish.concurrent.config.ManagedThreadFactory; + +import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseContextInfo; import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseInt; /** @@ -33,7 +37,7 @@ public class ManagedThreadFactoryCfg implements Serializable { private final int threadPriority; public ManagedThreadFactoryCfg(ManagedThreadFactory config) { - Set propagated = CfgParser.parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); + Set propagated = parseContextInfo(config.getContextInfo(), config.getContextInfoEnabled()); serviceConfig = new ConcurrentServiceCfg(config.getJndiName(), propagated, config.getContext()); threadPriority = parseInt(config.getThreadPriority(), Thread.NORM_PRIORITY); } diff --git a/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/ConcurrentRuntimeTest.java b/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/ConcurrentRuntimeTest.java index 010319dbc4e..43327a83010 100644 --- a/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/ConcurrentRuntimeTest.java +++ b/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/ConcurrentRuntimeTest.java @@ -32,11 +32,11 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Classloader; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.JNDI; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Remaining; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.Security; -import static com.sun.enterprise.deployment.annotation.handlers.StandardContextType.WorkArea; +import static com.sun.enterprise.deployment.types.StandardContextType.Classloader; +import static com.sun.enterprise.deployment.types.StandardContextType.JNDI; +import static com.sun.enterprise.deployment.types.StandardContextType.Remaining; +import static com.sun.enterprise.deployment.types.StandardContextType.Security; +import static com.sun.enterprise.deployment.types.StandardContextType.WorkArea; import static org.easymock.EasyMock.createMock; import static org.easymock.EasyMock.expect; import static org.easymock.EasyMock.replay; diff --git a/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParserTest.java b/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParserTest.java index 37d8bd324e5..4a5f0ec3854 100644 --- a/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParserTest.java +++ b/appserver/concurrent/concurrent-impl/src/test/java/org/glassfish/concurrent/runtime/deployer/cfg/CfgParserTest.java @@ -16,12 +16,16 @@ package org.glassfish.concurrent.runtime.deployer.cfg; +import com.sun.enterprise.deployment.types.CustomContextType; +import com.sun.enterprise.deployment.types.StandardContextType; + import org.junit.jupiter.api.Test; import static org.glassfish.concurrent.runtime.deployer.cfg.CfgParser.parseContextInfo; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsInAnyOrder; import static org.junit.jupiter.api.Assertions.assertAll; +import static com.sun.enterprise.deployment.types.StandardContextType.*; /** * @author David Matejcek @@ -32,17 +36,16 @@ public class CfgParserTest { public void testParseContextInfo() { assertAll( () -> assertThat(parseContextInfo(null, "true"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea", "Remaining")), + containsInAnyOrder(StandardContextType.values())), () -> assertThat(parseContextInfo("Classloader, JNDI, Security, WorkArea", "true"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea")), + containsInAnyOrder(Classloader, JNDI, Security, WorkArea)), () -> assertThat(parseContextInfo("classloader, jndi, security, workarea", "true"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea")), + containsInAnyOrder(Classloader, JNDI, Security, WorkArea)), () -> assertThat(parseContextInfo("CLASSLOADER, JNDI, SECURITY, WORKAREA", "true"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea")), + containsInAnyOrder(Classloader, JNDI, Security, WorkArea)), () -> assertThat(parseContextInfo("JNDI", "false"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea", "Remaining")), + containsInAnyOrder(StandardContextType.values())), () -> assertThat(parseContextInfo("Classloader, JNDI, JNDI, blah, BEH, Security, WorkArea, ", "true"), - containsInAnyOrder("Classloader", "JNDI", "Security", "WorkArea", "blah", "BEH")) - ); + containsInAnyOrder(Classloader, JNDI, Security, WorkArea, new CustomContextType("blah"), new CustomContextType("BEH"))) ); } } diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/ConcurrencyContextType.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/ConcurrencyContextType.java new file mode 100644 index 00000000000..209d88a5013 --- /dev/null +++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/ConcurrencyContextType.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2022 Eclipse Foundation and/or its affiliates. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ + +package com.sun.enterprise.deployment.types; + +import jakarta.enterprise.concurrent.spi.ThreadContextProvider; + +import java.io.Serializable; + +/** + * Context type can be standard or provided by some custom {@link ThreadContextProvider}. + * + * @author David Matejcek + */ +public interface ConcurrencyContextType extends Serializable { + + /** + * @return name of the context type supported by GlassFish or by the application's + * {@link ThreadContextProvider}. + */ + String name(); +} diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/CustomContextType.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/CustomContextType.java new file mode 100644 index 00000000000..06f39f0bdda --- /dev/null +++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/CustomContextType.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2022 Eclipse Foundation and/or its affiliates. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ + +package com.sun.enterprise.deployment.types; + +import jakarta.enterprise.concurrent.spi.ThreadContextProvider; + +import java.util.Objects; + +/** + * Context type provided by some custom {@link ThreadContextProvider}. + * + * @author David Matejcek + */ +public class CustomContextType implements ConcurrencyContextType { + + private static final long serialVersionUID = -311864575749450609L; + private final String name; + + /** + * @param name must not be null. + */ + public CustomContextType(String name) { + this.name = Objects.requireNonNull(name, "name"); + } + + + @Override + public String name() { + return this.name; + } + + + @Override + public int hashCode() { + return name.hashCode(); + } + + + @Override + public boolean equals(Object other) { + return other instanceof CustomContextType && ((CustomContextType) other).name.equals(name); + } + + + @Override + public String toString() { + return name; + } +} diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/StandardContextType.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/StandardContextType.java similarity index 72% rename from appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/StandardContextType.java rename to appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/StandardContextType.java index 3faa4561ddc..9997a0d3821 100644 --- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/annotation/handlers/StandardContextType.java +++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/types/StandardContextType.java @@ -14,19 +14,21 @@ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 */ -package com.sun.enterprise.deployment.annotation.handlers; +package com.sun.enterprise.deployment.types; import jakarta.enterprise.concurrent.ContextServiceDefinition; import java.util.Arrays; -import java.util.HashSet; import java.util.Set; import java.util.stream.Collectors; /** + * Enum for supported standard context types. + * * @author David Matejcek + * @see ContextServiceDefinition */ -public enum StandardContextType { +public enum StandardContextType implements ConcurrencyContextType { /** Same as {@link ContextServiceDefinition#ALL_REMAINING}*/ Remaining, /** Subtype of {@link ContextServiceDefinition#APPLICATION} */ @@ -39,11 +41,22 @@ public enum StandardContextType { WorkArea, ; + /** + * @return all enum names. + */ public static Set names() { return Arrays.stream(StandardContextType.values()).map(Enum::name).collect(Collectors.toSet()); } + /** + * Case insensitive parsing of enum names.
+ * Accepts also obsoleted NAMING and CLASSLOADING values as they can be simply converted + * to known types. + * + * @param name + * @return parsed {@link StandardContextType} or null. + */ public static StandardContextType parse(String name) { for (StandardContextType ctxType : StandardContextType.values()) { if (ctxType.name().equalsIgnoreCase(name)) { @@ -59,21 +72,4 @@ public static StandardContextType parse(String name) { } return null; } - - - public static Set standardize(Set contexts) { - Set result = new HashSet<>(); - for (String input : contexts) { - if (ContextServiceDefinition.TRANSACTION.equalsIgnoreCase(input)) { - result.add(WorkArea.name()); - } - if (ContextServiceDefinition.APPLICATION.equals(input)) { - result.add(Classloader.name()); - result.add(JNDI.name()); - } - StandardContextType contextType = parse(input); - result.add(contextType == null ? input : contextType.name()); - } - return result; - } }