/*
* 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
* 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
*
*
* Copyright 2006-2009 Sun Microsystems, Inc.
* Portions copyright 2013 ForgeRock AS
*/
/**
* This class defines a connection handler that will be used for
* communicating with administrative clients over JMX. The connection
* handler is responsible for accepting new connections, reading
* requests from the clients and parsing them as operations. A single
* request handler should be used.
*/
public final class JmxConnectionHandler extends
ConnectionHandler<JMXConnectionHandlerCfg> implements
/**
* Key that may be placed into a JMX connection environment map to
* provide a custom <code>javax.net.ssl.TrustManager</code> array
* for a connection.
*/
"org.opends.server.protocol.jmx.ssl.trust.manager.array";
// The fully-qualified name of this class.
"org.opends.server.protocols.jmx.JMXConnectionHandler";
// The list of active client connection.
// The current configuration state.
// The JMX RMI Connector associated with the Connection handler.
// The unique name for this connection handler.
// The protocol used to communicate with clients.
// The set of listeners for this connection handler.
/**
* Creates a new instance of this JMX connection handler. It must be
* initialized before it may be used.
*/
public JmxConnectionHandler() {
super("JMX Connection Handler Thread");
}
/**
* {@inheritDoc}
*/
// Create variables to include in the response.
// Determine whether or not the RMI connection needs restarting.
boolean rmiConnectorRestart = false;
boolean portChanged = false;
rmiConnectorRestart = true;
portChanged = true;
}
rmiConnectorRestart = true;
}
config.getSSLCertNickname())) ||
currentConfig.getSSLCertNickname()))) {
rmiConnectorRestart = true;
}
// Save the configuration.
// Restart the connector if required.
if (rmiConnectorRestart) {
protocol = "JMX+SSL";
} else {
protocol = "JMX";
}
try
{
}
catch (RuntimeException e)
{
}
}
// If the port number has changed then update the JMX port information
// stored in the system properties.
if (portChanged)
{
}
// Return configuration result.
}
/**
* {@inheritDoc}
*/
// Make sure that we don't get notified of any more changes.
// We should also close the RMI registry.
}
/**
* Retrieves information about the set of alerts that this generator
* may produce. The map returned should be between the notification
* type for a particular notification and the human-readable
* description for that notification. This alert generator must not
* generate any alerts with types that are not contained in this
* list.
*
* @return Information about the set of alerts that this generator
* may produce.
*/
return alerts;
}
/**
* Retrieves the fully-qualified name of the Java class for this
* alert generator implementation.
*
* @return The fully-qualified name of the Java class for this alert
* generator implementation.
*/
return CLASS_NAME;
}
/**
* Retrieves the set of active client connections that have been
* established through this connection handler.
*
* @return The set of active client connections that have been
* established through this connection handler.
*/
return connectionList;
}
/**
* Retrieves the DN of the configuration entry with which this alert
* generator is associated.
*
* @return The DN of the configuration entry with which this alert
* generator is associated.
*/
return currentConfig.dn();
}
/**
* Retrieves the DN of the key manager provider that should be used
* for operations associated with this connection handler which need
* access to a key manager.
*
* @return The DN of the key manager provider that should be used
* for operations associated with this connection handler
* which need access to a key manager, or {@code null} if no
* key manager provider has been configured for this
* connection handler.
*/
return currentConfig.getKeyManagerProviderDN();
}
/**
* Get the JMX connection handler's listen port.
*
* @return Returns the JMX connection handler's listen port.
*/
public int getListenPort() {
return currentConfig.getListenPort();
}
/**
* Get the JMX connection handler's RMI connector.
*
* @return Returns the JMX connection handler's RMI connector.
*/
return rmiConnector;
}
/**
* {@inheritDoc}
*/
return connectionHandlerName;
}
/**
* Retrieves the nickname of the server certificate that should be
* used in conjunction with this JMX connection handler.
*
* @return The nickname of the server certificate that should be
* used in conjunction with this JMX connection handler.
*/
return currentConfig.getSSLCertNickname();
}
/**
* {@inheritDoc}
*/
{
// Configuration is ok.
// Attempt to bind to the listen port to verify whether the connection
// handler will be able to start.
try
{
config.getListenPort(), true)) {
throw new IOException(
}
}
catch (Exception e)
{
throw new InitializationException(message);
}
protocol = "JMX+SSL";
} else {
protocol = "JMX";
}
// Create a system property to store the JMX port the server is
// listening to. This information can be displayed with jinfo.
// Create the associated RMI Connector.
// Register this as a change listener.
config.addJMXChangeListener(this);
}
/**
* {@inheritDoc}
*/
return connectionHandlerName;
}
/**
* {@inheritDoc}
*/
return protocol;
}
/**
* {@inheritDoc}
*/
return listeners;
}
/**
* {@inheritDoc}
*/
@Override()
{
if ((currentConfig == null) ||
// Attempt to bind to the listen port to verify whether the connection
// handler will be able to start.
try {
config.getListenPort(), true)) {
throw new IOException(
}
} catch (Exception e) {
getExceptionMessage(e));
return false;
}
}
}
/**
* {@inheritDoc}
*/
public boolean isConfigurationChangeAcceptable(
// All validation is performed by the admin framework.
return true;
}
/**
* Determines whether or not clients are allowed to connect over JMX
* using SSL.
*
* @return Returns <code>true</code> if clients are allowed to
* connect over JMX using SSL.
*/
public boolean isUseSSL() {
return currentConfig.isUseSSL();
}
/**
* {@inheritDoc}
*/
// We should also close the RMI registry.
}
/**
* Registers a client connection with this JMX connection handler.
*
* @param connection
* The client connection.
*/
}
/**
* {@inheritDoc}
*/
public void run() {
try
{
}
catch (RuntimeException e)
{
}
}
/**
* {@inheritDoc}
*/
}
}