From 313c7ce226afaa79e811d6fa0f5ad8b8a59f0fd5 Mon Sep 17 00:00:00 2001
From: neil_a_wilson <neil_a_wilson@localhost>
Date: Mon, 13 Aug 2007 14:48:19 +0000
Subject: [PATCH] Provide a new org.opends.server.util.EmbeddedUtils class that can be used to simplify the process of running the server as an embedded application. There are methods to start, stop, and restart the server, as well as to determine whether the server is running. Also, provide a new org.opends.server.types.DirectoryEnvironmentConfig class that can be used to define a number of "environment" properties that provide information about the way in which the server should run.
---
opends/src/server/org/opends/server/core/DirectoryServer.java | 327 ++++++++++++++++++++++++++++++++++++++++++------------
1 files changed, 254 insertions(+), 73 deletions(-)
diff --git a/opends/src/server/org/opends/server/core/DirectoryServer.java b/opends/src/server/org/opends/server/core/DirectoryServer.java
index be769b3..918625c 100644
--- a/opends/src/server/org/opends/server/core/DirectoryServer.java
+++ b/opends/src/server/org/opends/server/core/DirectoryServer.java
@@ -262,6 +262,9 @@
// The configuration manager that will handle the certificate mapper.
private CertificateMapperConfigManager certificateMapperConfigManager;
+ // The class used to provide the config handler implementation.
+ private Class configClass;
+
// The configuration handler for the Directory Server.
private ConfigHandler configHandler;
@@ -398,6 +401,9 @@
// The crypto manager for the Directory Server.
private CryptoManager cryptoManager;
+ // The environment configuration for the Directory Server.
+ private DirectoryEnvironmentConfig environmentConfig;
+
// The shutdown hook that has been registered with the server.
private DirectoryServerShutdownHook shutdownHook;
@@ -420,6 +426,10 @@
// The configuration manager for extended operation handlers.
private ExtendedOperationConfigManager extendedOperationConfigManager;
+ // The path to the file containing the Directory Server configuration, or the
+ // information needed to bootstrap the configuration handler.
+ private File configFile;
+
// The group manager for the Directory Server.
private GroupManager groupManager;
@@ -535,13 +545,6 @@
// The set of allowed task classes.
private Set<String> allowedTasks;
- // The fully-qualified name of the configuration handler class.
- private String configClass;
-
- // The path to the file containing the Directory Server configuration, or the
- // information needed to bootstrap the configuration handler.
- private String configFile;
-
// The time that the server was started, formatted in UTC time.
private String startTimeUTC;
@@ -597,11 +600,28 @@
*/
private DirectoryServer()
{
- isBootstrapped = false;
- isRunning = false;
- shuttingDown = false;
- lockdownMode = false;
- serverErrorResultCode = ResultCode.OTHER;
+ this(new DirectoryEnvironmentConfig());
+ }
+
+
+
+ /**
+ * Creates a new instance of the Directory Server. This will allow only a
+ * single instance of the server per JVM.
+ *
+ * @param config The environment configuration to use for the Directory
+ * Server instance.
+ */
+ private DirectoryServer(DirectoryEnvironmentConfig config)
+ {
+ environmentConfig = config;
+ isBootstrapped = false;
+ isRunning = false;
+ shuttingDown = false;
+ lockdownMode = false;
+ serverErrorResultCode = ResultCode.OTHER;
+ startupDebugLogPublisher = null;
+ startupErrorLogPublisher = null;
operatingSystem = OperatingSystem.forName(System.getProperty("os.name"));
}
@@ -627,20 +647,72 @@
* reference to it. This should only be used in the context of an in-core
* restart after the existing server has been shut down.
*
+ * @param config The environment configuration for the Directory Server.
+ *
* @return The new instance of the Directory Server that is associated with
* this JVM.
*/
- private static DirectoryServer getNewInstance()
+ private static DirectoryServer
+ getNewInstance(DirectoryEnvironmentConfig config)
{
synchronized (directoryServer)
{
- return directoryServer = new DirectoryServer();
+ return directoryServer = new DirectoryServer(config);
}
}
/**
+ * Retrieves the environment configuration for the Directory Server.
+ *
+ * @return The environment configuration for the Directory Server.
+ */
+ public static DirectoryEnvironmentConfig getEnvironmentConfig()
+ {
+ return directoryServer.environmentConfig;
+ }
+
+
+
+ /**
+ * Sets the environment configuration for the Directory Server. This method
+ * may only be invoked when the server is not running.
+ *
+ * @param config The environment configuration for the Directory Server.
+ *
+ * @throws InitializationException If the Directory Server is currently
+ * running.
+ */
+ private void setEnvironmentConfig(DirectoryEnvironmentConfig config)
+ throws InitializationException
+ {
+ if (isRunning)
+ {
+ int msgID = MSGID_CANNOT_SET_ENVIRONMENT_CONFIG_WHILE_RUNNING;
+ String message = getMessage(msgID);
+ throw new InitializationException(msgID, message);
+ }
+
+ environmentConfig = config;
+ }
+
+
+
+ /**
+ * Indicates whether the Directory Server is currently running.
+ *
+ * @return {@code true} if the server is currently running, or {@code false}
+ * if not.
+ */
+ public static boolean isRunning()
+ {
+ return directoryServer.isRunning;
+ }
+
+
+
+ /**
* Bootstraps the appropriate Directory Server structures that may be needed
* by client-side tools. This is not intended for use in running the server
* itself.
@@ -788,16 +860,24 @@
// Install default debug and error loggers for use until enough of the
// configuration has been read to allow the real loggers to be installed.
+ removeAllAccessLogPublishers();
+ for (AccessLogPublisher p : environmentConfig.getAccessLoggers())
+ {
+ addAccessLogPublisher(p);
+ }
- startupErrorLogPublisher =
- TextErrorLogPublisher.getStartupTextErrorPublisher(
- new TextWriter.STDOUT());
- addErrorLogPublisher(startupErrorLogPublisher);
+ removeAllErrorLogPublishers();
+ for (ErrorLogPublisher p : environmentConfig.getErrorLoggers())
+ {
+ addErrorLogPublisher(p);
+ }
- startupDebugLogPublisher =
- TextDebugLogPublisher.getStartupTextDebugPublisher(
- new TextWriter.STDOUT());
- addDebugLogPublisher(startupDebugLogPublisher);
+ removeAllDebugLogPublishers();
+ for (DebugLogPublisher p : environmentConfig.getDebugLoggers())
+ {
+ addDebugLogPublisher(p);
+ }
+
// Create the MBean server that we will use for JMX interaction.
initializeJMX();
@@ -891,8 +971,45 @@
public void initializeConfiguration(String configClass, String configFile)
throws InitializationException
{
- this.configClass = configClass;
- this.configFile = configFile;
+ Class cfgClass;
+ try
+ {
+ cfgClass = Class.forName(configClass);
+ }
+ catch (Exception e)
+ {
+ if (debugEnabled())
+ {
+ TRACER.debugCaught(DebugLogLevel.ERROR, e);
+ }
+
+ int msgID = MSGID_CANNOT_LOAD_CONFIG_HANDLER_CLASS;
+ String message = getMessage(msgID, configClass,
+ stackTraceToSingleLineString(e));
+ throw new InitializationException(msgID, message, e);
+ }
+
+ File cfgFile = new File(configFile);
+
+ environmentConfig.setConfigClass(cfgClass);
+ environmentConfig.setConfigFile(cfgFile);
+ initializeConfiguration();
+ }
+
+
+
+ /**
+ * Instantiates the configuration handler and loads the Directory Server
+ * configuration.
+ *
+ * @throws InitializationException If a problem occurs while trying to
+ * initialize the config handler.
+ */
+ public void initializeConfiguration()
+ throws InitializationException
+ {
+ this.configClass = environmentConfig.getConfigClass();
+ this.configFile = environmentConfig.getConfigFile();
// Make sure that administration framework definition classes are loaded.
@@ -904,23 +1021,7 @@
// Load and instantiate the configuration handler class.
- Class handlerClass;
- try
- {
- handlerClass = Class.forName(configClass);
- }
- catch (Exception e)
- {
- if (debugEnabled())
- {
- TRACER.debugCaught(DebugLogLevel.ERROR, e);
- }
-
- int msgID = MSGID_CANNOT_LOAD_CONFIG_HANDLER_CLASS;
- String message = getMessage(msgID, configClass, e);
- throw new InitializationException(msgID, message, e);
- }
-
+ Class handlerClass = configClass;
try
{
configHandler = (ConfigHandler) handlerClass.newInstance();
@@ -941,7 +1042,8 @@
// Perform the handler-specific initialization.
try
{
- configHandler.initializeConfigHandler(configFile, false);
+ configHandler.initializeConfigHandler(configFile.getAbsolutePath(),
+ false);
}
catch (InitializationException ie)
{
@@ -976,7 +1078,7 @@
*/
public static String getConfigFile()
{
- return directoryServer.configFile;
+ return directoryServer.configFile.getAbsolutePath();
}
@@ -1054,11 +1156,8 @@
// Determine whether or not we should start the connection handlers.
- String disableProperty =
- System.getProperty(PROPERTY_DISABLE_CONNECTION_HANDLERS);
boolean startConnectionHandlers =
- ((disableProperty == null) ||
- (! disableProperty.equalsIgnoreCase("true")));
+ (! environmentConfig.disableConnectionHandlers());
// Initialize all the schema elements.
@@ -1225,8 +1324,15 @@
sendAlertNotification(this, ALERT_TYPE_SERVER_STARTED, msgID, message);
- removeDebugLogPublisher(startupDebugLogPublisher);
- removeErrorLogPublisher(startupErrorLogPublisher);
+ if (startupDebugLogPublisher != null)
+ {
+ removeDebugLogPublisher(startupDebugLogPublisher);
+ }
+
+ if (startupErrorLogPublisher != null)
+ {
+ removeErrorLogPublisher(startupErrorLogPublisher);
+ }
// If a server.starting file exists, then remove it.
@@ -2176,7 +2282,7 @@
try
{
- configHandler.initializeConfigHandler(configFile, true);
+ configHandler.initializeConfigHandler(configFile.getAbsolutePath(), true);
}
catch (InitializationException ie)
{
@@ -2860,23 +2966,15 @@
{
if (directoryServer.configHandler == null)
{
- String serverRoot = System.getProperty(PROPERTY_SERVER_ROOT);
-
- if (serverRoot == null)
- {
- serverRoot = System.getenv(ENV_VAR_INSTANCE_ROOT);
- }
-
+ File serverRoot = directoryServer.environmentConfig.getServerRoot();
if (serverRoot != null)
{
- return serverRoot;
+ return serverRoot.getAbsolutePath();
}
- else
- {
- // We don't know where the server root is, so we'll have to assume it's
- // the current working directory.
- return System.getProperty("user.dir");
- }
+
+ // We don't know where the server root is, so we'll have to assume it's
+ // the current working directory.
+ return System.getProperty("user.dir");
}
else
{
@@ -8283,10 +8381,29 @@
*/
public static void restart(String className, String reason)
{
+ restart(className, reason, directoryServer.environmentConfig);
+ }
+
+
+
+ /**
+ * Causes the Directory Server to perform an in-core restart. This will
+ * cause virtually all components of the Directory Server to shut down, and
+ * once that has completed it will be restarted.
+ *
+ * @param className The fully-qualified name of the Java class that
+ * initiated the shutdown.
+ * @param reason The human-readable reason that the directory server is
+ * shutting down.
+ * @param config The environment configuration to use for the server.
+ */
+ public static void restart(String className, String reason,
+ DirectoryEnvironmentConfig config)
+ {
try
{
shutDown(className, reason);
- reinitialize();
+ reinitialize(config);
directoryServer.startServer();
}
catch (Exception e)
@@ -8300,23 +8417,52 @@
}
}
+
+
/**
- * Reinitializes the server following a shutdown, preparing it for
- * a call to <code>startServer</code>.
+ * Reinitializes the server following a shutdown, preparing it for a call to
+ * {@code startServer}.
+ *
+ * @return The new Directory Server instance created during the
+ * reinitialization process.
*
* @throws InitializationException If a problem occurs while trying to
* initialize the config handler or
* bootstrap that server.
*/
- public static void reinitialize() throws InitializationException
+ public static DirectoryServer reinitialize()
+ throws InitializationException
{
- String configClass = directoryServer.configClass;
- String configFile = directoryServer.configFile;
- getNewInstance();
- directoryServer.bootstrapServer();
- directoryServer.initializeConfiguration(configClass, configFile);
+ return reinitialize(directoryServer.environmentConfig);
}
+
+
+ /**
+ * Reinitializes the server following a shutdown, preparing it for a call to
+ * {@code startServer}.
+ *
+ * @param config The environment configuration for the Directory Server.
+ *
+ * @return The new Directory Server instance created during the
+ * reinitialization process.
+ *
+ * @throws InitializationException If a problem occurs while trying to
+ * initialize the config handler or
+ * bootstrap that server.
+ */
+ public static DirectoryServer reinitialize(DirectoryEnvironmentConfig config)
+ throws InitializationException
+ {
+ getNewInstance(config);
+ LockManager.reinitializeLockTable();
+ directoryServer.bootstrapServer();
+ directoryServer.initializeConfiguration();
+ return directoryServer;
+ }
+
+
+
/**
* Retrieves the maximum number of concurrent client connections that may be
* established.
@@ -9217,10 +9363,45 @@
}
+ // Create an environment configuration for the server and populate a number
+ // of appropriate properties.
+ TextErrorLogPublisher startupErrorLogPublisher = null;
+ TextDebugLogPublisher startupDebugLogPublisher = null;
+ DirectoryEnvironmentConfig environmentConfig =
+ new DirectoryEnvironmentConfig();
+ try
+ {
+ environmentConfig.setProperty(PROPERTY_CONFIG_CLASS,
+ configClass.getValue());
+ environmentConfig.setProperty(PROPERTY_CONFIG_FILE,
+ configFile.getValue());
+
+
+ startupErrorLogPublisher =
+ TextErrorLogPublisher.getStartupTextErrorPublisher(
+ new TextWriter.STDOUT());
+ environmentConfig.addErrorLogger(startupErrorLogPublisher);
+
+ startupDebugLogPublisher =
+ TextDebugLogPublisher.getStartupTextDebugPublisher(
+ new TextWriter.STDOUT());
+ environmentConfig.addDebugLogger(startupDebugLogPublisher);
+ }
+ catch (Exception e)
+ {
+ // This shouldn't happen. For the methods we are using, the exception is
+ // just a guard against making changes with the server running.
+ }
+
+
// Bootstrap and start the Directory Server.
DirectoryServer directoryServer = DirectoryServer.getInstance();
try
{
+ directoryServer.startupErrorLogPublisher = startupErrorLogPublisher;
+ directoryServer.startupDebugLogPublisher = startupDebugLogPublisher;
+
+ directoryServer.setEnvironmentConfig(environmentConfig);
directoryServer.bootstrapServer();
directoryServer.initializeConfiguration(configClass.getValue(),
configFile.getValue());
--
Gitblit v1.10.0