/*
|
* 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.statuspanel;
|
|
import java.util.HashSet;
|
import java.util.Set;
|
|
import javax.naming.NamingEnumeration;
|
import javax.naming.NamingException;
|
import javax.naming.directory.Attribute;
|
import javax.naming.directory.Attributes;
|
import javax.naming.directory.SearchControls;
|
import javax.naming.directory.SearchResult;
|
import javax.naming.ldap.InitialLdapContext;
|
import javax.naming.ldap.LdapName;
|
|
import org.opends.statuspanel.i18n.ResourceProvider;
|
import org.opends.quicksetup.util.Utils;
|
|
/**
|
* This class is used to retrieve configuration and monitoring information using
|
* LDAP protocol.
|
*
|
*/
|
public class ConfigFromLDAP
|
{
|
private HashSet<ListenerDescriptor> listeners =
|
new HashSet<ListenerDescriptor>();
|
private HashSet<DatabaseDescriptor> databases =
|
new HashSet<DatabaseDescriptor>();
|
private HashSet<String> administrativeUsers = new HashSet<String>();
|
private String errorMessage;
|
|
private String dn;
|
private String pwd;
|
private String ldapUrl;
|
|
private InitialLdapContext ctx;
|
private String javaVersion;
|
private int openConnections = -1;
|
|
/**
|
* Default constructor.
|
*
|
*/
|
public ConfigFromLDAP()
|
{
|
}
|
|
/**
|
* Sets the connection information required to contact the server using LDAP.
|
* @param ldapUrl the LDAP URL of the server.
|
* @param dn the authentication Distinguished Name to bind.
|
* @param pwd the authentication password to bind.
|
*/
|
public void setConnectionInfo(String ldapUrl, String dn, String pwd)
|
{
|
if (ldapUrl == null)
|
{
|
throw new IllegalArgumentException("ldapUrl cannot be null.");
|
}
|
if (dn == null)
|
{
|
throw new IllegalArgumentException("dn cannot be null.");
|
}
|
if (pwd == null)
|
{
|
throw new IllegalArgumentException("pwd cannot be null.");
|
}
|
if (!Utils.areDnsEqual(dn, this.dn) ||
|
!pwd.equals(this.pwd) ||
|
!ldapUrl.equals(this.ldapUrl))
|
{
|
if (ctx != null)
|
{
|
try
|
{
|
ctx.close();
|
}
|
catch (Throwable t)
|
{
|
}
|
ctx = null;
|
}
|
}
|
|
this.ldapUrl = ldapUrl;
|
this.dn = dn;
|
this.pwd = pwd;
|
}
|
|
/**
|
* Reads the configuration and monitoring information of the server using
|
* LDAP.
|
* When calling this method the thread is blocked until all the configuration
|
* is read.
|
*
|
* This method assumes that the setConnectionInfo has been called previously.
|
*
|
*/
|
public void readConfiguration()
|
{
|
errorMessage = null;
|
|
listeners.clear();
|
databases.clear();
|
administrativeUsers.clear();
|
javaVersion = null;
|
openConnections = -1;
|
|
try
|
{
|
InitialLdapContext ctx = getDirContext();
|
updateAdministrativeUsers(ctx);
|
updateListeners(ctx);
|
updateDatabases(ctx);
|
javaVersion = getJavaVersion(ctx);
|
openConnections = getOpenConnections(ctx);
|
}
|
catch (NamingException ne)
|
{
|
String detail;
|
if (ne.getMessage() != null)
|
{
|
detail = ne.getMessage();
|
}
|
else
|
{
|
detail = ne.toString();
|
}
|
String[] arg = {detail};
|
errorMessage = getMsg("error-reading-config-ldap", arg);
|
}
|
catch (Throwable t)
|
{
|
// Bug
|
t.printStackTrace();
|
String[] arg = {t.toString()};
|
errorMessage = getMsg("error-reading-config-ldap", arg);
|
}
|
}
|
|
|
/**
|
* Returns the Administrative User DNs found using LDAP.
|
* @return the Administrative User DNs found using LDAP.
|
*/
|
public HashSet<String> getAdministrativeUsers()
|
{
|
return administrativeUsers;
|
}
|
|
/**
|
* Returns the database descriptors found using LDAP.
|
* @return the database descriptors found using LDAP.
|
*/
|
public HashSet<DatabaseDescriptor> getDatabases()
|
{
|
return databases;
|
}
|
|
/**
|
* Returns the listener descriptors found using LDAP.
|
* @return the listeners descriptors found using LDAP.
|
*/
|
public HashSet<ListenerDescriptor> getListeners()
|
{
|
return listeners;
|
}
|
|
/**
|
* Return the java version we found using LDAP.
|
* @return the java version we found using LDAP.
|
*/
|
public String getJavaVersion()
|
{
|
return javaVersion;
|
}
|
|
/**
|
* Return the number of open connections we found using LDAP.
|
* @return the number of open connections we found using LDAP.
|
*/
|
public int getOpenConnections()
|
{
|
return openConnections;
|
}
|
|
/**
|
* Returns the error message that we got when retrieving the information
|
* using LDAP.
|
* @return the error message that we got when retrieving the information
|
* using LDAP.
|
*/
|
public String getErrorMessage()
|
{
|
return errorMessage;
|
}
|
|
/**
|
* Returns the InitialLdapContext object to be used to retrieve configuration
|
* and monitoring information.
|
* @return the InitialLdapContext object to be used to retrieve configuration
|
* and monitoring information.
|
* @throws NamingException if we could not get an InitialLdapContext.
|
*/
|
private InitialLdapContext getDirContext() throws NamingException
|
{
|
if (ctx != null)
|
{
|
try
|
{
|
pingDirContext(ctx);
|
}
|
catch (NamingException ne)
|
{
|
try
|
{
|
ctx.close();
|
}
|
catch(NamingException xx)
|
{
|
}
|
ctx = null;
|
}
|
}
|
if (ctx == null)
|
{
|
ctx = Utils.createLdapContext(ldapUrl, dn, pwd, 3000, null);
|
}
|
return ctx;
|
}
|
|
/**
|
* Ping the specified InitialLdapContext.
|
* This method sends a search request on the root entry of the DIT
|
* and forward the corresponding exception (if any).
|
* @param ctx the InitialLdapContext to be "pinged".
|
* @throws NamingException if the ping could not be performed.
|
*/
|
private void pingDirContext(InitialLdapContext ctx) throws NamingException {
|
SearchControls sc = new SearchControls(
|
SearchControls.OBJECT_SCOPE,
|
0, // count limit
|
0, // time limit
|
new String[0], // No attributes
|
false, // Don't return bound object
|
false // Don't dereference link
|
);
|
ctx.search("", "objectclass=*", sc);
|
}
|
|
/**
|
* Updates the listener configuration data we expose to the user with the
|
* provided InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateListeners(InitialLdapContext ctx) throws NamingException
|
{
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"ds-cfg-connection-handler-enabled",
|
"ds-cfg-listen-address",
|
"ds-cfg-listen-port",
|
"ds-cfg-use-ssl",
|
"objectclass"
|
});
|
String filter = "(objectclass=ds-cfg-connection-handler)";
|
|
LdapName jndiName = new LdapName("cn=config");
|
NamingEnumeration listeners = ctx.search(jndiName, filter, ctls);
|
|
while(listeners.hasMore())
|
{
|
SearchResult sr = (SearchResult)listeners.next();
|
|
updateConfigWithConnectionHandler(sr);
|
|
}
|
}
|
|
/**
|
* Updates the database configuration data we expose to the user with the
|
* provided InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateDatabases(InitialLdapContext ctx) throws NamingException
|
{
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"ds-cfg-backend-base-dn",
|
"ds-cfg-backend-id"
|
});
|
String filter = "(objectclass=ds-cfg-backend)";
|
|
LdapName jndiName = new LdapName("cn=config");
|
NamingEnumeration databases = ctx.search(jndiName, filter, ctls);
|
|
while(databases.hasMore())
|
{
|
SearchResult sr = (SearchResult)databases.next();
|
|
updateConfigWithBackend(sr, ctx);
|
|
}
|
}
|
|
/**
|
* Updates the administrative user configuration we expose to the user with
|
* the provided InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateAdministrativeUsers(InitialLdapContext ctx)
|
throws NamingException
|
{
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"ds-cfg-alternate-bind-dn"
|
});
|
String filter = "(objectclass=ds-cfg-root-dn)";
|
|
LdapName jndiName = new LdapName("cn=config");
|
NamingEnumeration users = ctx.search(jndiName, filter, ctls);
|
|
while(users.hasMore())
|
{
|
SearchResult sr = (SearchResult)users.next();
|
|
updateConfigWithAdministrativeUser(sr);
|
|
}
|
}
|
|
/**
|
* Returns the java version we find using the provided InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @return the java version we find using the provided InitialLdapContext.
|
* @throws NamingException if there was an error.
|
*/
|
private String getJavaVersion(InitialLdapContext ctx)
|
throws NamingException
|
{
|
String v = null;
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.OBJECT_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"jvmVersion"
|
});
|
String filter = "(objectclass=*)";
|
|
LdapName jndiName = new LdapName("cn=System Information,cn=monitor");
|
NamingEnumeration listeners = ctx.search(jndiName, filter, ctls);
|
|
while(listeners.hasMore())
|
{
|
SearchResult sr = (SearchResult)listeners.next();
|
|
v = getFirstValue(sr, "jvmVersion");
|
|
}
|
return v;
|
}
|
|
/**
|
* Returns the number of open connections we find using the provided
|
* InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @return the number of open connections we find using the provided
|
* InitialLdapContext.
|
* @throws NamingException if there was an error.
|
*/
|
private int getOpenConnections(InitialLdapContext ctx)
|
throws NamingException
|
{
|
int nConnections = -1;
|
String v = null;
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.OBJECT_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"currentConnections"
|
});
|
String filter = "(objectclass=*)";
|
|
LdapName jndiName = new LdapName("cn=monitor");
|
NamingEnumeration listeners = ctx.search(jndiName, filter, ctls);
|
|
while(listeners.hasMore())
|
{
|
SearchResult sr = (SearchResult)listeners.next();
|
|
v = getFirstValue(sr, "currentConnections");
|
}
|
try
|
{
|
nConnections = Integer.parseInt(v);
|
}
|
catch (Exception ex)
|
{
|
|
}
|
return nConnections;
|
|
}
|
|
/**
|
* Returns the number of entries in a given backend using the provided
|
* InitialLdapContext.
|
* @param ctx the InitialLdapContext to use to update the configuration.
|
* @param backenID the id of the backend.
|
* @return the number of entries in the backend.
|
* @throws NamingException if there was an error.
|
*/
|
private int getEntryCount(InitialLdapContext ctx, String backendID)
|
throws NamingException
|
{
|
int nEntries = -1;
|
String v = null;
|
SearchControls ctls = new SearchControls();
|
ctls.setSearchScope(SearchControls.ONELEVEL_SCOPE);
|
ctls.setReturningAttributes(
|
new String[] {
|
"ds-backend-entry-count"
|
});
|
String filter = "(ds-backend-id="+backendID+")";
|
|
LdapName jndiName = new LdapName("cn=monitor");
|
NamingEnumeration listeners = ctx.search(jndiName, filter, ctls);
|
|
while(listeners.hasMore())
|
{
|
SearchResult sr = (SearchResult)listeners.next();
|
|
v = getFirstValue(sr, "ds-backend-entry-count");
|
}
|
try
|
{
|
nEntries = Integer.parseInt(v);
|
}
|
catch (Exception ex)
|
{
|
|
}
|
return nEntries;
|
|
}
|
|
/**
|
* Updates the listener configuration data we expose to the user with the
|
* provided SearchResult object.
|
* @param entry the entry to analyze.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateConfigWithConnectionHandler(SearchResult entry)
|
throws NamingException
|
{
|
String address = getFirstValue(entry, "ds-cfg-listen-address");
|
String port = getFirstValue(entry, "ds-cfg-listen-port");
|
String addressPort;
|
|
boolean isSecure = "true".equalsIgnoreCase(
|
getFirstValue(entry, "ds-cfg-use-ssl"));
|
|
ListenerDescriptor.Protocol protocol;
|
String protocolDescription;
|
|
ListenerDescriptor.State state;
|
if (hasObjectClass(entry, "ds-cfg-ldap-connection-handler"))
|
{
|
addressPort = address+":"+port;
|
if (isSecure)
|
{
|
protocolDescription = getMsg("ldaps-protocol-label");
|
protocol = ListenerDescriptor.Protocol.LDAPS;
|
}
|
else
|
{
|
protocolDescription = getMsg("ldap-protocol-label");
|
protocol = ListenerDescriptor.Protocol.LDAP;
|
}
|
boolean enabled = "true".equalsIgnoreCase(
|
getFirstValue(entry, "ds-cfg-connection-handler-enabled"));
|
if (enabled)
|
{
|
state = ListenerDescriptor.State.ENABLED;
|
}
|
else
|
{
|
state = ListenerDescriptor.State.DISABLED;
|
}
|
}
|
else if (hasObjectClass(entry, "ds-cfg-jmx-connection-handler"))
|
{
|
addressPort = "0.0.0.0:"+port;
|
if (isSecure)
|
{
|
protocolDescription = getMsg("jmx-secure-protocol-label");
|
protocol = ListenerDescriptor.Protocol.JMXS;
|
}
|
else
|
{
|
protocolDescription = getMsg("jmx-protocol-label");
|
protocol = ListenerDescriptor.Protocol.JMX;
|
}
|
boolean enabled = "true".equalsIgnoreCase(
|
getFirstValue(entry, "ds-cfg-connection-handler-enabled"));
|
if (enabled)
|
{
|
state = ListenerDescriptor.State.ENABLED;
|
}
|
else
|
{
|
state = ListenerDescriptor.State.DISABLED;
|
}
|
}
|
else
|
{
|
addressPort = getMsg("unknown-label");
|
protocolDescription = null;
|
protocol = ListenerDescriptor.Protocol.OTHER;
|
/* Try to figure a name from the cn */
|
String cn = getFirstValue(entry, "cn");
|
if (cn != null)
|
{
|
int index = cn.toLowerCase().indexOf("connection handler");
|
if (index > 0)
|
{
|
protocolDescription = cn.substring(0, index).trim();
|
}
|
else
|
{
|
protocolDescription = cn;
|
}
|
}
|
else
|
{
|
protocolDescription = getMsg("undefined-protocol-label");
|
}
|
state = ListenerDescriptor.State.UNKNOWN;
|
}
|
listeners.add(new ListenerDescriptor(addressPort, protocol,
|
protocolDescription, state));
|
}
|
|
/**
|
* Updates the database configuration data we expose to the user with the
|
* provided SearchResult object.
|
* @param entry the entry to analyze.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateConfigWithBackend(SearchResult entry,
|
InitialLdapContext ctx)
|
throws NamingException
|
{
|
String baseDn = getFirstValue(entry, "ds-cfg-backend-base-dn");
|
String id = getFirstValue(entry, "ds-cfg-backend-id");
|
|
if (!isConfigBackend(id))
|
{
|
int nEntries = getEntryCount(ctx, id);
|
databases.add(new DatabaseDescriptor(id, baseDn, nEntries));
|
}
|
}
|
|
/**
|
* Updates the administrative user configuration data we expose to the user
|
* with the provided SearchResult object.
|
* @param entry the entry to analyze.
|
* @throws NamingException if there was an error.
|
*/
|
private void updateConfigWithAdministrativeUser(SearchResult entry)
|
throws NamingException
|
{
|
administrativeUsers.addAll(getValues(entry, "ds-cfg-alternate-bind-dn"));
|
}
|
|
/*
|
* The following 2 methods are convenience methods to retrieve String values
|
* from an entry.
|
*/
|
private String getFirstValue(SearchResult entry, String attrName)
|
throws NamingException
|
{
|
String v = null;
|
Attributes attrs = entry.getAttributes();
|
if (attrs != null)
|
{
|
Attribute attr = attrs.get(attrName);
|
if ((attr != null) && (attr.size() > 0))
|
{
|
v = (String)attr.get();
|
}
|
}
|
return v;
|
}
|
|
private Set<String> getValues(SearchResult entry, String attrName)
|
throws NamingException
|
{
|
Set<String> values = new HashSet<String>();
|
Attributes attrs = entry.getAttributes();
|
if (attrs != null)
|
{
|
Attribute attr = attrs.get(attrName);
|
if (attr != null)
|
{
|
for (int i=0; i<attr.size(); i++)
|
{
|
values.add((String)attr.get(i));
|
}
|
}
|
}
|
return values;
|
}
|
|
/**
|
* Returns true if the SearchResult object is of a given objectclass.
|
* @param entry the SearchResult to analyze.
|
* @param ocName the objectclass.
|
* @return <CODE>true</CODE> if the SearchResult is of a the objectclass and
|
* <CODE>false</CODE> otherwise.
|
* @throws NamingException if there was an error.
|
*/
|
private boolean hasObjectClass(SearchResult entry, String ocName)
|
throws NamingException
|
{
|
boolean hasObjectClass = false;
|
Attributes attrs = entry.getAttributes();
|
if (attrs != null)
|
{
|
Attribute attr = attrs.get("objectclass");
|
if (attr != null)
|
{
|
for (int i=0; i<attr.size() && !hasObjectClass; i++)
|
{
|
hasObjectClass = ocName.equalsIgnoreCase((String)attr.get(i));
|
}
|
}
|
}
|
return hasObjectClass;
|
}
|
|
|
private boolean isConfigBackend(String id)
|
{
|
return ConfigFromFile.isConfigBackend(id);
|
}
|
|
/**
|
* The following three methods are just commodity methods to get localized
|
* messages.
|
*/
|
private String getMsg(String key)
|
{
|
return getI18n().getMsg(key);
|
}
|
|
private String getMsg(String key, String[] args)
|
{
|
return getI18n().getMsg(key, args);
|
}
|
|
private ResourceProvider getI18n()
|
{
|
return ResourceProvider.getInstance();
|
}
|
}
|
