/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions Copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2008-2009 Sun Microsystems, Inc.
|
* Portions copyright 2012-2016 ForgeRock AS.
|
*/
|
package org.forgerock.opendj.config;
|
|
import static com.forgerock.opendj.ldap.config.ConfigMessages.*;
|
import static com.forgerock.opendj.util.StaticUtils.*;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileFilter;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.lang.reflect.Method;
|
import java.net.MalformedURLException;
|
import java.net.URL;
|
import java.net.URLClassLoader;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.HashSet;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.jar.Attributes;
|
import java.util.jar.JarEntry;
|
import java.util.jar.JarFile;
|
import java.util.jar.Manifest;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.i18n.slf4j.LocalizedLogger;
|
import org.forgerock.opendj.config.server.ConfigException;
|
import org.forgerock.opendj.server.config.meta.RootCfgDefn;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import com.forgerock.opendj.ldap.config.ConfigMessages;
|
|
/**
|
* This class is responsible for managing the configuration framework including:
|
* <ul>
|
* <li>loading core components during application initialization
|
* <li>loading extensions during and after application initialization
|
* <li>changing the property validation strategy based on whether the application is a client or server.
|
* </ul>
|
* This class defines a class loader which will be used for loading components.
|
* For extensions which define their own extended configuration definitions, the class loader
|
* will make sure that the configuration definition classes are loaded and initialized.
|
* <p>
|
* Initially the configuration framework is disabled, and calls to the {@link #getClassLoader()}
|
* will return the system default class loader.
|
* <p>
|
* Applications <b>MUST NOT</b> maintain persistent references to the class loader as it can change at run-time.
|
*/
|
public final class ConfigurationFramework {
|
/**
|
* Private URLClassLoader implementation. This is only required so that we can provide access to the addURL method.
|
*/
|
private static final class MyURLClassLoader extends URLClassLoader {
|
|
/** Create a class loader with the default parent class loader. */
|
public MyURLClassLoader() {
|
super(new URL[0]);
|
}
|
|
/**
|
* Create a class loader with the provided parent class loader.
|
*
|
* @param parent
|
* The parent class loader.
|
*/
|
public MyURLClassLoader(final ClassLoader parent) {
|
super(new URL[0], parent);
|
}
|
|
/**
|
* Add a Jar file to this class loader.
|
*
|
* @param jarFile
|
* The name of the Jar file.
|
* @throws MalformedURLException
|
* If a protocol handler for the URL could not be found, or
|
* if some other error occurred while constructing the URL.
|
* @throws SecurityException
|
* If a required system property value cannot be accessed.
|
*/
|
public void addJarFile(final File jarFile) throws MalformedURLException {
|
addURL(jarFile.toURI().toURL());
|
}
|
|
}
|
|
/** Relative path must be used to retrieve the manifest as a jar entry from the jars. */
|
private static final String MANIFEST_RELATIVE_PATH =
|
"META-INF/services/org.forgerock.opendj.config.AbstractManagedObjectDefinition";
|
|
/** Absolute path must be used to retrieve the manifest as a resource stream. */
|
private static final String MANIFEST_ABSOLUTE_PATH = "/" + MANIFEST_RELATIVE_PATH;
|
|
private static final LocalizedLogger adminLogger = LocalizedLogger
|
.getLocalizedLogger(ConfigMessages.resourceName());
|
private static final Logger debugLogger = LoggerFactory.getLogger(ConfigurationFramework.class);
|
|
/** The name of the lib directory. */
|
private static final String LIB_DIR = "lib";
|
|
/** The name of the extensions directory. */
|
private static final String EXTENSIONS_DIR = "extensions";
|
|
/** The singleton instance. */
|
private static final ConfigurationFramework INSTANCE = new ConfigurationFramework();
|
|
/** Attribute name in jar's MANIFEST corresponding to the revision number. */
|
private static final String REVISION_NUMBER = "Revision-Number";
|
|
/** The attribute names for build information is name, version and revision number. */
|
private static final String[] BUILD_INFORMATION_ATTRIBUTE_NAMES = new String[] {
|
Attributes.Name.EXTENSION_NAME.toString(),
|
Attributes.Name.IMPLEMENTATION_VERSION.toString(), REVISION_NUMBER };
|
|
/**
|
* Returns the single application wide configuration framework instance.
|
*
|
* @return The single application wide configuration framework instance.
|
*/
|
public static ConfigurationFramework getInstance() {
|
return INSTANCE;
|
}
|
|
/**
|
* Returns a string representing all information about extensions.
|
*
|
* @param installPath
|
* The path where application binaries are located.
|
* @param instancePath
|
* The path where application data are located.
|
*
|
* @return A string representing all information about extensions;
|
* <code>null</code> if there is no information available.
|
*/
|
public static String getPrintableExtensionInformation(final String installPath, final String instancePath) {
|
final File extensionsPath = buildExtensionDir(installPath);
|
|
final List<File> extensions = new ArrayList<>();
|
|
if (extensionsPath.exists() && extensionsPath.isDirectory()) {
|
extensions.addAll(listFiles(extensionsPath));
|
}
|
|
File instanceExtensionsPath = buildExtensionDir(instancePath);
|
if (!extensionsPath.getAbsolutePath().equals(instanceExtensionsPath.getAbsolutePath())) {
|
extensions.addAll(listFiles(instanceExtensionsPath));
|
}
|
|
if (extensions.isEmpty()) {
|
return null;
|
}
|
|
final StringBuilder sb = new StringBuilder();
|
printExtensionDetailsHeader(sb);
|
|
for (final File extension : extensions) {
|
printExtensionDetails(sb, extension);
|
}
|
|
return sb.toString();
|
}
|
|
private static void printExtensionDetailsHeader(final StringBuilder sb) {
|
// Leave space at start of the line for "Extension:"
|
sb.append("--")
|
.append(EOL)
|
.append(" Name Build number Revision number")
|
.append(EOL);
|
}
|
|
private static File buildExtensionDir(String directory) {
|
final File libDir = new File(directory, LIB_DIR);
|
final File extensionDir = new File(libDir, EXTENSIONS_DIR);
|
try {
|
return extensionDir.getCanonicalFile();
|
} catch (Exception e) {
|
return extensionDir;
|
}
|
}
|
|
private static List<File> listFiles(File path) {
|
if (path.exists() && path.isDirectory()) {
|
return Arrays.asList(path.listFiles(new FileFilter() {
|
@Override
|
public boolean accept(File pathname) {
|
// only files with names ending with ".jar"
|
return pathname.isFile() && pathname.getName().endsWith(".jar");
|
}
|
}));
|
}
|
return Collections.emptyList();
|
}
|
|
private static void printExtensionDetails(final StringBuilder sb, final File extension) {
|
// retrieve MANIFEST entry and display name, build number and revision number
|
try (JarFile jarFile = new JarFile(extension)) {
|
JarEntry entry = jarFile.getJarEntry(MANIFEST_RELATIVE_PATH);
|
if (entry == null) {
|
return;
|
}
|
|
String[] information = getBuildInformation(jarFile);
|
sb.append("Extension:");
|
for (final String name : information) {
|
sb.append(" ").append(String.format("%-20s", name));
|
}
|
sb.append(EOL);
|
} catch (final IOException ignored) {
|
// ignore extra information for this extension
|
}
|
}
|
|
/**
|
* Returns a String array with the following information : <br>
|
* index 0: the name of the extension. <br>
|
* index 1: the build number of the extension. <br>
|
* index 2: the revision number of the extension.
|
*
|
* @param extension
|
* the jar file of the extension
|
* @return a String array containing the name, the build number and the revision number
|
* of the extension given in argument
|
* @throws java.io.IOException
|
* thrown if the jar file has been closed.
|
*/
|
private static String[] getBuildInformation(final JarFile extension) throws IOException {
|
final String[] result = new String[3];
|
|
final Manifest manifest = extension.getManifest();
|
if (manifest != null) {
|
final Attributes attributes = manifest.getMainAttributes();
|
|
int index = 0;
|
for (final String name : BUILD_INFORMATION_ATTRIBUTE_NAMES) {
|
String value = attributes.getValue(name);
|
if (value == null) {
|
value = "<unknown>";
|
}
|
result[index++] = value;
|
}
|
}
|
|
return result;
|
}
|
|
/** Set of registered Jar files. */
|
private Set<File> jarFiles = new HashSet<>();
|
|
/**
|
* Underlying class loader used to load classes and resources (null if disabled).
|
* <p>
|
* We contain a reference to the URLClassLoader rather than
|
* sub-class it so that it is possible to replace the loader at
|
* run-time. For example, when removing or replacing extension Jar
|
* files (the URLClassLoader only supports adding new URLs, not removal).
|
*/
|
private MyURLClassLoader loader;
|
|
private boolean isClient = true;
|
private String installPath;
|
private String instancePath;
|
private ClassLoader parent;
|
|
/** Private constructor. */
|
private ConfigurationFramework() {
|
// No implementation required.
|
}
|
|
/**
|
* Returns the class loader which should be used for loading classes and resources. When this configuration
|
* framework is disabled, the system default class loader will be returned by default.
|
* <p>
|
* Applications <b>MUST NOT</b> maintain persistent references to the class loader as it can change at run-time.
|
*
|
* @return Returns the class loader which should be used for loading classes and resources.
|
*/
|
public synchronized ClassLoader getClassLoader() {
|
if (loader != null) {
|
return loader;
|
} else {
|
return ClassLoader.getSystemClassLoader();
|
}
|
}
|
|
/**
|
* Initializes the configuration framework using the application's class loader as the parent class loader,
|
* and the current working directory as the install and instance path.
|
*
|
* @return The configuration framework.
|
* @throws ConfigException
|
* If the configuration framework could not initialize successfully.
|
* @throws IllegalStateException
|
* If the configuration framework has already been initialized.
|
*/
|
public ConfigurationFramework initialize() throws ConfigException {
|
return initialize(null);
|
}
|
|
/**
|
* Initializes the configuration framework using the application's class loader
|
* as the parent class loader, and the provided install/instance path.
|
*
|
* @param installAndInstancePath
|
* The path where application binaries and data are located.
|
* @return The configuration framework.
|
* @throws ConfigException
|
* If the configuration framework could not initialize successfully.
|
* @throws IllegalStateException
|
* If the configuration framework has already been initialized.
|
*/
|
public ConfigurationFramework initialize(final String installAndInstancePath)
|
throws ConfigException {
|
return initialize(installAndInstancePath, installAndInstancePath);
|
}
|
|
/**
|
* Initializes the configuration framework using the application's class loader
|
* as the parent class loader, and the provided install and instance paths.
|
*
|
* @param installPath
|
* The path where application binaries are located.
|
* @param instancePath
|
* The path where application data are located.
|
* @return The configuration framework.
|
* @throws ConfigException
|
* If the configuration framework could not initialize successfully.
|
* @throws IllegalStateException
|
* If the configuration framework has already been initialized.
|
*/
|
public ConfigurationFramework initialize(final String installPath, final String instancePath)
|
throws ConfigException {
|
return initialize(installPath, instancePath, RootCfgDefn.class.getClassLoader());
|
}
|
|
/**
|
* Initializes the configuration framework using the provided parent class
|
* loader and install and instance paths.
|
*
|
* @param installPath
|
* The path where application binaries are located.
|
* @param instancePath
|
* The path where application data are located.
|
* @param parent
|
* The parent class loader.
|
* @return The configuration framework.
|
* @throws ConfigException
|
* If the configuration framework could not initialize successfully.
|
* @throws IllegalStateException
|
* If the configuration framework has already been initialized.
|
*/
|
public synchronized ConfigurationFramework initialize(final String installPath,
|
final String instancePath, final ClassLoader parent) throws ConfigException {
|
if (loader != null) {
|
throw new IllegalStateException("configuration framework already initialized.");
|
}
|
this.installPath = installPath != null ? installPath : System.getenv("INSTALL_ROOT");
|
if (instancePath != null) {
|
this.instancePath = instancePath;
|
} else {
|
String instanceRoot = System.getenv("INSTANCE_ROOT");
|
this.instancePath = instanceRoot != null ? instanceRoot : this.installPath;
|
}
|
this.parent = parent;
|
initialize0();
|
return this;
|
}
|
|
/**
|
* Returns {@code true} if the configuration framework is being used within
|
* a client application. Client applications will perform less property
|
* value validation than server applications because they do not have
|
* resources available such as the server schema.
|
*
|
* @return {@code true} if the configuration framework is being used within a client application.
|
*/
|
public boolean isClient() {
|
return isClient;
|
}
|
|
/**
|
* Returns {@code true} if the configuration framework has been initialized.
|
*
|
* @return {@code true} if the configuration framework has been initialized.
|
*/
|
public synchronized boolean isInitialized() {
|
return loader != null;
|
}
|
|
/**
|
* Reloads the configuration framework.
|
*
|
* @throws ConfigException
|
* If the configuration framework could not initialize successfully.
|
* @throws IllegalStateException
|
* If the configuration framework has not yet been initialized.
|
*/
|
public synchronized void reload() throws ConfigException {
|
ensureInitialized();
|
loader = null;
|
jarFiles = new HashSet<>();
|
initialize0();
|
}
|
|
/**
|
* Specifies whether the configuration framework is being used within
|
* a client application. Client applications will perform less property
|
* value validation than server applications because they do not have
|
* resources available such as the server schema.
|
*
|
* @param isClient
|
* {@code true} if the configuration framework is being used within a client application.
|
* @return The configuration framework.
|
*/
|
public ConfigurationFramework setIsClient(final boolean isClient) {
|
this.isClient = isClient;
|
return this;
|
}
|
|
private void addExtension(final List<File> extensions) throws ConfigException {
|
// First add the Jar files to the class loader.
|
final List<JarFile> jars = new LinkedList<>();
|
for (final File extension : extensions) {
|
if (jarFiles.contains(extension)) {
|
// Skip this file as it is already loaded.
|
continue;
|
}
|
|
// Attempt to load it.
|
jars.add(loadJarFile(extension));
|
|
// Register the Jar file with the class loader.
|
try {
|
loader.addJarFile(extension);
|
} catch (final Exception e) {
|
debugLogger.trace("Unable to register the jar file with the class loader", e);
|
final LocalizableMessage message =
|
ERR_ADMIN_CANNOT_OPEN_JAR_FILE.get(extension.getName(), extension
|
.getParent(), stackTraceToSingleLineString(e, true));
|
throw new ConfigException(message);
|
}
|
jarFiles.add(extension);
|
}
|
|
// Now forcefully load the configuration definition classes.
|
for (final JarFile jar : jars) {
|
initializeExtension(jar);
|
}
|
}
|
|
private void ensureInitialized() {
|
if (loader == null) {
|
throw new IllegalStateException("configuration framework is disabled.");
|
}
|
}
|
|
private void initialize0() throws ConfigException {
|
if (parent != null) {
|
loader = new MyURLClassLoader(parent);
|
} else {
|
loader = new MyURLClassLoader();
|
}
|
|
// Forcefully load all configuration definition classes in OpenDS.jar.
|
initializeCoreComponents();
|
|
// Put extensions jars into the class loader and load all
|
// configuration definition classes in that they contain.
|
// First load the extension from the install directory, then
|
// from the instance directory.
|
File installExtensionsPath = buildExtensionDir(installPath);
|
File instanceExtensionsPath = buildExtensionDir(instancePath);
|
|
initializeAllExtensions(installExtensionsPath);
|
|
if (!installExtensionsPath.getAbsolutePath().equals(instanceExtensionsPath.getAbsolutePath())) {
|
initializeAllExtensions(instanceExtensionsPath);
|
}
|
}
|
|
/**
|
* Put extensions jars into the class loader and load all configuration
|
* definition classes in that they contain.
|
*
|
* @param extensionsPath
|
* Indicates where extensions are located.
|
* @throws ConfigException
|
* If the extensions folder could not be accessed or if a
|
* extension jar file could not be accessed or if one of the
|
* configuration definition classes could not be initialized.
|
*/
|
private void initializeAllExtensions(final File extensionsPath) throws ConfigException {
|
try {
|
if (!extensionsPath.exists()) {
|
// The extensions directory does not exist. This is not a critical problem.
|
adminLogger.warn(WARN_ADMIN_NO_EXTENSIONS_DIR, extensionsPath);
|
return;
|
}
|
|
if (!extensionsPath.isDirectory()) {
|
// The extensions directory is not a directory. This is more critical.
|
throw new ConfigException(ERR_ADMIN_EXTENSIONS_DIR_NOT_DIRECTORY.get(extensionsPath));
|
}
|
|
// Add and initialize the extensions.
|
addExtension(listFiles(extensionsPath));
|
} catch (final ConfigException e) {
|
debugLogger.trace("Unable to initialize all extensions", e);
|
throw e;
|
} catch (final Exception e) {
|
debugLogger.trace("Unable to initialize all extensions", e);
|
final LocalizableMessage message = ERR_ADMIN_EXTENSIONS_CANNOT_LIST_FILES.get(
|
extensionsPath, stackTraceToSingleLineString(e, true));
|
throw new ConfigException(message, e);
|
}
|
}
|
|
/**
|
* Make sure all core configuration definitions are loaded.
|
*
|
* @throws ConfigException
|
* If the core manifest file could not be read or if one of the
|
* configuration definition classes could not be initialized.
|
*/
|
private void initializeCoreComponents() throws ConfigException {
|
final InputStream is = RootCfgDefn.class.getResourceAsStream(MANIFEST_ABSOLUTE_PATH);
|
if (is == null) {
|
throw new ConfigException(ERR_ADMIN_CANNOT_FIND_CORE_MANIFEST.get(MANIFEST_ABSOLUTE_PATH));
|
}
|
try {
|
loadDefinitionClasses(is);
|
} catch (final ConfigException e) {
|
debugLogger.trace("Unable to initialize core components", e);
|
throw new ConfigException(ERR_CLASS_LOADER_CANNOT_LOAD_CORE.get(
|
MANIFEST_ABSOLUTE_PATH, stackTraceToSingleLineString(e, true)));
|
}
|
}
|
|
/**
|
* Make sure all the configuration definition classes in a extension are
|
* loaded.
|
*
|
* @param jarFile
|
* The extension's Jar file.
|
* @throws ConfigException
|
* If the extension jar file could not be accessed or if one of
|
* the configuration definition classes could not be
|
* initialized.
|
*/
|
private void initializeExtension(final JarFile jarFile) throws ConfigException {
|
final JarEntry entry = jarFile.getJarEntry(MANIFEST_RELATIVE_PATH);
|
if (entry != null) {
|
InputStream is;
|
try {
|
is = jarFile.getInputStream(entry);
|
} catch (final Exception e) {
|
debugLogger.trace("Unable to get input stream from jar", e);
|
final LocalizableMessage message =
|
ERR_ADMIN_CANNOT_READ_EXTENSION_MANIFEST.get(MANIFEST_RELATIVE_PATH, jarFile.getName(),
|
stackTraceToSingleLineString(e, true));
|
throw new ConfigException(message);
|
}
|
|
try {
|
loadDefinitionClasses(is);
|
} catch (final ConfigException e) {
|
debugLogger.trace("Unable to load classes from input stream", e);
|
final LocalizableMessage message = ERR_CLASS_LOADER_CANNOT_LOAD_EXTENSION.get(
|
jarFile.getName(), MANIFEST_RELATIVE_PATH, stackTraceToSingleLineString(e, true));
|
throw new ConfigException(message);
|
}
|
try {
|
// Log build information of extensions in the error log
|
final String[] information = getBuildInformation(jarFile);
|
final LocalizableMessage message = NOTE_LOG_EXTENSION_INFORMATION.get(
|
jarFile.getName(), information[1], information[2]);
|
LocalizedLogger.getLocalizedLogger(message.resourceName()).info(message);
|
} catch (final Exception e) {
|
// Do not log information for that extension
|
}
|
}
|
}
|
|
/**
|
* Forcefully load configuration definition classes named in a manifest file.
|
*
|
* @param is
|
* The manifest file input stream.
|
* @throws ConfigException
|
* If the definition classes could not be loaded and initialized.
|
*/
|
private void loadDefinitionClasses(final InputStream is) throws ConfigException {
|
// Cannot use ServiceLoader because constructors are private
|
final BufferedReader reader = new BufferedReader(new InputStreamReader(is));
|
final List<AbstractManagedObjectDefinition<?, ?>> definitions = new LinkedList<>();
|
while (true) {
|
String className;
|
try {
|
className = reader.readLine();
|
} catch (final IOException e) {
|
final LocalizableMessage msg =
|
ERR_CLASS_LOADER_CANNOT_READ_MANIFEST_FILE.get(e.getMessage());
|
throw new ConfigException(msg, e);
|
}
|
|
// Break out when the end of the manifest is reached.
|
if (className == null) {
|
break;
|
}
|
|
className = className.trim();
|
// Skip blank lines or lines beginning with #.
|
if (className.isEmpty() || className.startsWith("#")) {
|
continue;
|
}
|
|
debugLogger.trace("Loading class " + className);
|
|
// Load the class and get an instance of it if it is a definition.
|
Class<?> theClass;
|
try {
|
theClass = Class.forName(className, true, loader);
|
} catch (final Exception e) {
|
final LocalizableMessage msg =
|
ERR_CLASS_LOADER_CANNOT_LOAD_CLASS.get(className, e.getMessage());
|
throw new ConfigException(msg, e);
|
}
|
if (AbstractManagedObjectDefinition.class.isAssignableFrom(theClass)) {
|
// We need to instantiate it using its getInstance() static method.
|
Method method;
|
try {
|
method = theClass.getMethod("getInstance");
|
} catch (final Exception e) {
|
final LocalizableMessage msg =
|
ERR_CLASS_LOADER_CANNOT_FIND_GET_INSTANCE_METHOD.get(className, e.getMessage());
|
throw new ConfigException(msg, e);
|
}
|
|
// Get the definition instance.
|
AbstractManagedObjectDefinition<?, ?> d;
|
try {
|
d = (AbstractManagedObjectDefinition<?, ?>) method.invoke(null);
|
} catch (final Exception e) {
|
final LocalizableMessage msg =
|
ERR_CLASS_LOADER_CANNOT_INVOKE_GET_INSTANCE_METHOD.get(className, e.getMessage());
|
throw new ConfigException(msg, e);
|
}
|
definitions.add(d);
|
}
|
}
|
|
// Initialize any definitions that were loaded.
|
for (final AbstractManagedObjectDefinition<?, ?> d : definitions) {
|
try {
|
d.initialize();
|
} catch (final Exception e) {
|
final LocalizableMessage msg = ERR_CLASS_LOADER_CANNOT_INITIALIZE_DEFN.get(
|
d.getName(), d.getClass().getName(), e.getMessage());
|
throw new ConfigException(msg, e);
|
}
|
}
|
}
|
|
private JarFile loadJarFile(final File jar) throws ConfigException {
|
try {
|
// Load the extension jar file.
|
return new JarFile(jar);
|
} catch (final Exception e) {
|
debugLogger.trace("Unable to load jar file: " + jar, e);
|
|
final LocalizableMessage message =
|
ERR_ADMIN_CANNOT_OPEN_JAR_FILE.get(jar.getName(), jar.getParent(),
|
stackTraceToSingleLineString(e, true));
|
throw new ConfigException(message);
|
}
|
}
|
|
/**
|
* Returns the installation path.
|
*
|
* @return The installation path of this instance.
|
*/
|
public String getInstallPath() {
|
return installPath;
|
}
|
|
/**
|
* Returns the instance path.
|
*
|
* @return The instance path.
|
*/
|
public String getInstancePath() {
|
return instancePath;
|
}
|
}
|
