Add the ability to track loggers to the ContextConfiguration. Rename …

…some components and make some minor changes.

Signed-off-by: James R. Perkins <[email protected]>

src/main/java/org/jboss/logmanager/configuration/ConfigurationResource.java

@@ -0,0 +1,65 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ *
+ * Copyright 2022 Red Hat, Inc., and individual contributors
+ * as indicated by the @author tags.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jboss.logmanager.configuration;
+
+import java.util.function.Supplier;
+
+/**
+ * A configuration resource
+ *
+ * @author <a href="mailto:[email protected]">James R. Perkins</a>
+ */
+class ConfigurationResource<T> implements Supplier<T>, AutoCloseable {
+    private final Supplier<T> supplier;
+    private volatile T instance;
+
+    private ConfigurationResource(final Supplier<T> supplier) {
+        this.supplier = supplier;
+    }
+
+    static <T> ConfigurationResource<T> of(final Supplier<T> supplier) {
+        if (supplier instanceof ConfigurationResource) {
+            return (ConfigurationResource<T>) supplier;
+        }
+        return new ConfigurationResource<>(supplier);
+    }
+
+    @Override
+    public T get() {
+        if (instance == null) {
+            synchronized (this) {
+                if (instance == null) {
+                    instance = supplier.get();
+                }
+            }
+        }
+        return instance;
+    }
+
+    @Override
+    public void close() throws Exception {
+        synchronized (this) {
+            if (instance instanceof AutoCloseable) {
+                ((AutoCloseable) instance).close();
+            }
+            instance = null;
+        }
+    }
+}

src/main/java/org/jboss/logmanager/configuration/ContextConfiguration.java

@@ -19,16 +19,19 @@
 
 package org.jboss.logmanager.configuration;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
 import java.util.logging.ErrorManager;
 import java.util.logging.Filter;
 import java.util.logging.Formatter;
 import java.util.logging.Handler;
 
+import org.jboss.logmanager.LogContext;
 import org.jboss.logmanager.Logger;
 
 /**
@@ -47,25 +50,67 @@
  * @author <a href="mailto:[email protected]">James R. Perkins</a>
  */
 @SuppressWarnings({ "UnusedReturnValue", "unused" })
-public class ContextConfiguration {
+public class ContextConfiguration implements AutoCloseable {
     public static final Logger.AttachmentKey<ContextConfiguration> CONTEXT_CONFIGURATION_KEY = new Logger.AttachmentKey<>();
-    private final Map<String, Supplier<ErrorManager>> errorManagers;
-    private final Map<String, Supplier<Filter>> filters;
-    private final Map<String, Supplier<Formatter>> formatters;
-    private final Map<String, Supplier<Handler>> handlers;
-    private final Map<String, Supplier<Object>> objects;
+    private final LogContext context;
+    private final Map<String, ConfigurationResource<ErrorManager>> errorManagers;
+    private final Map<String, ConfigurationResource<Filter>> filters;
+    private final Map<String, ConfigurationResource<Formatter>> formatters;
+    private final Map<String, ConfigurationResource<Handler>> handlers;
+    private final Map<String, ConfigurationResource<Object>> objects;
 
     /**
      * Creates a new context configuration.
      */
-    public ContextConfiguration() {
+    public ContextConfiguration(final LogContext context) {
+        this.context = context;
         errorManagers = new ConcurrentHashMap<>();
         handlers = new ConcurrentHashMap<>();
         formatters = new ConcurrentHashMap<>();
         filters = new ConcurrentHashMap<>();
         objects = new ConcurrentHashMap<>();
     }
 
+    /**
+     * Returns the {@linkplain LogContext context} for this configuration.
+     *
+     * @return the context for this configuration
+     */
+    public LogContext getContext() {
+        return context;
+    }
+
+    /**
+     * Checks if the logger exists in this context.
+     *
+     * @param name the logger name
+     *
+     * @return {@code true} if the logger exists in this context, otherwise {@code false}
+     */
+    public boolean hasLogger(final String name) {
+        return getContext().getLoggerIfExists(Objects.requireNonNull(name, "The name cannot be null")) != null;
+    }
+
+    /**
+     * Gets the logger if it exists.
+     *
+     * @param name the name of the logger
+     *
+     * @return the logger or {@code null} if the logger does not exist
+     */
+    public Logger getLogger(final String name) {
+        return getContext().getLogger(Objects.requireNonNull(name, "The name cannot be null"));
+    }
+
+    /**
+     * Returns an unmodifiable set of the configured logger names
+     *
+     * @return an unmodified set of the logger names
+     */
+    public Set<String> getLoggers() {
+        return Set.copyOf(Collections.list(getContext().getLoggerNames()));
+    }
+
     /**
      * Adds an error manager to the context configuration.
      *
@@ -79,7 +124,7 @@ public Supplier<ErrorManager> addErrorManager(final String name, final Supplier<
             return removeErrorManager(name);
         }
         return errorManagers.putIfAbsent(Objects.requireNonNull(name, "The name cannot be null"),
-                SingletonSupplier.of(errorManager));
+                ConfigurationResource.of(errorManager));
     }
 
     /**
@@ -140,7 +185,7 @@ public Supplier<Handler> addHandler(final String name, final Supplier<Handler> h
             return removeHandler(name);
         }
         return handlers.putIfAbsent(Objects.requireNonNull(name, "The name cannot be null"),
-                SingletonSupplier.of(handler));
+                ConfigurationResource.of(handler));
     }
 
     /**
@@ -201,7 +246,7 @@ public Supplier<Formatter> addFormatter(final String name, final Supplier<Format
             return removeFormatter(name);
         }
         return formatters.putIfAbsent(Objects.requireNonNull(name, "The name cannot be null"),
-                SingletonSupplier.of(formatter));
+                ConfigurationResource.of(formatter));
     }
 
     /**
@@ -262,7 +307,7 @@ public Supplier<Filter> addFilter(final String name, final Supplier<Filter> filt
             return removeFilter(name);
         }
         return filters.putIfAbsent(Objects.requireNonNull(name, "The name cannot be null"),
-                SingletonSupplier.of(filter));
+                ConfigurationResource.of(filter));
     }
 
     /**
@@ -324,7 +369,7 @@ public Supplier<Object> addObject(final String name, final Supplier<Object> obje
             return removeObject(name);
         }
         return objects.putIfAbsent(Objects.requireNonNull(name, "The name cannot be null"),
-                SingletonSupplier.of(object));
+                ConfigurationResource.of(object));
     }
 
     /**
@@ -372,28 +417,30 @@ public Map<String, Supplier<Object>> getObjects() {
         return Collections.unmodifiableMap(objects);
     }
 
-    private static class SingletonSupplier<T> implements Supplier<T> {
-        private final Supplier<T> supplier;
-        private volatile T instance;
-
-        private SingletonSupplier(final Supplier<T> supplier) {
-            this.supplier = supplier;
-        }
-
-        static <T> Supplier<T> of(final Supplier<T> supplier) {
-            return new SingletonSupplier<>(supplier);
-        }
+    @Override
+    public void close() throws Exception {
+        context.close();
+        // TODO (jrp) these are not really thread safe
+        closeResources(handlers.values());
+        handlers.clear();
+        closeResources(filters.values());
+        filters.clear();
+        closeResources(formatters.values());
+        formatters.clear();
+        closeResources(errorManagers.values());
+        errorManagers.clear();
+        closeResources(objects.values());
+        objects.clear();
+    }
 
-        @Override
-        public T get() {
-            if (instance == null) {
-                synchronized (this) {
-                    if (instance == null) {
-                        instance = supplier.get();
-                    }
-                }
+    private static void closeResources(final Collection<? extends AutoCloseable> closeables) {
+        for (var closeable : closeables) {
+            try {
+                closeable.close();
+            } catch (Throwable ignore) {
+                // do nothing
             }
-            return instance;
         }
     }
+
 }

src/main/java/org/jboss/logmanager/configuration/DefaultConfiguratorFactory.java

@@ -33,7 +33,7 @@ public class DefaultConfiguratorFactory implements ConfiguratorFactory {
 
     @Override
     public LogContextConfigurator create() {
-        return new DefaultLogContextConfigurator();
+        return new PropertyLogContextConfigurator();
     }
 
     @Override

src/main/java/org/jboss/logmanager/configuration/ObjectBuilder.java

@@ -33,7 +33,6 @@
 import java.util.logging.Level;
 import java.util.regex.Pattern;
 
-import org.jboss.logmanager.LogContext;
 import org.jboss.modules.Module;
 import org.jboss.modules.ModuleLoader;
 
@@ -44,8 +43,6 @@
  */
 @SuppressWarnings({ "UnusedReturnValue" })
 class ObjectBuilder<T> {
-
-    private final LogContext logContext;
     private final ContextConfiguration contextConfiguration;
     private final Class<? extends T> baseClass;
     private final String className;
@@ -55,9 +52,8 @@ class ObjectBuilder<T> {
     private final Set<String> postConstructMethods;
     private String moduleName;
 
-    private ObjectBuilder(final LogContext logContext, final ContextConfiguration contextConfiguration,
+    private ObjectBuilder(final ContextConfiguration contextConfiguration,
             final Class<? extends T> baseClass, final String className) {
-        this.logContext = logContext;
         this.contextConfiguration = contextConfiguration;
         this.baseClass = baseClass;
         this.className = className;
@@ -70,16 +66,15 @@ private ObjectBuilder(final LogContext logContext, final ContextConfiguration co
     /**
      * Create a new {@link ObjectBuilder}.
      *
-     * @param logContext the log context being configured
-     * @param baseClass  the base type
-     * @param className  the name of the class to create
-     * @param <T>        the type being created
+     * @param baseClass the base type
+     * @param className the name of the class to create
+     * @param <T>       the type being created
      *
      * @return a new {@link ObjectBuilder}
      */
-    static <T> ObjectBuilder<T> of(final LogContext logContext, final ContextConfiguration contextConfiguration,
+    static <T> ObjectBuilder<T> of(final ContextConfiguration contextConfiguration,
             final Class<? extends T> baseClass, final String className) {
-        return new ObjectBuilder<>(logContext, contextConfiguration, baseClass, className);
+        return new ObjectBuilder<>(contextConfiguration, baseClass, className);
     }
 
     /**
@@ -272,39 +267,40 @@ private Object getValue(final Class<?> objClass, final String propertyName, fina
             }
             return null;
         }
+        final var trimmedValue = value.trim();
         if (paramType == String.class) {
             // Don't use the trimmed value for strings
             return value;
         } else if (paramType == java.util.logging.Level.class) {
-            return logContext.getLevelForName(value);
+            return contextConfiguration.getContext().getLevelForName(trimmedValue);
         } else if (paramType == java.util.logging.Logger.class) {
-            return logContext.getLogger(value);
+            return contextConfiguration.getContext().getLogger(trimmedValue);
         } else if (paramType == boolean.class || paramType == Boolean.class) {
-            return Boolean.valueOf(value);
+            return Boolean.valueOf(trimmedValue);
         } else if (paramType == byte.class || paramType == Byte.class) {
-            return Byte.valueOf(value);
+            return Byte.valueOf(trimmedValue);
         } else if (paramType == short.class || paramType == Short.class) {
-            return Short.valueOf(value);
+            return Short.valueOf(trimmedValue);
         } else if (paramType == int.class || paramType == Integer.class) {
-            return Integer.valueOf(value);
+            return Integer.valueOf(trimmedValue);
         } else if (paramType == long.class || paramType == Long.class) {
-            return Long.valueOf(value);
+            return Long.valueOf(trimmedValue);
         } else if (paramType == float.class || paramType == Float.class) {
-            return Float.valueOf(value);
+            return Float.valueOf(trimmedValue);
         } else if (paramType == double.class || paramType == Double.class) {
-            return Double.valueOf(value);
+            return Double.valueOf(trimmedValue);
         } else if (paramType == char.class || paramType == Character.class) {
-            return value.length() > 0 ? value.charAt(0) : 0;
+            return trimmedValue.length() > 0 ? trimmedValue.charAt(0) : 0;
         } else if (paramType == TimeZone.class) {
-            return TimeZone.getTimeZone(value);
+            return TimeZone.getTimeZone(trimmedValue);
         } else if (paramType == Charset.class) {
-            return Charset.forName(value);
+            return Charset.forName(trimmedValue);
         } else if (paramType.isAssignableFrom(Level.class)) {
-            return Level.parse(value);
+            return Level.parse(trimmedValue);
         } else if (paramType.isEnum()) {
-            return Enum.valueOf(paramType.asSubclass(Enum.class), value);
-        } else if (contextConfiguration.hasObject(value)) {
-            return contextConfiguration.getObject(value);
+            return Enum.valueOf(paramType.asSubclass(Enum.class), trimmedValue);
+        } else if (contextConfiguration.hasObject(trimmedValue)) {
+            return contextConfiguration.getObject(trimmedValue);
         } else if (definedPropertiesContains(propertyName)) {
             final PropertyValue propertyValue = findDefinedProperty(propertyName);
             if (propertyValue == null) {