/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions Copyright 2007 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.admin.server;
|
|
|
|
import static org.opends.server.messages.MessageHandler.getMessage;
|
import static org.opends.server.util.StaticUtils.stackTraceToSingleLineString;
|
|
import java.lang.reflect.Method;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import org.opends.server.admin.ClassPropertyDefinition;
|
import org.opends.server.admin.Configuration;
|
import org.opends.server.config.ConfigException;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.messages.AdminMessages;
|
import org.opends.server.types.ConfigChangeResult;
|
import org.opends.server.types.InitializationException;
|
import org.opends.server.types.ResultCode;
|
|
|
|
/**
|
* A skeleton implementation of a configuration manager. This type of
|
* manager can be used for managing "optional" configurations (i.e.
|
* where there is a one to zero or one relationship).
|
* <p>
|
* Configuration managers are responsible for initializing and
|
* finalizing instances as required. During initialization, the
|
* manager takes responsibility for loading and instantiating the
|
* implementation class. It then initializes the implementation
|
* instance by invoking a method having the following signature:
|
*
|
* <pre>
|
* void initializeXXX(YYY config) throws ConfigException,
|
* InitializationException;
|
* </pre>
|
*
|
* Where <code>XXX</code> is the simple name of the instance type
|
* <code>T</code>, and <code>YYY</code> is the expected
|
* configuration type for the implementation, which is either the
|
* configuration type <code>C</code> or a sub-type thereof.
|
*
|
* @param <C>
|
* The type of configuration referenced by this manager.
|
* @param <T>
|
* The type of component represented by the configuration.
|
*/
|
public abstract class AbstractOptionalConfigurationManager
|
<C extends Configuration, T> {
|
|
/**
|
* Private add listener implementation.
|
*/
|
private class AddListener implements ConfigurationAddListener<C> {
|
|
// Private constructor.
|
private AddListener() {
|
// No implementation required.
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ConfigChangeResult applyConfigurationAdd(C config) {
|
// Default result code.
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
ArrayList<String> messages = new ArrayList<String>();
|
|
// We have committed to this change so always update the
|
// configuration.
|
setConfiguration(config);
|
|
if (isEnabled(config)) {
|
// The configuration is enabled so it should be instantiated.
|
try {
|
// Notify that a new instance has been added.
|
doRegisterInstance(getImplementation(config));
|
} catch (ConfigException e) {
|
messages.add(e.getMessage());
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
} catch (InitializationException e) {
|
messages.add(e.getMessage());
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
}
|
} else {
|
// Ignore this configuration if it is disabled - we don't need
|
// to set instance to null here since it should already be
|
// null, but we do just to make the behavior explicit.
|
if (instance != null) {
|
finalizeInstance(instance);
|
instance = null;
|
}
|
notifyDisableInstance(config);
|
}
|
|
// Return the configuration result.
|
return new ConfigChangeResult(resultCode, adminActionRequired,
|
messages);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean isConfigurationAddAcceptable(C config,
|
List<String> unacceptableReasons) {
|
if (isEnabled(config)) {
|
// It's enabled so always validate the class.
|
return isJavaClassAcceptable(config, unacceptableReasons);
|
} else {
|
// It's disabled so ignore it.
|
return true;
|
}
|
}
|
}
|
|
|
|
/**
|
* Private change listener implementation.
|
*/
|
private class ChangeListener implements
|
ConfigurationChangeListener<C> {
|
|
// Private constructor.
|
private ChangeListener() {
|
// No implementation required.
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ConfigChangeResult applyConfigurationChange(C config) {
|
// Default result code.
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
ArrayList<String> messages = new ArrayList<String>();
|
|
// We have committed to this change so always update the
|
// configuration.
|
setConfiguration(config);
|
|
// See whether the configuration should be enabled.
|
if (instance == null) {
|
if (isEnabled(config)) {
|
// The configuration is enabled so it should be
|
// instantiated.
|
try {
|
// Notify that a new instance has been added.
|
doRegisterInstance(getImplementation(config));
|
} catch (ConfigException e) {
|
messages.add(e.getMessage());
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
} catch (InitializationException e) {
|
messages.add(e.getMessage());
|
resultCode = DirectoryServer.getServerErrorResultCode();
|
}
|
} else {
|
// Do nothing: we could notify that the configuration is
|
// disabled, but it was already, so there's no point in
|
// notifying again.
|
}
|
} else if (isEnabled(config)) {
|
// The instance is currently active, so we don't need to do
|
// anything. Changes to the class name should not be applied
|
// dynamically, so if the class name did change then
|
// indicate that administrative action is required for that
|
// change to take effect.
|
String className = getJavaImplementationClass(config);
|
if (!className.equals(instance.getClass().getName())) {
|
adminActionRequired = true;
|
}
|
} else {
|
// We need to disable the instance.
|
if (instance != null) {
|
finalizeInstance(instance);
|
instance = null;
|
}
|
notifyDisableInstance(config);
|
}
|
|
// Return the configuration result.
|
return new ConfigChangeResult(resultCode, adminActionRequired,
|
messages);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean isConfigurationChangeAcceptable(C config,
|
List<String> unacceptableReasons) {
|
if (isEnabled(config)) {
|
// It's enabled so always validate the class.
|
return isJavaClassAcceptable(config, unacceptableReasons);
|
} else if (isEnabled(getConfiguration())) {
|
return isDisableInstanceAcceptable(config,
|
unacceptableReasons);
|
} else {
|
// It's already disabled so ignore it.
|
return true;
|
}
|
}
|
}
|
|
|
|
/**
|
* Private delete listener implementation.
|
*/
|
private class DeleteListener implements
|
ConfigurationDeleteListener<C> {
|
|
// Private constructor.
|
private DeleteListener() {
|
// No implementation required.
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public ConfigChangeResult applyConfigurationDelete(C config) {
|
// Default result code.
|
ResultCode resultCode = ResultCode.SUCCESS;
|
boolean adminActionRequired = false;
|
|
// We have committed to this change so always update the
|
// configuration and finalize the instance.
|
setConfiguration(null);
|
|
if (instance != null) {
|
finalizeInstance(instance);
|
instance = null;
|
}
|
notifyDeleteInstance(config);
|
|
return new ConfigChangeResult(resultCode, adminActionRequired);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public boolean isConfigurationDeleteAcceptable(C config,
|
List<String> unacceptableReasons) {
|
if (isEnabled(getConfiguration())) {
|
return isDisableInstanceAcceptable(config,
|
unacceptableReasons);
|
} else {
|
return true;
|
}
|
}
|
}
|
|
// The property definition defining the Java implementation class.
|
private final ClassPropertyDefinition propertyDefinition;
|
|
// The instance class.
|
private final Class<T> theClass;
|
|
// Configuration add listener.
|
private final AddListener addListener;
|
|
// Configuration change listener.
|
private final ChangeListener changeListener;
|
|
// Configuration delete listener.
|
private final DeleteListener deleteListener;
|
|
// Indicates whether or not the parent listeners have been
|
// registered.
|
private boolean listenersRegistered;
|
|
// The current active configuration.
|
private C currentConfig;
|
|
// The current active instance.
|
private T instance;
|
|
|
|
/**
|
* Create a new optional configuration manager.
|
*
|
* @param theClass
|
* The instance class.
|
* @param propertyDefinition
|
* The property definition defining the Java implementation
|
* class.
|
*/
|
protected AbstractOptionalConfigurationManager(Class<T> theClass,
|
ClassPropertyDefinition propertyDefinition) {
|
this.currentConfig = null;
|
this.instance = null;
|
this.theClass = theClass;
|
this.propertyDefinition = propertyDefinition;
|
this.listenersRegistered = false;
|
|
this.addListener = new AddListener();
|
this.deleteListener = new DeleteListener();
|
this.changeListener = new ChangeListener();
|
}
|
|
|
|
/**
|
* Performs any finalization that may be necessary for this manager.
|
*/
|
public final void finalizeManager() {
|
deregisterAddListener(addListener);
|
deregisterDeleteListener(deleteListener);
|
|
if (currentConfig != null) {
|
deregisterChangeListener(changeListener, currentConfig);
|
}
|
|
if (instance != null) {
|
finalizeInstance(instance);
|
}
|
}
|
|
|
|
/**
|
* Get the current active configuration.
|
*
|
* @return Returns the current active configuration.
|
*/
|
public final C getConfiguration() {
|
return currentConfig;
|
}
|
|
|
|
/**
|
* Get the current active instance.
|
*
|
* @return Returns the current active instance.
|
*/
|
public final T getInstance() {
|
return instance;
|
}
|
|
|
|
/**
|
* Initializes this manager based on the information in the provided
|
* configuration if available. The implementation of this method
|
* will first register this manager as an add/delete listener before
|
* processing the provided initial configuration if it is available.
|
* <p>
|
* It is safe to initialize the manager more than once. This is
|
* useful during testing as an easy way to set the manager's
|
* configuration.
|
*
|
* @param config
|
* The configuration (can be <code>null</code> if there
|
* is no initial configuration.
|
* @throws ConfigException
|
* If there is a problem with the configuration.
|
* @throws InitializationException
|
* If a problem occurs during initialization.
|
*/
|
public final void initialize(C config) throws ConfigException,
|
InitializationException {
|
// Register to be notified when a configuration is added or
|
// removed (only do this once).
|
if (!listenersRegistered) {
|
registerAddListener(addListener);
|
registerDeleteListener(deleteListener);
|
listenersRegistered = true;
|
}
|
|
// Make sure that there is no current instance.
|
instance = null;
|
|
if (config != null) {
|
// Always register as a listener.
|
setConfiguration(config);
|
|
if (isEnabled(config)) {
|
// We have a configuration and it is enabled.
|
doRegisterInstance(getImplementation(config));
|
} else {
|
// There is a configuration present but it is disabled. Don't
|
// process the configuration in case it is invalid. We don't
|
// want to issue warnings for components which are disabled.
|
notifyDisableInstance(config);
|
}
|
}
|
}
|
|
|
|
/**
|
* Deregisters an add listener.
|
*
|
* @param listener
|
* The configuration add listener.
|
*/
|
protected abstract void deregisterAddListener(
|
ConfigurationAddListener<C> listener);
|
|
|
|
/**
|
* Deregisters a change listener.
|
*
|
* @param listener
|
* The configuration change listener.
|
* @param config
|
* The configuration from which to deregister the change
|
* listener.
|
*/
|
protected abstract void deregisterChangeListener(
|
ConfigurationChangeListener<C> listener, C config);
|
|
|
|
/**
|
* Deregisters a delete listener.
|
*
|
* @param listener
|
* The configuration delete listener.
|
*/
|
protected abstract void deregisterDeleteListener(
|
ConfigurationDeleteListener<C> listener);
|
|
|
|
/**
|
* Finalizes a previously activate instance.
|
*
|
* @param instance
|
* The instance to be finalized.
|
*/
|
protected abstract void finalizeInstance(T instance);
|
|
|
|
/**
|
* Get the name of the Java implementation class.
|
* <p>
|
* Sub-classes should usually implement this method using a call to
|
* the configuration's <code>getJavaImplementationClass()</code>
|
* method.
|
*
|
* @param config
|
* The active configuration.
|
* @return Returns the name of the Java implementation class.
|
*/
|
protected abstract String getJavaImplementationClass(C config);
|
|
|
|
/**
|
* Indicates whether the active instance can be disabled or deleted.
|
*
|
* @param config
|
* The configuration that will be disabled or deleted.
|
* @param unacceptableReasons
|
* A list that can be used to hold messages about why the
|
* active instance cannot be disabled or deleted..
|
* @return Returns <code>true</code> if the active instance can be
|
* disabled or deleted.
|
*/
|
protected abstract boolean isDisableInstanceAcceptable(C config,
|
List<String> unacceptableReasons);
|
|
|
|
/**
|
* Determines whether or not the active configuration is enabled or
|
* not.
|
* <p>
|
* Sub-classes should usually implement this method using a call to
|
* the configuration's <code>isEnabled()</code> method.
|
*
|
* @param config
|
* The active configuration.
|
* @return Returns <code>true</code> if the configuration is
|
* enabled.
|
*/
|
protected abstract boolean isEnabled(C config);
|
|
|
|
/**
|
* Notify that the configuration has been deleted. This may involve
|
* logging a message. Implementations do not need to worry about
|
* finalizing the instance, since that is performed by the
|
* {@link #finalizeInstance(Object)} method.
|
*
|
* @param config
|
* The deleted configuration.
|
*/
|
protected abstract void notifyDeleteInstance(C config);
|
|
|
|
/**
|
* Notify that the configuration has been disabled. This may involve
|
* logging a message. Implementations do not need to worry about
|
* finalizing the instance, since that is performed by the
|
* {@link #finalizeInstance(Object)} method.
|
*
|
* @param config
|
* The disabled configuration.
|
*/
|
protected abstract void notifyDisableInstance(C config);
|
|
|
|
/**
|
* Register to be notified when the configuration is added.
|
*
|
* @param listener
|
* The configuration add listener.
|
* @throws ConfigException
|
* If the add listener could not be registered.
|
*/
|
protected abstract void registerAddListener(
|
ConfigurationAddListener<C> listener) throws ConfigException;
|
|
|
|
/**
|
* Register to be notified when a configuration is changed.
|
*
|
* @param listener
|
* The configuration change listener.
|
* @param config
|
* Receive change notifications for this configuration.
|
*/
|
protected abstract void registerChangeListener(
|
ConfigurationChangeListener<C> listener, C config);
|
|
|
|
/**
|
* Register to be notified when the configuration is deleted.
|
*
|
* @param listener
|
* The configuration delete listener.
|
* @throws ConfigException
|
* If the add listener could not be registered.
|
*/
|
protected abstract void registerDeleteListener(
|
ConfigurationDeleteListener<C> listener) throws ConfigException;
|
|
|
|
/**
|
* Registers a newly activated instance. This may involve updating
|
* the parent configuration, starting a thread, etc. This manager
|
* will have already invoked <code>initialize(C config)</code>
|
* against the instance.
|
*
|
* @param instance
|
* The new instance.
|
* @throws InitializationException
|
* If a problem occurs during initialization.
|
*/
|
protected abstract void registerInstance(T instance)
|
throws InitializationException;
|
|
|
|
// Notify listeners that a new instance has been added and/or
|
// enabled.
|
private void doRegisterInstance(T instance)
|
throws InitializationException {
|
this.instance = instance;
|
|
// Let sub-class implementation decide what to do with the new
|
// instance.
|
registerInstance(instance);
|
}
|
|
|
|
// Load, instantiate, and initialize the class named in the Java
|
// implementation class property of the provided configuration.
|
private T getImplementation(C config) throws ConfigException {
|
String className = getJavaImplementationClass(config);
|
|
// Load the class and cast it to a T.
|
Class<? extends T> implClass;
|
T instance;
|
|
try {
|
implClass = propertyDefinition.loadClass(className, theClass);
|
instance = implClass.newInstance();
|
} catch (Exception e) {
|
int msgID = AdminMessages.MSGID_ADMIN_CANNOT_INSTANTIATE_CLASS;
|
String message = getMessage(msgID, String.valueOf(className),
|
String.valueOf(config.dn()),
|
stackTraceToSingleLineString(e));
|
throw new ConfigException(msgID, message, e);
|
}
|
|
// Perform the necessary initialization for the instance.
|
try {
|
// Determine the initialization method to use: it must take a
|
// single parameter which is the exact type of the configuration
|
// object.
|
String name = getInitializationMethodName();
|
Method method = implClass.getMethod(name, config.definition()
|
.getServerConfigurationClass());
|
|
method.invoke(instance, config);
|
} catch (Exception e) {
|
int msgID = AdminMessages.MSGID_ADMIN_CANNOT_INITIALIZE_COMPONENT;
|
String message = getMessage(msgID, String.valueOf(className),
|
String.valueOf(config.dn()),
|
stackTraceToSingleLineString(e));
|
throw new ConfigException(msgID, message, e);
|
}
|
|
// The instance has been successfully initialized.
|
return instance;
|
}
|
|
|
|
// Get the name of the method which should be used
|
// to initialize instances.
|
private String getInitializationMethodName() {
|
return "initialize" + theClass.getSimpleName();
|
}
|
|
|
|
// Determines whether or not the new configuration's implementation
|
// class is acceptable.
|
private boolean isJavaClassAcceptable(C config,
|
List<String> unacceptableReasons) {
|
String className = getJavaImplementationClass(config);
|
|
// Load the class and cast it to a T.
|
Class<? extends T> implClass;
|
|
try {
|
implClass = propertyDefinition.loadClass(className, theClass);
|
implClass.newInstance();
|
} catch (Exception e) {
|
int msgID = AdminMessages.MSGID_ADMIN_CANNOT_INSTANTIATE_CLASS;
|
unacceptableReasons.add(getMessage(msgID, String
|
.valueOf(className), String.valueOf(config.dn()),
|
stackTraceToSingleLineString(e)));
|
return false;
|
}
|
|
// Perform the necessary initialization for the instance.
|
try {
|
// Determine the initialization method to use: it must take a
|
// single parameter which is the exact type of the configuration
|
// object.
|
String name = getInitializationMethodName();
|
implClass.getMethod(name, config.definition()
|
.getServerConfigurationClass());
|
} catch (Exception e) {
|
int msgID = AdminMessages.MSGID_ADMIN_CANNOT_INITIALIZE_COMPONENT;
|
unacceptableReasons.add(getMessage(msgID, String
|
.valueOf(className), String.valueOf(config.dn()),
|
stackTraceToSingleLineString(e)));
|
return false;
|
}
|
|
// The class is valid as far as we can tell.
|
return true;
|
}
|
|
|
|
// Set the new configuration and register for change events.
|
private void setConfiguration(C config) {
|
// We only need to register for change events if there was no
|
// previous configuration. This is because the notification
|
// frameworks ensures that listeners are preserved when a new
|
// configuration replaces an old one.
|
if (currentConfig == null && config != null) {
|
registerChangeListener(changeListener, config);
|
}
|
currentConfig = config;
|
}
|
}
|
