Update package-info.java files to include the @PublicAPI annotation to indicate
whether any or all of the classes in that package are intended to be part of
the public API. Further, mark all classes that we intend to be part of the
public API with the @PublicAPI annotation to indicate the ways in which they
may be used. Note that the use of these annotations and the ultimate
determination as to what is in our public API and the ways in which those
elements may be used still needs to be carefully reviewed before the 1.0
release.
Also, perform minor cleanup in various places througout the code. This
includes:
- Eliminate the use of protected fields in classes that are in the
org.opends.server.api package (and the classes that extend them). The use of
protected fields can be troublesome, and there are generally better ways to
accomplish the same thing.
- Eliminate the use of the {@inheritDoc} Javadoc tag in classes that are
intended to be part of the public API. Some IDEs don't resolve {@inheritDoc}
to show the actual documentation. Further, there were problems in the way
that some instances of {@inheritDoc} were used, namely having a method sourced
from multiple parents, and in some cases {@inheritDoc} was used to refer to
code defined outside of the OpenDS codebase, which will not be properly handled
by the javadoc utility.
- Update a number of public API classes to mark them as final if we do not
intend for them to be overridden. Further, for some classes that cannot be
marked final, mark some methods final if we do not intend for those methods to
be overridden.
| | |
| | | description="Compile the Directory Server source files."> |
| | | <mkdir dir="${classes.dir}" /> |
| | | |
| | | <javac srcdir="${src.dir}:${admin.src.dir}:${msg.src.dir}:${msg.javagen.dir}:${ads.src.dir}:${quicksetup.src.dir}:${guitools.src.dir}" destdir="${classes.dir}" |
| | | excludes="**/package-info.java" |
| | | debug="on" debuglevel="${build.debuglevel}" source="1.5" target="1.5" |
| | | deprecation="true" fork="true" memoryInitialSize="${MEM}" |
| | | memoryMaximumSize="${MEM}"> |
| | | <javac srcdir="${src.dir}:${admin.src.dir}:${msg.src.dir}:${msg.javagen.dir}:${ads.src.dir}:${quicksetup.src.dir}:${guitools.src.dir}" |
| | | destdir="${classes.dir}" debug="on" debuglevel="${build.debuglevel}" |
| | | source="1.5" target="1.5" deprecation="true" fork="true" |
| | | memoryInitialSize="${MEM}" memoryMaximumSize="${MEM}"> |
| | | <compilerarg value="-Xlint:all" /> |
| | | |
| | | <classpath> |
| | |
| | | * Directory Server source. It was dynamically generated as part of the |
| | | * Directory Server build process and should not be edited directly. |
| | | */ |
| | | public class DynamicConstants |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DynamicConstants |
| | | { |
| | | /** |
| | | * The official full product name for the Directory Server. |
| | |
| | | * as LDAPv3 requests to a directory server, and converts the LDAPv3 response |
| | | * back to a DSMLv2 response that is sent back to the client. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.dsml.protocol; |
| | | |
| | |
| | | * This package contains classes which client applications and client-side |
| | | * driver implementations are expected to use for their command-line interfaces. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.admin.client.cli; |
| | | |
| | |
| | | * Portions Copyright 2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * LDAP configuration transport implementation. |
| | | * <p> |
| | |
| | | * that, at some point in the future, we will replace this implementation |
| | | * with our own LDAP client SDK based implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.admin.client.ldap; |
| | | |
| | |
| | | * Portions Copyright 2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * Common client-side administration classes. |
| | | * <p> |
| | |
| | | * applications, <code>ExampleClient</code> and |
| | | * <code>ExampleIntrospection</code>. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.admin.client; |
| | | |
| | | |
| | | |
| | |
| | | * Portions Copyright 2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * Common administration classes. |
| | | * <p> |
| | | * This package contains administration related classes and interfaces |
| | | * common to both the client and server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.admin; |
| | | |
| | |
| | | * Portions Copyright 2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * Server-side administration interface. |
| | | * <p> |
| | |
| | | * access the server's current configuration and register |
| | | * to be notified when the configuration changes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.admin.server; |
| | | |
| | | |
| | | |
| | |
| | | * @param <T> The type of access control configuration handled by |
| | | * this access control provider implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class AccessControlHandler |
| | | <T extends AccessControlHandlerCfg> |
| | | { |
| | |
| | | * @param <T> The type of access log publisher configuration handled |
| | | * by this log publisher implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class AccessLogPublisher |
| | | <T extends AccessLogPublisherCfg> |
| | | { |
| | | /** |
| | | * Indicates if internal operations should be omited in the messages |
| | | * logged by this publisher. |
| | | */ |
| | | protected boolean suppressInternalOperations = true; |
| | | |
| | | /** |
| | | * Indicates if synchronization operations should be omited in the |
| | | * messages logged by this publisher. |
| | | */ |
| | | protected boolean suppressSynchronizationOperations = false; |
| | | |
| | | |
| | | |
| | | /** |
| | | * Initializes this access publisher provider based on the |
| | | * information in the provided debug publisher configuration. |
| | | * |
| | |
| | | * @param <T> The type of configuration handled by this notification |
| | | * handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class |
| | | AccountStatusNotificationHandler |
| | | <T extends AccountStatusNotificationHandlerCfg> |
| | |
| | | * component. The notifications will be made available through JMX |
| | | * and may be published through other mechanisms as well. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface AlertGenerator |
| | | { |
| | | /** |
| | |
| | | * @param <T> The type of configuration handled by this alert |
| | | * handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface AlertHandler<T extends AlertHandlerCfg> |
| | | { |
| | | /** |
| | |
| | | * |
| | | * @param generator The alert generator that created the alert. |
| | | * @param alertType The alert type name for this alert. |
| | | * @param alertMessage A message (possibly <CODE>null</CODE>) that |
| | | * can provide more information about this |
| | | * alert. |
| | | * @param alertMessage A message (possibly {@code null}) that can |
| | | * provide more information about this alert. |
| | | */ |
| | | public void sendAlertNotification(AlertGenerator generator, |
| | | String alertType, |
| | |
| | | * implemented by a Directory Server module that implements a matching |
| | | * rule used for approximate matching. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class ApproximateMatchingRule |
| | | extends MatchingRule<ApproximateMatchingRuleCfg> |
| | | { |
| | |
| | | * @param value2 The normalized form of the second value to |
| | | * compare. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided values are |
| | | * approximately equal, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if the provided values are approximately |
| | | * equal, or {@code false} if not. |
| | | */ |
| | | public abstract boolean approximatelyMatch(ByteString value1, |
| | | ByteString value2); |
| | |
| | | * considered a match for the given assertion value. This will only |
| | | * be used for the purpose of extensible matching. Other forms of |
| | | * matching against approximate matching rules should use the |
| | | * <CODE>areEqual</CODE> method. |
| | | * {@code areEqual} method. |
| | | * |
| | | * @param attributeValue The attribute value in a form that has |
| | | * been normalized according to this |
| | |
| | | * been normalized according to this |
| | | * matching rule. |
| | | * |
| | | * @return <CODE>TRUE</CODE> if the attribute value should be |
| | | * considered a match for the provided assertion value, |
| | | * <CODE>FALSE</CODE> if it does not match, or |
| | | * <CODE>UNDEFINED</CODE> if the result is undefined. |
| | | * @return {@code TRUE} if the attribute value should be considered |
| | | * a match for the provided assertion value, {@code FALSE} |
| | | * if it does not match, or {@code UNDEFINED} if the result |
| | | * is undefined. |
| | | */ |
| | | public ConditionResult valuesMatch(ByteString attributeValue, |
| | | ByteString assertionValue) |
| | |
| | | * @param <T> The type of configuration handled by this attribute |
| | | * syntax. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class AttributeSyntax<T extends AttributeSyntaxCfg> |
| | | { |
| | | /** |
| | |
| | | * for attributes with this syntax. |
| | | * |
| | | * @return The default equality matching rule that will be used for |
| | | * attributes with this syntax, or <CODE>null</CODE> if |
| | | * equality matches will not be allowed for this type by |
| | | * default. |
| | | * attributes with this syntax, or {@code null} if equality |
| | | * matches will not be allowed for this type by default. |
| | | */ |
| | | public abstract EqualityMatchingRule getEqualityMatchingRule(); |
| | | |
| | |
| | | * for attributes with this syntax. |
| | | * |
| | | * @return The default ordering matching rule that will be used for |
| | | * attributes with this syntax, or <CODE>null</CODE> if |
| | | * ordering matches will not be allowed for this type by |
| | | * default. |
| | | * attributes with this syntax, or {@code null} if ordering |
| | | * matches will not be allowed for this type by default. |
| | | */ |
| | | public abstract OrderingMatchingRule getOrderingMatchingRule(); |
| | | |
| | |
| | | * for attributes with this syntax. |
| | | * |
| | | * @return The default substring matching rule that will be used |
| | | * for attributes with this syntax, or <CODE>null</CODE> if |
| | | * for attributes with this syntax, or {@code null} if |
| | | * substring matches will not be allowed for this type by |
| | | * default. |
| | | */ |
| | |
| | | * for attributes with this syntax. |
| | | * |
| | | * @return The default approximate matching rule that will be used |
| | | * for attributes with this syntax, or <CODE>null</CODE> if |
| | | * for attributes with this syntax, or {@code null} if |
| | | * approximate matches will not be allowed for this type by |
| | | * default. |
| | | */ |
| | |
| | | * @param invalidReason The buffer to which the invalid reason |
| | | * should be appended. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided value is acceptable |
| | | * for use with this syntax, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if the provided value is acceptable for use |
| | | * with this syntax, or {@code false} if not. |
| | | */ |
| | | public abstract boolean valueIsAcceptable(ByteString value, |
| | | MessageBuilder invalidReason); |
| | |
| | | * |
| | | * @return The hash code for this attribute syntax. |
| | | */ |
| | | public int hashCode() |
| | | public final int hashCode() |
| | | { |
| | | int hashCode = 0; |
| | | |
| | |
| | | * |
| | | * @param o The object for which to make the determination. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided object is equal to |
| | | * this attribute syntax, or <CODE>false</CODE> if it is |
| | | * not. |
| | | * @return {@code true} if the provided object is equal to this |
| | | * attribute syntax, or {@code false} if it is not. |
| | | */ |
| | | public boolean equals(Object o) |
| | | public final boolean equals(Object o) |
| | | { |
| | | if (o == null) |
| | | { |
| | |
| | | * @return A string representation of this attribute syntax in the |
| | | * format defined in RFC 2252. |
| | | */ |
| | | public String toString() |
| | | public final String toString() |
| | | { |
| | | StringBuilder buffer = new StringBuilder(); |
| | | toString(buffer); |
| | |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | public void toString(StringBuilder buffer) |
| | | public final void toString(StringBuilder buffer) |
| | | { |
| | | buffer.append("( "); |
| | | buffer.append(getOID()); |
| | |
| | | * |
| | | * @param <T> Decode the attribute value to an object of this type. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public interface AttributeValueDecoder<T> |
| | | { |
| | | /** |
| | |
| | | * This class defines the set of methods and structures that must be |
| | | * implemented for a Directory Server backend. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class Backend |
| | | { |
| | | // The backend that holds a portion of the DIT that is |
| | |
| | | /** |
| | | * Creates a new backend with the provided information. All backend |
| | | * implementations must implement a default constructor that use |
| | | * <CODE>super()</CODE> to invoke this constructor. |
| | | * {@code super} to invoke this constructor. |
| | | */ |
| | | protected Backend() |
| | | { |
| | |
| | | * accessed by the Directory Server but managed through some other |
| | | * means). |
| | | * |
| | | * @return <CODE>true</CODE> if the data associated with this |
| | | * backend may be considered local, or <CODE>false</CODE> |
| | | * if it is remote. |
| | | * @return {@code true} if the data associated with this backend |
| | | * may be considered local, or {@code false} if it is |
| | | * remote. |
| | | */ |
| | | public abstract boolean isLocal(); |
| | | |
| | |
| | | * |
| | | * @param entryDN The distinguished name of the entry to retrieve. |
| | | * |
| | | * @return The requested entry, or <CODE>null</CODE> if the entry |
| | | * does not exist. |
| | | * @return The requested entry, or {@code null} if the entry does |
| | | * not exist. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | | * retrieve the entry. |
| | |
| | | /** |
| | | * Indicates whether an entry with the specified DN exists in the |
| | | * backend. The default implementation obtains a read lock and calls |
| | | * <CODE>getEntry</CODE>, but backend implementations may override |
| | | * this with a more efficient version that does not require a lock. |
| | | * The caller is not required to hold any locks on the specified DN. |
| | | * {@code getEntry}, but backend implementations may override this |
| | | * with a more efficient version that does not require a lock. The |
| | | * caller is not required to hold any locks on the specified DN. |
| | | * |
| | | * @param entryDN The DN of the entry for which to determine |
| | | * existence. |
| | | * |
| | | * @return <CODE>true</CODE> if the specified entry exists in this |
| | | * backend, or <CODE>false</CODE> if it does not. |
| | | * @return {@code true} if the specified entry exists in this |
| | | * backend, or {@code false} if it does not. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | | * make the determination. |
| | |
| | | * |
| | | * @param entry The entry to add to this backend. |
| | | * @param addOperation The add operation with which the new entry |
| | | * is associated. This may be |
| | | * <CODE>null</CODE> for adds performed |
| | | * internally. |
| | | * is associated. This may be {@code null} |
| | | * for adds performed internally. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | | * add the entry. |
| | |
| | | * backend. |
| | | * @param deleteOperation The delete operation with which this |
| | | * action is associated. This may be |
| | | * <CODE>null</CODE> for deletes performed |
| | | * {@code null} for deletes performed |
| | | * internally. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | |
| | | * existing entry with the same DN. |
| | | * @param modifyOperation The modify operation with which this |
| | | * action is associated. This may be |
| | | * <CODE>null</CODE> for modifications |
| | | * performed internally. |
| | | * {@code null} for modifications performed |
| | | * internally. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | | * replace the entry. |
| | |
| | | * @param entry The new content to use for the entry. |
| | | * @param modifyDNOperation The modify DN operation with which |
| | | * this action is associated. This may |
| | | * be <CODE>null</CODE> |
| | | * for modify DN operations performed |
| | | * internally. |
| | | * be {@code null} for modify DN |
| | | * operations performed internally. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while trying to |
| | | * perform the rename. |
| | |
| | | /** |
| | | * Processes the specified search in this backend. Matching entries |
| | | * should be provided back to the core server using the |
| | | * <CODE>SearchOperation.returnEntry</CODE> method. The caller is |
| | | * not required to have any locks when calling this operation. |
| | | * {@code SearchOperation.returnEntry} method. The caller is not |
| | | * required to have any locks when calling this operation. |
| | | * |
| | | * @param searchOperation The search operation to be processed. |
| | | * |
| | |
| | | * Indicates whether this backend provides a mechanism to export the |
| | | * data it contains to an LDIF file. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend provides an LDIF |
| | | * export mechanism, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this backend provides an LDIF export |
| | | * mechanism, or {@code false} if not. |
| | | */ |
| | | public abstract boolean supportsLDIFExport(); |
| | | |
| | |
| | | |
| | | /** |
| | | * Exports the contents of this backend to LDIF. This method should |
| | | * only be called if <CODE>supportsLDIFExport</CODE> returns |
| | | * <CODE>true</CODE>. Note that the server will not explicitly |
| | | * only be called if {@code supportsLDIFExport} returns |
| | | * {@code true}. Note that the server will not explicitly |
| | | * initialize this backend before calling this method. |
| | | * |
| | | * @param exportConfig The configuration to use when performing |
| | |
| | | * Indicates whether this backend provides a mechanism to import its |
| | | * data from an LDIF file. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend provides an LDIF |
| | | * import mechanism, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this backend provides an LDIF import |
| | | * mechanism, or {@code false} if not. |
| | | */ |
| | | public abstract boolean supportsLDIFImport(); |
| | | |
| | |
| | | |
| | | /** |
| | | * Imports information from an LDIF file into this backend. This |
| | | * method should only be called if <CODE>supportsLDIFImport</CODE> |
| | | * returns <CODE>true</CODE>. Note that the server will not |
| | | * explicitly initialize this backend before calling this method. |
| | | * method should only be called if {@code supportsLDIFImport} |
| | | * returns {@code true}. Note that the server will not explicitly |
| | | * initialize this backend before calling this method. |
| | | * |
| | | * @param importConfig The configuration to use when performing |
| | | * the import. |
| | |
| | | * Indicates whether this backend provides a backup mechanism of any |
| | | * kind. This method is used by the backup process when backing up |
| | | * all backends to determine whether this backend is one that should |
| | | * be skipped. It should only return <CODE>true</CODE> for backends |
| | | * that it is not possible to archive directly (e.g., those that |
| | | * don't store their data locally, but rather pass through requests |
| | | * to some other repository). |
| | | * be skipped. It should only return {@code true} for backends that |
| | | * it is not possible to archive directly (e.g., those that don't |
| | | * store their data locally, but rather pass through requests to |
| | | * some other repository). |
| | | * |
| | | * @return <CODE>true</CODE> if this backend provides any kind of |
| | | * backup mechanism, or <CODE>false</CODE> if it does not. |
| | | * @return {@code true} if this backend provides any kind of backup |
| | | * mechanism, or {@code false} if it does not. |
| | | */ |
| | | public abstract boolean supportsBackup(); |
| | | |
| | |
| | | * explaining why the requested backup is |
| | | * not supported. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend provides a mechanism |
| | | * for performing backups with the provided configuration, |
| | | * or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this backend provides a mechanism for |
| | | * performing backups with the provided configuration, or |
| | | * {@code false} if not. |
| | | */ |
| | | public abstract boolean supportsBackup(BackupConfig backupConfig, |
| | | StringBuilder unsupportedReason); |
| | |
| | | /** |
| | | * Creates a backup of the contents of this backend in a form that |
| | | * may be restored at a later date if necessary. This method should |
| | | * only be called if <CODE>supportsBackup</CODE> returns |
| | | * <CODE>true</CODE>. Note that the server will not explicitly |
| | | * initialize this backend before calling this method. |
| | | * only be called if {@code supportsBackup} returns {@code true}. |
| | | * Note that the server will not explicitly initialize this backend |
| | | * before calling this method. |
| | | * |
| | | * @param backupConfig The configuration to use when performing |
| | | * the backup. |
| | |
| | | * Indicates whether this backend provides a mechanism to restore a |
| | | * backup. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend provides a mechanism |
| | | * for restoring backups, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this backend provides a mechanism for |
| | | * restoring backups, or {@code false} if not. |
| | | */ |
| | | public abstract boolean supportsRestore(); |
| | | |
| | |
| | | |
| | | /** |
| | | * Restores a backup of the contents of this backend. This method |
| | | * should only be called if <CODE>supportsRestore</CODE> returns |
| | | * <CODE>true</CODE>. Note that the server will not explicitly |
| | | * should only be called if {@code supportsRestore} returns |
| | | * {@code true}. Note that the server will not explicitly |
| | | * initialize this backend before calling this method. |
| | | * |
| | | * @param restoreConfig The configuration to use when performing |
| | |
| | | * |
| | | * @return The unique identifier for this backend. |
| | | */ |
| | | public String getBackendID() |
| | | public final String getBackendID() |
| | | { |
| | | return backendID; |
| | | } |
| | |
| | | * |
| | | * @param backendID The unique identifier for this backend. |
| | | */ |
| | | public void setBackendID(String backendID) |
| | | public final void setBackendID(String backendID) |
| | | { |
| | | this.backendID = backendID; |
| | | } |
| | |
| | | /** |
| | | * Indicates whether this backend holds private data or user data. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend holds private data, or |
| | | * <CODE>false</CODE> if it holds user data. |
| | | * @return {@code true} if this backend holds private data, or |
| | | * {@code false} if it holds user data. |
| | | */ |
| | | public boolean isPrivateBackend() |
| | | public final boolean isPrivateBackend() |
| | | { |
| | | return isPrivateBackend; |
| | | } |
| | |
| | | * @param isPrivateBackend Specifies whether this backend holds |
| | | * private data or user data. |
| | | */ |
| | | public void setPrivateBackend(boolean isPrivateBackend) |
| | | public final void setPrivateBackend(boolean isPrivateBackend) |
| | | { |
| | | this.isPrivateBackend = isPrivateBackend; |
| | | } |
| | |
| | | * |
| | | * @return The writability mode for this backend. |
| | | */ |
| | | public WritabilityMode getWritabilityMode() |
| | | public final WritabilityMode getWritabilityMode() |
| | | { |
| | | return writabilityMode; |
| | | } |
| | |
| | | * |
| | | * @param writabilityMode The writability mode for this backend. |
| | | */ |
| | | public void setWritabilityMode(WritabilityMode writabilityMode) |
| | | public final void setWritabilityMode( |
| | | WritabilityMode writabilityMode) |
| | | { |
| | | if (writabilityMode == null) |
| | | { |
| | |
| | | * @return The backend monitor that is associated with this |
| | | * backend, or {@code null} if none has been assigned. |
| | | */ |
| | | public BackendMonitor getBackendMonitor() |
| | | public final BackendMonitor getBackendMonitor() |
| | | { |
| | | return backendMonitor; |
| | | } |
| | |
| | | * |
| | | * @param backendMonitor The backend monitor for this backend. |
| | | */ |
| | | public void setBackendMonitor(BackendMonitor backendMonitor) |
| | | public final void setBackendMonitor(BackendMonitor backendMonitor) |
| | | { |
| | | this.backendMonitor = backendMonitor; |
| | | } |
| | |
| | | /** |
| | | * Retrieves the parent backend for this backend. |
| | | * |
| | | * @return The parent backend for this backend, or |
| | | * <CODE>null</CODE> if there is none. |
| | | * @return The parent backend for this backend, or {@code null} if |
| | | * there is none. |
| | | */ |
| | | public Backend getParentBackend() |
| | | public final Backend getParentBackend() |
| | | { |
| | | return parentBackend; |
| | | } |
| | |
| | | * |
| | | * @param parentBackend The parent backend for this backend. |
| | | */ |
| | | public void setParentBackend(Backend parentBackend) |
| | | public final void setParentBackend(Backend parentBackend) |
| | | { |
| | | synchronized (this) |
| | | { |
| | |
| | | * @return The set of subordinate backends for this backend, or an |
| | | * empty array if none exist. |
| | | */ |
| | | public Backend[] getSubordinateBackends() |
| | | public final Backend[] getSubordinateBackends() |
| | | { |
| | | return subordinateBackends; |
| | | } |
| | |
| | | * @param subordinateBackends The set of subordinate backends for |
| | | * this backend. |
| | | */ |
| | | public void setSubordinateBackends(Backend[] subordinateBackends) |
| | | public final void setSubordinateBackends( |
| | | Backend[] subordinateBackends) |
| | | { |
| | | synchronized (this) |
| | | { |
| | |
| | | * @param subSuffixDN The DN of the sub-suffix for which to make |
| | | * the determination. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend has a subordinate |
| | | * backend registered with the provided base DN, or |
| | | * <CODE>false</CODE> if it does not. |
| | | * @return {@code true} if this backend has a subordinate backend |
| | | * registered with the provided base DN, or {@code false} |
| | | * if it does not. |
| | | */ |
| | | public boolean hasSubSuffix(DN subSuffixDN) |
| | | public final boolean hasSubSuffix(DN subSuffixDN) |
| | | { |
| | | Backend[] subBackends = subordinateBackends; |
| | | for (Backend b : subBackends) |
| | |
| | | * @throws ConfigException If the sub-suffix exists but it is not |
| | | * possible to remove it for some reason. |
| | | */ |
| | | public void removeSubSuffix(DN subSuffixDN, DN parentDN) |
| | | public final void removeSubSuffix(DN subSuffixDN, DN parentDN) |
| | | throws ConfigException |
| | | { |
| | | synchronized (this) |
| | |
| | | * subordinate backends for this |
| | | * backend. |
| | | */ |
| | | public void addSubordinateBackend(Backend subordinateBackend) |
| | | public final void addSubordinateBackend(Backend subordinateBackend) |
| | | { |
| | | synchronized (this) |
| | | { |
| | |
| | | * subordinate backends for this |
| | | * backend. |
| | | */ |
| | | public void removeSubordinateBackend(Backend subordinateBackend) |
| | | public final void removeSubordinateBackend( |
| | | Backend subordinateBackend) |
| | | { |
| | | synchronized (this) |
| | | { |
| | |
| | | * @param entryDN The DN of the entry for which to make the |
| | | * determination. |
| | | * |
| | | * @return <CODE>true</CODE> if this backend handles operations for |
| | | * the provided entry, or <CODE>false</CODE> if it does |
| | | * not. |
| | | * @return {@code true} if this backend handles operations for the |
| | | * provided entry, or {@code false} if it does not. |
| | | */ |
| | | public boolean handlesEntry(DN entryDN) |
| | | public final boolean handlesEntry(DN entryDN) |
| | | { |
| | | DN[] baseDNs = getBaseDNs(); |
| | | for (DN dn : baseDNs) |
| | |
| | | * @param excludeDNs The set of DNs that should be excluded from |
| | | * the backend. |
| | | * |
| | | * @return <CODE>true</CODE> if the backend should handle |
| | | * operations for the provided entry, or <CODE>false</CODE> |
| | | * if it does not. |
| | | * @return {@code true} if the backend should handle operations for |
| | | * the provided entry, or {@code false} if it does not. |
| | | */ |
| | | public static final boolean handlesEntry(DN entryDN, |
| | | List<DN> baseDNs, |
| | |
| | | * components to perform any processing that they might find necessary |
| | | * whenever a backend is initialized and/or finalized. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface BackendInitializationListener |
| | | { |
| | | /** |
| | |
| | | * will only be invoked for the backup task and not for offline backup |
| | | * processing. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface BackupTaskListener |
| | | { |
| | | /** |
| | |
| | | * @param <T> The type of configuration handled by this certificate |
| | | * mapper. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class CertificateMapper |
| | | <T extends CertificateMapperCfg> |
| | | { |
| | |
| | | * as appropriate. |
| | | * |
| | | * @return The entry for the user to whom the mapping was |
| | | * established, or <CODE>null</CODE> if no mapping was |
| | | * established, or {@code null} if no mapping was |
| | | * established and no special message is required to send |
| | | * back to the client. |
| | | * |
| | |
| | | * notified of changes to the configuration data just as easily as it |
| | | * can be used for any other entry anywhere in the server, components |
| | | * that are only interested in being notified of changes to the server |
| | | * configuration should use the <CODE>ConfigurableComponent</CODE>, |
| | | * <CODE>ConfigAddListener</CODE>, <CODE>ConfigDeleteListener</CODE>, |
| | | * and/or the <CODE>ConfigChangeListener</CODE> interfaces instead. |
| | | * They will be more efficient overall because they will only be |
| | | * invoked for operations in the server configuration, and then only |
| | | * for the specific entries with which the component has registered. |
| | | * configuration should use the {@code ConfigAddListener}, |
| | | * {@code ConfigDeleteListener}, and/or the |
| | | * {@code ConfigChangeListener} interfaces instead. They will be more |
| | | * efficient overall because they will only be invoked for operations |
| | | * in the server configuration, and then only for the specific entries |
| | | * with which the component has registered. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ChangeNotificationListener |
| | | { |
| | | /** |
| | |
| | | * This class defines the set of methods and structures that must be |
| | | * implemented by a Directory Server client connection. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class ClientConnection |
| | | { |
| | | /** |
| | |
| | | * deregistered with the {@code AuthenticatedUsers} manager, and |
| | | * will then invoke the {@code finalizeClientConnection} method. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true, |
| | | notes="This method should only be invoked by connection " + |
| | | "handlers.") |
| | | protected final void finalizeConnectionInternal() |
| | | { |
| | | if (finalized) |
| | |
| | | * then it will be called when the client connection object is |
| | | * finalized by the garbage collector. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | protected void finalizeClientConnection() |
| | | { |
| | | // No implementation is required by default. |
| | |
| | | * @return The time that this connection was established, measured |
| | | * in the number of milliseconds since January 1, 1970 UTC. |
| | | */ |
| | | public long getConnectTime() |
| | | public final long getConnectTime() |
| | | { |
| | | return connectTime; |
| | | } |
| | |
| | | * @return A string representation of the time that this connection |
| | | * was established. |
| | | */ |
| | | public String getConnectTimeString() |
| | | public final String getConnectTimeString() |
| | | { |
| | | return connectTimeString; |
| | | } |
| | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the <CODE>java.net.InetAddress</CODE> associated with |
| | | * the remote client system. |
| | | * Retrieves the {@code java.net.InetAddress} associated with the |
| | | * remote client system. |
| | | * |
| | | * @return The <CODE>java.net.InetAddress</CODE> associated with |
| | | * the remote client system. It may be <CODE>null</CODE> |
| | | * if the client is not connected over an IP-based |
| | | * connection. |
| | | * @return The {@code java.net.InetAddress} associated with the |
| | | * remote client system. It may be {@code null} if the |
| | | * client is not connected over an IP-based connection. |
| | | */ |
| | | public abstract InetAddress getRemoteAddress(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the <CODE>java.net.InetAddress</CODE> for the Directory |
| | | * Retrieves the {@code java.net.InetAddress} for the Directory |
| | | * Server system to which the client has established the connection. |
| | | * |
| | | * @return The <CODE>java.net.InetAddress</CODE> for the Directory |
| | | * @return The {@code java.net.InetAddress} for the Directory |
| | | * Server system to which the client has established the |
| | | * connection. It may be <CODE>null</CODE> if the client |
| | | * is not connected over an IP-based connection. |
| | | * connection. It may be {@code null} if the client is not |
| | | * connected over an IP-based connection. |
| | | */ |
| | | public abstract InetAddress getLocalAddress(); |
| | | |
| | |
| | | * Indicates whether this client connection is currently using a |
| | | * secure mechanism to communicate with the server. Note that this |
| | | * may change over time based on operations performed by the client |
| | | * or server (e.g., it may go from <CODE>false</CODE> to |
| | | * <CODE>true</CODE> if the client uses the StartTLS extended |
| | | * operation). |
| | | * or server (e.g., it may go from {@code false} to {@code true} if |
| | | * if the client uses the StartTLS extended operation). |
| | | * |
| | | * @return <CODE>true</CODE> if the client connection is currently |
| | | * using a secure mechanism to communicate with the server, |
| | | * or <CODE>false</CODE> if not. |
| | | * @return {@code true} if the client connection is currently using |
| | | * a secure mechanism to communicate with the server, or |
| | | * {@code false} if not. |
| | | */ |
| | | public abstract boolean isSecure(); |
| | | |
| | |
| | | * |
| | | * @return The human-readable name of the security mechanism that |
| | | * is used to protect communication with this client, or |
| | | * <CODE>null</CODE> if no security is in place. |
| | | * {@code null} if no security is in place. |
| | | */ |
| | | public abstract String getSecurityMechanism(); |
| | | |
| | |
| | | * @param buffer The byte buffer containing the data available for |
| | | * reading. |
| | | * |
| | | * @return <CODE>true</CODE> if all the data in the provided buffer |
| | | * was processed and the client connection can remain |
| | | * established, or <CODE>false</CODE> if a decoding error |
| | | * @return {@code true} if all the data in the provided buffer was |
| | | * processed and the client connection can remain |
| | | * established, or {@code false} if a decoding error |
| | | * occurred and requests from this client should no longer |
| | | * be processed. Note that if this method does return |
| | | * <CODE>false</CODE>, then it must have already |
| | | * disconnected the client. |
| | | * {@code false}, then it must have already disconnected |
| | | * the client. |
| | | */ |
| | | public abstract boolean processDataRead(ByteBuffer buffer); |
| | | |
| | |
| | | * @param searchReference The search result reference to be sent |
| | | * to the client. |
| | | * |
| | | * @return <CODE>true</CODE> if the client is able to accept |
| | | * referrals, or <CODE>false</CODE> if the client cannot |
| | | * handle referrals and no more attempts should be made to |
| | | * send them for the associated search operation. |
| | | * @return {@code true} if the client is able to accept referrals, |
| | | * or {@code false} if the client cannot handle referrals |
| | | * and no more attempts should be made to send them for the |
| | | * associated search operation. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while attempting |
| | | * to send the reference to the client |
| | |
| | | * @param intermediateResponse The intermediate response message |
| | | * to be sent. |
| | | * |
| | | * @return <CODE>true</CODE> if processing on the associated |
| | | * operation should continue, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if processing on the associated operation |
| | | * should continue, or {@code false} if not. |
| | | */ |
| | | public final boolean sendIntermediateResponse( |
| | | IntermediateResponse intermediateResponse) |
| | |
| | | * @param intermediateResponse The intermediate response message |
| | | * to be sent. |
| | | * |
| | | * @return <CODE>true</CODE> if processing on the associated |
| | | * operation should continue, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if processing on the associated operation |
| | | * should continue, or {@code false} if not. |
| | | */ |
| | | protected abstract boolean |
| | | sendIntermediateResponseMessage( |
| | |
| | | * for all protocols or under all circumstances. Also note that |
| | | * when attempting to disconnect a client connection as a part of |
| | | * operation processing (e.g., within a plugin or other extension), |
| | | * the <CODE>disconnectClient</CODE> method within that operation |
| | | * should be called rather than invoking this method directly. |
| | | * the {@code disconnectClient} method within that operation should |
| | | * be called rather than invoking this method directly. |
| | | * <BR><BR> |
| | | * All subclasses must invoke the {@code finalizeConnectionInternal} |
| | | * method during the course of processing this method. |
| | |
| | | * notification to the client that the |
| | | * connection will be closed. |
| | | * @param message The message to send to the client. It |
| | | * may be <CODE>null</CODE> if no |
| | | * notification is to be sent. |
| | | * may be {@code null} if no notification |
| | | * is to be sent. |
| | | */ |
| | | public abstract void disconnect(DisconnectReason disconnectReason, |
| | | boolean sendNotification, |
| | |
| | | * connection. If so, then no new operations should be allowed |
| | | * until the bind has completed. |
| | | * |
| | | * @return <CODE>true</CODE> if a bind operation is in progress on |
| | | * this connection, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if a bind operation is in progress on this |
| | | * connection, or {@code false} if not. |
| | | */ |
| | | public boolean bindInProgress() |
| | | { |
| | |
| | | * must change their password before they will be allowed to do |
| | | * anything else. |
| | | * |
| | | * @return <CODE>true</CODE> if the user associated with this |
| | | * client connection must change their password before they |
| | | * will be allowed to do anything else, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the user associated with this client |
| | | * connection must change their password before they will |
| | | * be allowed to do anything else, or {@code false} if not. |
| | | */ |
| | | public boolean mustChangePassword() |
| | | public final boolean mustChangePassword() |
| | | { |
| | | if (authenticationInfo == null) |
| | | { |
| | |
| | | * change their password before they |
| | | * will be allowed to do anything else. |
| | | */ |
| | | public void setMustChangePassword(boolean mustChangePassword) |
| | | public final void setMustChangePassword(boolean mustChangePassword) |
| | | { |
| | | if (authenticationInfo == null) |
| | | { |
| | |
| | | * @param messageID The message ID of the operation to retrieve. |
| | | * |
| | | * @return The operation in progress with the specified message ID, |
| | | * or <CODE>null</CODE> if no such operation could be |
| | | * found. |
| | | * or {@code null} if no such operation could be found. |
| | | */ |
| | | public abstract AbstractOperation |
| | | getOperationInProgress(int messageID); |
| | |
| | | * @param messageID The message ID of the operation to remove from |
| | | * the set of operations in progress. |
| | | * |
| | | * @return <CODE>true</CODE> if the operation was found and removed |
| | | * from the set of operations in progress, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the operation was found and removed from |
| | | * the set of operations in progress, or {@code false} if |
| | | * not. |
| | | */ |
| | | public abstract boolean removeOperationInProgress(int messageID); |
| | | |
| | |
| | | * @return The set of persistent searches registered for this |
| | | * client. |
| | | */ |
| | | public CopyOnWriteArrayList<PersistentSearch> |
| | | getPersistentSearches() |
| | | public final CopyOnWriteArrayList<PersistentSearch> |
| | | getPersistentSearches() |
| | | { |
| | | return persistentSearches; |
| | | } |
| | |
| | | /** |
| | | * Registers the provided persistent search for this client. Note |
| | | * that this should only be called by |
| | | * <CODE>DirectoryServer.registerPersistentSearch</CODE> and not |
| | | * through any other means. |
| | | * {@code DirectoryServer.registerPersistentSearch} and not through |
| | | * any other means. |
| | | * |
| | | * @param persistentSearch The persistent search to register for |
| | | * this client. |
| | | */ |
| | | public void registerPersistentSearch(PersistentSearch |
| | | persistentSearch) |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public final void registerPersistentSearch(PersistentSearch |
| | | persistentSearch) |
| | | { |
| | | persistentSearches.add(persistentSearch); |
| | | } |
| | |
| | | /** |
| | | * Deregisters the provided persistent search for this client. Note |
| | | * that this should only be called by |
| | | * <CODE>DirectoryServer.deregisterPersistentSearch</CODE> and not |
| | | * {@code DirectoryServer.deregisterPersistentSearch} and not |
| | | * through any other means. |
| | | * |
| | | * @param persistentSearch The persistent search to deregister for |
| | | * this client. |
| | | */ |
| | | public void deregisterPersistentSearch(PersistentSearch |
| | | persistentSearch) |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public final void deregisterPersistentSearch(PersistentSearch |
| | | persistentSearch) |
| | | { |
| | | persistentSearches.remove(persistentSearch); |
| | | } |
| | |
| | | * @param authenticationInfo Information about the authentication |
| | | * that has been performed for this |
| | | * connection. It should not be |
| | | * <CODE>null</CODE>. |
| | | * {@code null}. |
| | | */ |
| | | public void setAuthenticationInfo(AuthenticationInfo |
| | | authenticationInfo) |
| | |
| | | * existing entry. It may optionally have a |
| | | * different DN than the old entry. |
| | | */ |
| | | public void updateAuthenticationInfo(Entry oldEntry, Entry newEntry) |
| | | public final void updateAuthenticationInfo(Entry oldEntry, |
| | | Entry newEntry) |
| | | { |
| | | Entry authNEntry = authenticationInfo.getAuthenticationEntry(); |
| | | Entry authZEntry = authenticationInfo.getAuthorizationEntry(); |
| | |
| | | * |
| | | * @return the network group attached to the connection |
| | | */ |
| | | public NetworkGroup getNetworkGroup() |
| | | public final NetworkGroup getNetworkGroup() |
| | | { |
| | | return networkGroup; |
| | | } |
| | |
| | | * @param networkGroup the network group to which the |
| | | * connections belongs to |
| | | */ |
| | | public void setNetworkGroup (NetworkGroup networkGroup) |
| | | public final void setNetworkGroup (NetworkGroup networkGroup) |
| | | { |
| | | this.networkGroup = networkGroup; |
| | | } |
| | |
| | | * component should implement if it wishes to be able to receive |
| | | * notification of new entries added below a configuration entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ConfigAddListener |
| | | { |
| | | /** |
| | |
| | | * explaining why the proposed entry is |
| | | * not acceptable. |
| | | * |
| | | * @return <CODE>true</CODE> if the proposed entry contains an |
| | | * acceptable configuration, or <CODE>false</CODE> if it |
| | | * does not. |
| | | * @return {@code true} if the proposed entry contains an |
| | | * acceptable configuration, or {@code false} if it does |
| | | * not. |
| | | */ |
| | | public boolean configAddIsAcceptable(ConfigEntry configEntry, |
| | | MessageBuilder unacceptableReason); |
| | |
| | | * component should implement if it wishes to be able to receive |
| | | * notification of changes to a configuration entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ConfigChangeListener |
| | | { |
| | | /** |
| | |
| | | * explaining why the proposed change is |
| | | * not acceptable. |
| | | * |
| | | * @return <CODE>true</CODE> if the proposed entry contains an |
| | | * acceptable configuration, or <CODE>false</CODE> if it |
| | | * does not. |
| | | * @return {@code true} if the proposed entry contains an |
| | | * acceptable configuration, or {@code false} if it does |
| | | * not. |
| | | */ |
| | | public boolean configChangeIsAcceptable(ConfigEntry configEntry, |
| | | MessageBuilder unacceptableReason); |
| | |
| | | * component should implement if it wishes to be able to receive |
| | | * notification if entries below a configuration entry are removed. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ConfigDeleteListener |
| | | { |
| | | /** |
| | |
| | | * explaining why the proposed delete is |
| | | * not acceptable. |
| | | * |
| | | * @return <CODE>true</CODE> if the proposed entry may be removed |
| | | * from the configuration, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if the proposed entry may be removed from |
| | | * the configuration, or {@code false} if not. |
| | | */ |
| | | public boolean configDeleteIsAcceptable(ConfigEntry configEntry, |
| | | MessageBuilder unacceptableReason); |
| | |
| | | * This class defines the set of methods and structures that must be |
| | | * implemented by a Directory Server configuration handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class ConfigHandler |
| | | extends Backend |
| | | { |
| | |
| | | * The type of connection handler configuration handled by |
| | | * this connection handler implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class ConnectionHandler |
| | | <T extends ConnectionHandlerCfg> |
| | | extends DirectoryThread { |
| | | |
| | | <T extends ConnectionHandlerCfg> |
| | | extends DirectoryThread |
| | | { |
| | | // The monitor associated with this connection handler. |
| | | private ConnectionHandlerMonitor monitor; |
| | | |
| | |
| | | * that some connection handler implementations may not have any way |
| | | * to continue processing requests from existing connections, in |
| | | * which case they should always be closed regardless of the value |
| | | * of the <CODE>closeConnections</CODE> flag. |
| | | * of the {@code closeConnections} flag. |
| | | * |
| | | * @param finalizeReason |
| | | * The reason that this connection handler should be |
| | |
| | | * @return The monitor instance for this connection handler, or |
| | | * {@code null} if none has been provided. |
| | | */ |
| | | public ConnectionHandlerMonitor getConnectionHandlerMonitor() |
| | | public final ConnectionHandlerMonitor getConnectionHandlerMonitor() |
| | | { |
| | | return monitor; |
| | | } |
| | |
| | | * @param monitor The monitor instance for this connection |
| | | * handler. |
| | | */ |
| | | public void setConnectionHandlerMonitor( |
| | | ConnectionHandlerMonitor monitor) |
| | | public final void setConnectionHandlerMonitor( |
| | | ConnectionHandlerMonitor monitor) |
| | | { |
| | | this.monitor = monitor; |
| | | } |
| | |
| | | * data for communication with clients over a secure channel (e.g., |
| | | * SSL/TLS, Kerberos confidentiality, etc.). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class ConnectionSecurityProvider |
| | | { |
| | | /** |
| | |
| | | * Indicates whether client connections using this connection |
| | | * security provider should be considered secure. |
| | | * |
| | | * @return <CODE>true</CODE> if client connections using this |
| | | * connection security provider should be considered |
| | | * secure, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if client connections using this connection |
| | | * security provider should be considered secure, or |
| | | * {@code false} if not. |
| | | */ |
| | | public abstract boolean isSecure(); |
| | | |
| | |
| | | * negotiation in the process. Whenever any clear-text data has |
| | | * been obtained, then the connection security provider should make |
| | | * that available to the client by calling the |
| | | * <CODE>ClientConnection.processDataRead</CODE> method. |
| | | * {@code ClientConnection.processDataRead} method. |
| | | * |
| | | * @return <CODE>true</CODE> if all the data in the provided buffer |
| | | * was processed and the client connection can remain |
| | | * established, or <CODE>false</CODE> if a decoding error |
| | | * @return {@code true} if all the data in the provided buffer was |
| | | * processed and the client connection can remain |
| | | * established, or {@code false} if a decoding error |
| | | * occurred and requests from this client should no longer |
| | | * be processed. Note that if this method does return |
| | | * <CODE>false</CODE>, then it must have already |
| | | * disconnected the client. |
| | | * {@code false}, then it must have already disconnected |
| | | * the client. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while reading |
| | | * data from the client. |
| | |
| | | * Writes the data contained in the provided clear-text buffer to |
| | | * the client, performing any necessary encoding in the process. It |
| | | * must be capable of dealing with input buffers that are larger |
| | | * than the value returned by the <CODE>getClearBufferSize</CODE> |
| | | * method. When this method returns, the provided buffer should be |
| | | * in its original state with regard to the position and limit. |
| | | * than the value returned by the {@code getClearBufferSize} method. |
| | | * When this method returns, the provided buffer should be in its |
| | | * original state with regard to the position and limit. |
| | | * |
| | | * @param clearData The buffer containing the clear-text data to |
| | | * write to the client. |
| | | * |
| | | * @return <CODE>true</CODE> if all the data in the provided buffer |
| | | * was written to the client and the connection may remain |
| | | * established, or <CODE>false</CODE> if a problem occurred |
| | | * and the client connection is no longer valid. Note that |
| | | * if this method does return <CODE>false</CODE>, then it |
| | | * must have already disconnected the client. |
| | | * @return {@code true} if all the data in the provided buffer was |
| | | * written to the client and the connection may remain |
| | | * established, or {@code false} if a problem occurred and |
| | | * the client connection is no longer valid. Note that if |
| | | * this method does return {@code false}, then it must have |
| | | * already disconnected the client. |
| | | */ |
| | | public abstract boolean writeData(ByteBuffer clearData); |
| | | } |
| | |
| | | * @param <T> The type of debug log publisher configuration handled |
| | | * by this log publisher implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class DebugLogPublisher |
| | | <T extends DebugLogPublisherCfg> |
| | | { |
| | |
| | | * or {@code null} if no method-level tracing is configured |
| | | * for the scope. |
| | | */ |
| | | public Map<String,TraceSettings> getMethodSettings(String className) |
| | | public final Map<String,TraceSettings> getMethodSettings( |
| | | String className) |
| | | { |
| | | if(methodTraceSettings == null) |
| | | { |
| | |
| | | * |
| | | * @return The current trace settings for the class. |
| | | */ |
| | | public TraceSettings getClassSettings(String className) |
| | | public final TraceSettings getClassSettings(String className) |
| | | { |
| | | TraceSettings settings = TraceSettings.DISABLED; |
| | | |
| | |
| | | * global scope. |
| | | * @param settings The trace settings for the specified scope. |
| | | */ |
| | | public void addTraceSettings(String scope, TraceSettings settings) |
| | | public final void addTraceSettings(String scope, |
| | | TraceSettings settings) |
| | | { |
| | | if (scope == null) { |
| | | setClassSettings(GLOBAL, settings); |
| | |
| | | * {@code null} if no trace setting is defined for that |
| | | * scope. |
| | | */ |
| | | public TraceSettings getTraceSettings(String scope) |
| | | public final TraceSettings getTraceSettings(String scope) |
| | | { |
| | | if (scope == null) { |
| | | if(classTraceSettings != null) |
| | |
| | | * {@code null} if no trace setting is defined for that |
| | | * scope. |
| | | */ |
| | | public TraceSettings removeTraceSettings(String scope) |
| | | public final TraceSettings removeTraceSettings(String scope) |
| | | { |
| | | TraceSettings removedSettings = null; |
| | | if (scope == null) { |
| | |
| | | * @param className The class name. |
| | | * @param settings The trace settings for the class. |
| | | */ |
| | | private synchronized void setClassSettings(String className, |
| | | TraceSettings settings) |
| | | private synchronized final void setClassSettings(String className, |
| | | TraceSettings settings) |
| | | { |
| | | if(classTraceSettings == null) classTraceSettings = |
| | | new HashMap<String, TraceSettings>(); |
| | |
| | | * @param methodName The method name. |
| | | * @param settings The trace settings for the method. |
| | | */ |
| | | private synchronized void setMethodSettings(String className, |
| | | String methodName, |
| | | TraceSettings settings) |
| | | private synchronized final void setMethodSettings(String className, |
| | | String methodName, |
| | | TraceSettings settings) |
| | | { |
| | | if (methodTraceSettings == null) methodTraceSettings = |
| | | new HashMap<String, Map<String, TraceSettings>>(); |
| | |
| | | * This interface must be implemented by all Directory Server |
| | | * components that interact with JMX in any way. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface DirectoryServerMBean |
| | | { |
| | | /** |
| | |
| | | * that task.</LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public class DirectoryThread |
| | | extends Thread |
| | | { |
| | |
| | | * of running a task. |
| | | * |
| | | * @return The task with which this thread is associated, or |
| | | * <CODE>null</CODE> if there is none. |
| | | * {@code null} if there is none. |
| | | */ |
| | | public Task getAssociatedTask() |
| | | { |
| | |
| | | |
| | | /** |
| | | * Sets the task with which this thread is associated. It may be |
| | | * <CODE>null</CODE> to indicate that it is not associated with any |
| | | * task. |
| | | * {@code null} to indicate that it is not associated with any task. |
| | | * |
| | | * @param task The task with which this thread is associated. |
| | | */ |
| | |
| | | |
| | | import java.util.List; |
| | | import java.util.HashSet; |
| | | import java.util.Set; |
| | | import java.util.concurrent.locks.Lock; |
| | | |
| | | import org.opends.server.core.DirectoryServer; |
| | |
| | | * This class defines the set of methods that must be implemented by a |
| | | * Directory Server entry cache. Note that components accessing the |
| | | * entry cache must not depend on any particular behavior. For |
| | | * example, if a call is made to <CODE>putEntry</CODE> to store an |
| | | * entry in the cache, there is no guarantee that immediately calling |
| | | * <CODE>getEntry</CODE> will be able to retrieve it. There are |
| | | * several potential reasons for this, including: |
| | | * example, if a call is made to {@code putEntry} to store an entry in |
| | | * the cache, there is no guarantee that immediately calling |
| | | * {@code getEntry} will be able to retrieve it. There are several |
| | | * potential reasons for this, including: |
| | | * <UL> |
| | | * <LI>The entry may have been deleted or replaced by another thread |
| | | * between the <CODE>putEntry</CODE> and <CODE>getEntry</CODE> |
| | | * calls.</LI> |
| | | * between the {@code putEntry} and {@code getEntry} calls.</LI> |
| | | * <LI>The entry cache may implement a purging mechanism and the |
| | | * entry added may have been purged between the |
| | | * <CODE>putEntry</CODE> and <CODE>getEntry</CODE> calls.</LI> |
| | | * {@code putEntry} and {@code getEntry} calls.</LI> |
| | | * <LI>The entry cache may implement some kind of filtering |
| | | * mechanism to determine which entries to store, and entries |
| | | * not matching the appropriate criteria may not be stored.</LI> |
| | |
| | | * @param <T> The type of configuration handled by this entry |
| | | * cache. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true, |
| | | notes="Entry cache methods may only be invoked by backends") |
| | | public abstract class EntryCache |
| | | <T extends EntryCacheCfg> |
| | | implements BackendInitializationListener |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | | */ |
| | | private static final DebugTracer TRACER = getTracer(); |
| | | |
| | | |
| | | |
| | | // The set of filters that define the entries that should be |
| | | // excluded from the cache. |
| | | private Set<SearchFilter> excludeFilters = |
| | | new HashSet<SearchFilter>(0); |
| | | |
| | | // The set of filters that define the entries that should be |
| | | // included in the cache. |
| | | private Set<SearchFilter> includeFilters = |
| | | new HashSet<SearchFilter>(0); |
| | | |
| | | // The maximum length of time to try to obtain a lock before giving |
| | | // up. |
| | | private long lockTimeout = LockManager.DEFAULT_TIMEOUT; |
| | | |
| | | |
| | | |
| | | /** |
| | | * Default constructor which is implicitly called from all entry |
| | | * cache implementations. |
| | | */ |
| | |
| | | |
| | | |
| | | /** |
| | | * The tracer object for the debug logger. |
| | | */ |
| | | private static final DebugTracer TRACER = getTracer(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * The maximum length of time to try to obtain a lock |
| | | * before giving up. |
| | | */ |
| | | protected long lockTimeout; |
| | | |
| | | |
| | | |
| | | /** |
| | | * The set of filters that define the entries that should |
| | | * be excluded from the cache. |
| | | */ |
| | | protected HashSet<SearchFilter> excludeFilters; |
| | | |
| | | |
| | | |
| | | /** |
| | | * The set of filters that define the entries that should |
| | | * be included in the cache. |
| | | */ |
| | | protected HashSet<SearchFilter> includeFilters; |
| | | |
| | | |
| | | |
| | | /** |
| | | * Initializes this entry cache implementation so that it will be |
| | | * available for storing and retrieving entries. |
| | | * |
| | |
| | | * |
| | | * @param entryDN The DN for which to make the determination. |
| | | * |
| | | * @return <CODE>true</CODE> if the entry cache currently contains |
| | | * the entry with the specified DN, or <CODE>false</CODE> |
| | | * if not. |
| | | * @return {@code true} if the entry cache currently contains the |
| | | * entry with the specified DN, or {@code false} if not. |
| | | */ |
| | | public abstract boolean containsEntry(DN entryDN); |
| | | |
| | |
| | | * @param entryDN The DN of the entry to retrieve. |
| | | * |
| | | * @return The requested entry if it is present in the cache, or |
| | | * <CODE>null</CODE> if it is not present. |
| | | * {@code null} if it is not present. |
| | | */ |
| | | public abstract Entry getEntry(DN entryDN); |
| | | |
| | |
| | | * |
| | | * @param entryDN The DN of the entry to retrieve. |
| | | * @param lockType The type of lock to obtain (it may be |
| | | * <CODE>NONE</CODE>). |
| | | * {@code NONE}). |
| | | * @param lockList The list to which the obtained lock will be |
| | | * added (note that no lock will be added if the |
| | | * lock type was <CODE>NONE</CODE>). |
| | | * lock type was {@code NONE}). |
| | | * |
| | | * @return The requested entry if it is present in the cache, or |
| | | * <CODE>null</CODE> if it is not present. |
| | | * {@code null} if it is not present. |
| | | */ |
| | | public Entry getEntry(DN entryDN, |
| | | LockType lockType, |
| | |
| | | * @param entryID The entry ID within the provided backend for |
| | | * the specified entry. |
| | | * @param lockType The type of lock to obtain (it may be |
| | | * <CODE>NONE</CODE>). |
| | | * {@code NONE}). |
| | | * @param lockList The list to which the obtained lock will be |
| | | * added (note that no lock will be added if the |
| | | * lock type was <CODE>NONE</CODE>). |
| | | * lock type was {@code NONE}). |
| | | * |
| | | * @return The requested entry if it is present in the cache, or |
| | | * <CODE>null</CODE> if it is not present. |
| | | * {@code null} if it is not present. |
| | | */ |
| | | public Entry getEntry(Backend backend, long entryID, |
| | | LockType lockType, |
| | |
| | | * for which to retrieve the entry DN. |
| | | * |
| | | * @return The entry DN for the requested entry, or |
| | | * <CODE>null</CODE> if it is not present in the cache. |
| | | * {@code null} if it is not present in the cache. |
| | | */ |
| | | protected abstract DN getEntryDN(Backend backend, long entryID); |
| | | |
| | |
| | | * @param entryID The entry ID within the provided backend that |
| | | * uniquely identifies the specified entry. |
| | | * |
| | | * @return <CODE>false</CODE> if an existing entry or some other |
| | | * problem prevented the method from completing |
| | | * successfully, or <CODE>true</CODE> if there was no |
| | | * conflict and the entry was either stored or the cache |
| | | * determined that this entry should never be cached for |
| | | * some reason. |
| | | * @return {@code false} if an existing entry or some other problem |
| | | * prevented the method from completing successfully, or |
| | | * {@code true} if there was no conflict and the entry was |
| | | * either stored or the cache determined that this entry |
| | | * should never be cached for some reason. |
| | | */ |
| | | public abstract boolean putEntryIfAbsent(Entry entry, |
| | | Backend backend, |
| | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the maximum length of time in milliseconds to wait for |
| | | * a lock before giving up. |
| | | * |
| | | * @return The maximum length of time in milliseconds to wait for a |
| | | * lock before giving up. |
| | | */ |
| | | public long getLockTimeout() |
| | | { |
| | | return lockTimeout; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies the maximum length of time in milliseconds to wait for |
| | | * a lock before giving up. |
| | | * |
| | | * @param lockTimeout The maximum length of time in milliseconds |
| | | * to wait for a lock before giving up. |
| | | */ |
| | | public void setLockTimeout(long lockTimeout) |
| | | { |
| | | this.lockTimeout = lockTimeout; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the set of search filters that may be used to determine |
| | | * whether an entry should be excluded from the cache. |
| | | * |
| | | * @return The set of search filters that may be used to determine |
| | | * whether an entry should be excluded from the cache. |
| | | */ |
| | | public Set<SearchFilter> getExcludeFilters() |
| | | { |
| | | return excludeFilters; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies the set of search filters that may be used to determine |
| | | * whether an entry should be excluded from the cache. |
| | | * |
| | | * @param excludeFilters The set of search filters that may be |
| | | * used to determine whether an entry should |
| | | * be excluded from the cache. |
| | | */ |
| | | public void setExcludeFilters(Set<SearchFilter> excludeFilters) |
| | | { |
| | | if (excludeFilters == null) |
| | | { |
| | | this.excludeFilters = new HashSet<SearchFilter>(0); |
| | | } |
| | | else |
| | | { |
| | | this.excludeFilters = excludeFilters; |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the set of search filters that may be used to determine |
| | | * whether an entry should be included in the cache. |
| | | * |
| | | * @return The set of search filters that may be used to determine |
| | | * whether an entry should be included in the cache. |
| | | */ |
| | | public Set<SearchFilter> getIncludeFilters() |
| | | { |
| | | return includeFilters; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies the set of search filters that may be used to determine |
| | | * whether an entry should be included in the cache. |
| | | * |
| | | * @param includeFilters The set of search filters that may be |
| | | * used to determine whether an entry should |
| | | * be included in the cache. |
| | | */ |
| | | public void setIncludeFilters(Set<SearchFilter> includeFilters) |
| | | { |
| | | if (includeFilters == null) |
| | | { |
| | | this.includeFilters = new HashSet<SearchFilter>(0); |
| | | } |
| | | else |
| | | { |
| | | this.includeFilters = includeFilters; |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether the current set of exclude and include filters |
| | | * allow caching of the specified entry. |
| | | * |
| | | * @param entry The entry to evaluate against exclude and include |
| | | * filter sets. |
| | | * @return <CODE>true</CODE> if current set of filters allow caching |
| | | * the entry and <CODE>false</CODE> otherwise. |
| | | * |
| | | * @return {@code true} if current set of filters allow caching the |
| | | * entry and {@code false} otherwise. |
| | | */ |
| | | protected boolean filtersAllowCaching(Entry entry) |
| | | { |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Performs any processing that may be required whenever a backend |
| | | * is initialized for use in the Directory Server. This method will |
| | | * be invoked after the backend has been initialized but before it |
| | | * has been put into service. |
| | | * |
| | | * @param backend The backend that has been initialized and is |
| | | * about to be put into service. |
| | | */ |
| | | public void performBackendInitializationProcessing(Backend backend) |
| | | { |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Performs any processing that may be required whenever a backend |
| | | * is finalized. This method will be invoked after the backend has |
| | | * been taken out of service but before it has been finalized. |
| | | * |
| | | * @param backend The backend that has been taken out of service |
| | | * and is about to be finalized. |
| | | */ |
| | | public void performBackendFinalizationProcessing(Backend backend) |
| | | { |
| | |
| | | * implemented by a Directory Server module that implements a matching |
| | | * rule used for equality matching. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class EqualityMatchingRule |
| | | extends MatchingRule<EqualityMatchingRuleCfg> |
| | | { |
| | |
| | | * @param value2 The normalized form of the second value to |
| | | * compare. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided values are equal, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the provided values are equal, or |
| | | * {@code false} if not. |
| | | */ |
| | | public abstract boolean areEqual(ByteString value1, |
| | | ByteString value2); |
| | |
| | | * considered a match for the given assertion value. This will only |
| | | * be used for the purpose of extensible matching. Other forms of |
| | | * matching against equality matching rules should use the |
| | | * <CODE>areEqual</CODE> method. |
| | | * {@code areEqual} method. |
| | | * |
| | | * @param attributeValue The attribute value in a form that has |
| | | * been normalized according to this |
| | |
| | | * been normalized according to this |
| | | * matching rule. |
| | | * |
| | | * @return <CODE>true</CODE> if the attribute value should be |
| | | * considered a match for the provided assertion value, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the attribute value should be considered |
| | | * a match for the provided assertion value, or |
| | | * {@code false} if not. |
| | | */ |
| | | public ConditionResult valuesMatch(ByteString attributeValue, |
| | | ByteString assertionValue) |
| | |
| | | * @param <T> The type of error log publisher configuration handled |
| | | * by this log publisher implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class ErrorLogPublisher |
| | | <T extends ErrorLogPublisherCfg> |
| | | { |
| | |
| | | * only be invoked for the LDIF export task and not for offline LDIF |
| | | * export processing. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ExportTaskListener |
| | | { |
| | | /** |
| | |
| | | * @param <T> The configuration class that will be provided to |
| | | * initialize the handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class |
| | | ExtendedOperationHandler<T extends ExtendedOperationHandlerCfg> |
| | | { |
| | | /** |
| | | * The default set of supported control OIDs for this extended |
| | | * operation. |
| | | */ |
| | | protected Set<String> supportedControlOIDs = new HashSet<String>(0); |
| | | // The default set of supported control OIDs for this extended |
| | | private Set<String> supportedControlOIDs = new HashSet<String>(0); |
| | | |
| | | |
| | | |
| | | /** |
| | | * The default set of supported feature OIDs for this extended |
| | | * operation. |
| | | */ |
| | | protected Set<String> supportedFeatureOIDs = new HashSet<String>(0); |
| | | // The default set of supported feature OIDs for this extended |
| | | private Set<String> supportedFeatureOIDs = new HashSet<String>(0); |
| | | |
| | | |
| | | |
| | |
| | | return getSupportedFeatures().contains(featureOID); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * If the extended operation handler defines any supported controls |
| | | * and/or features, then register them with the server. |
| | |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * If the extended operation handler defines any supported controls |
| | | * and/or features, then deregister them with the server. |
| | |
| | | * @param <T> The type of configuration handled by this group |
| | | * implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class Group<T extends GroupImplementationCfg> |
| | | { |
| | | /** |
| | |
| | | * @param <T> The type of configuration handled by this identity |
| | | * mapper. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class IdentityMapper |
| | | <T extends IdentityMapperCfg> |
| | | { |
| | |
| | | * user. |
| | | * |
| | | * @return The user entry that was mapped to the provided |
| | | * identification, or <CODE>null</CODE> if no users were |
| | | * found that could be mapped to the provided ID. |
| | | * identification, or {@code null} if no users were found |
| | | * that could be mapped to the provided ID. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while attempting |
| | | * to map the given ID to a user entry, |
| | |
| | | * only be invoked for the LDIF import task and not for offline LDIF |
| | | * import processing. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ImportTaskListener |
| | | { |
| | | /** |
| | |
| | | * either via adding configuration entries (e.g., task plugins) or |
| | | * through JMX. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface InvokableComponent |
| | | { |
| | | /** |
| | |
| | | * @param arguments The set of configuration attributes holding |
| | | * the arguments to use for the method. |
| | | * |
| | | * @return The return value for the method, or <CODE>null</CODE> |
| | | * if it did not return a value. |
| | | * @return The return value for the method, or {@code null} if it |
| | | * did not return a value. |
| | | * |
| | | * @throws DirectoryException If there was no such method, or if |
| | | * an error occurred while attempting |
| | |
| | | |
| | | /** |
| | | * This class defines an API that may be used to obtain a set of |
| | | * <CODE>javax.net.ssl.KeyManager</CODE> objects for use when |
| | | * performing SSL communication. |
| | | * {@code javax.net.ssl.KeyManager} objects for use when performing |
| | | * SSL communication. |
| | | * |
| | | * @param <T> |
| | | * The type of key manager provider configuration handled by |
| | | * this key manager provider implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class KeyManagerProvider |
| | | <T extends KeyManagerCfg> |
| | | { |
| | |
| | | |
| | | |
| | | /** |
| | | * Retrieves a set of <CODE>KeyManager</CODE> objects that may be |
| | | * used for interactions requiring access to a key manager. |
| | | * Retrieves a set of {@code KeyManager} objects that may be used |
| | | * for interactions requiring access to a key manager. |
| | | * |
| | | * @return A set of <CODE>KeyManager</CODE> objects that may be |
| | | * used for interactions requiring access to a key manager. |
| | | * @return A set of {@code KeyManager} objects that may be used for |
| | | * interactions requiring access to a key manager. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while attempting |
| | | * to obtain the set of key managers. |
| | |
| | | * @param <T> The type of configuration handled by this matching |
| | | * rule. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class MatchingRule<T extends MatchingRuleCfg> |
| | | { |
| | | /** |
| | |
| | | /** |
| | | * Retrieves the common name for this matching rule. |
| | | * |
| | | * @return The common name for this matching rule, or |
| | | * <CODE>null</CODE> if it does not have a name. |
| | | * @return The common name for this matching rule, or {@code null} |
| | | * if it does not have a name. |
| | | */ |
| | | public abstract String getName(); |
| | | |
| | |
| | | * |
| | | * @return The name or OID for this matching rule. |
| | | */ |
| | | public String getNameOrOID() |
| | | public final String getNameOrOID() |
| | | { |
| | | String name = getName(); |
| | | if ((name == null) || (name.length() == 0)) |
| | |
| | | /** |
| | | * Retrieves the description for this matching rule. |
| | | * |
| | | * @return The description for this matching rule, or |
| | | * <CODE>null</CODE> if there is none. |
| | | * @return The description for this matching rule, or {@code null} |
| | | * if there is none. |
| | | */ |
| | | public abstract String getDescription(); |
| | | |
| | |
| | | |
| | | /** |
| | | * Indicates whether this matching rule is declared "OBSOLETE". |
| | | * The default implementation will always return <CODE>false</CODE>. |
| | | * If that is not acceptable for a particular matching rule |
| | | * The default implementation will always return {@code false}. If |
| | | * that is not acceptable for a particular matching rule |
| | | * implementation, then it should override this method and perform |
| | | * the appropriate processing to return the correct value. |
| | | * |
| | | * @return <CODE>true</CODE> if this matching rule is declared |
| | | * "OBSOLETE", or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this matching rule is declared |
| | | * "OBSOLETE", or {@code false} if not. |
| | | */ |
| | | public boolean isObsolete() |
| | | { |
| | |
| | | * been normalized according to this |
| | | * matching rule. |
| | | * |
| | | * @return <CODE>TRUE</CODE> if the attribute value should be |
| | | * considered a match for the provided assertion value, |
| | | * <CODE>FALSE</CODE> if it does not match, or |
| | | * <CODE>UNDEFINED</CODE> if the result is undefined. |
| | | * @return {@code TRUE} if the attribute value should be considered |
| | | * a match for the provided assertion value, {@code FALSE} |
| | | * if it does not match, or {@code UNDEFINED} if the result |
| | | * is undefined. |
| | | */ |
| | | public abstract ConditionResult |
| | | valuesMatch(ByteString attributeValue, |
| | |
| | | * |
| | | * @return The hash code for this matching rule. |
| | | */ |
| | | public int hashCode() |
| | | public final int hashCode() |
| | | { |
| | | int hashCode = 0; |
| | | |
| | |
| | | * |
| | | * @param o The object for which to make the determination. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided object is equal to |
| | | * this matching rule, or <CODE>false</CODE> if it is not. |
| | | * @return {@code true} if the provided object is equal to this |
| | | * matching rule, or {@code false} if it is not. |
| | | */ |
| | | public boolean equals(Object o) |
| | | public final boolean equals(Object o) |
| | | { |
| | | if (o == null) |
| | | { |
| | |
| | | * @return A string representation of this matching rule in the |
| | | * format defined in RFC 2252. |
| | | */ |
| | | public String toString() |
| | | public final String toString() |
| | | { |
| | | StringBuilder buffer = new StringBuilder(); |
| | | toString(buffer); |
| | |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | public void toString(StringBuilder buffer) |
| | | public final void toString(StringBuilder buffer) |
| | | { |
| | | buffer.append("( "); |
| | | buffer.append(getOID()); |
| | |
| | | * @param <T> The type of configuration handled by this monitor |
| | | * provider. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class MonitorProvider<T extends MonitorProviderCfg> |
| | | extends DirectoryThread |
| | | { |
| | |
| | | /** |
| | | * Initializes this monitor provider. Note that no initialization |
| | | * should be done here, since it should be performed in the |
| | | * <CODE>initializeMonitorProvider</CODE> class. |
| | | * {@code initializeMonitorProvider} class. |
| | | * |
| | | * @param threadName The name to use for this thread for debugging |
| | | * purposes. |
| | |
| | | * monitor provider that has resources that should be released when |
| | | * the monitor is no longer needed. Any monitor that does override |
| | | * this method must first invoke this version by calling |
| | | * <CODE>super.finalizeMonitorProvider()</CODE>. |
| | | * {@code super.finalizeMonitorProvider}. |
| | | */ |
| | | public void finalizeMonitorProvider() |
| | | { |
| | |
| | | |
| | | /** |
| | | * Retrieves the length of time in milliseconds that should elapse |
| | | * between calls to the <CODE>updateMonitorData()</CODE> method. A |
| | | * between calls to the {@code updateMonitorData} method. A |
| | | * negative or zero return value indicates that the |
| | | * <CODE>updateMonitorData()</CODE> method should not be |
| | | * periodically invoked. |
| | | * {@code updateMonitorData} method should not be periodically |
| | | * invoked. |
| | | * |
| | | * @return The length of time in milliseconds that should elapse |
| | | * between calls to the <CODE>updateMonitorData()</CODE> |
| | | * method. |
| | | * between calls to the {@code updateMonitorData()} method. |
| | | */ |
| | | public abstract long getUpdateInterval(); |
| | | |
| | |
| | | * Performs any processing periodic processing that may be desired |
| | | * to update the information associated with this monitor. Note |
| | | * that best-effort attempts will be made to ensure that calls to |
| | | * this method come <CODE>getUpdateInterval()</CODE> milliseconds |
| | | * apart, but no guarantees will be made. |
| | | * this method come {@code getUpdateInterval} milliseconds apart, |
| | | * but no guarantees will be made. |
| | | */ |
| | | public abstract void updateMonitorData(); |
| | | |
| | |
| | | |
| | | /** |
| | | * Enters a loop, periodically invoking the |
| | | * <CODE>getUpdateInterval()</CODE> method to updates the data |
| | | * associated with this monitor. |
| | | * {@code getUpdateInterval} method to updates the data associated |
| | | * with this monitor. |
| | | */ |
| | | public final void run() |
| | | { |
| | |
| | | * rule used for determining the correct order of values when sorting |
| | | * or processing range filters. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class OrderingMatchingRule |
| | | extends MatchingRule<OrderingMatchingRuleCfg> |
| | | implements Comparator<byte[]>, Serializable |
| | | { |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler |
| | | * because this class implements the |
| | | * <CODE>java.io.Serializable</CODE> interface. This value was |
| | | * generated using the <CODE>serialver</CODE> command-line utility |
| | | * included with the Java SDK. |
| | | * because this class implements the {@code java.io.Serializable} |
| | | * interface. This value was generated using the {@code serialver} |
| | | * command-line utility included with the Java SDK. |
| | | */ |
| | | private static final long serialVersionUID = -5322529685787024597L; |
| | | |
| | |
| | | * @param value2 The normalized form of the second value to |
| | | * compare. |
| | | * |
| | | * @return A negative integer if <CODE>value1</CODE> should come |
| | | * before <CODE>value2</CODE> in ascending order, a |
| | | * positive integer if <CODE>value1</CODE> should come |
| | | * after <CODE>value2</CODE> in ascending order, or zero if |
| | | * there is no difference between the values with regard to |
| | | * ordering. |
| | | * @return A negative integer if {@code value1} should come before |
| | | * {@code value2} in ascending order, a positive integer if |
| | | * {@code value1} should come after {@code value2} in |
| | | * ascending order, or zero if there is no difference |
| | | * between the values with regard to ordering. |
| | | */ |
| | | public abstract int compareValues(ByteString value1, |
| | | ByteString value2); |
| | |
| | | * <BR><BR> |
| | | * Note that ordering matching rules by default do not support |
| | | * extensible matching, and therefore this method will always return |
| | | * <CODE>UNDEFINED</CODE>. If an ordering matching rule does |
| | | * support extensible matching operations, then it should override |
| | | * this method and provide an appropriate implementation. |
| | | * {@code UNDEFINED}. If an ordering matching rule does support |
| | | * extensible matching operations, then it should override this |
| | | * method and provide an appropriate implementation. |
| | | * |
| | | * @param attributeValue The attribute value in a form that has |
| | | * been normalized according to this |
| | |
| | | * been normalized according to this |
| | | * matching rule. |
| | | * |
| | | * @return <CODE>true</CODE> if the attribute value should be |
| | | * considered a match for the provided assertion value, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the attribute value should be considered |
| | | * a match for the provided assertion value, or |
| | | * {@code false} if not. |
| | | */ |
| | | public ConditionResult valuesMatch(ByteString attributeValue, |
| | | ByteString assertionValue) |
| | |
| | | * @param <T> The type of configuration handled by this password |
| | | * generator. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class PasswordGenerator |
| | | <T extends PasswordGeneratorCfg> |
| | | { |
| | |
| | | * @param <T> The type of configuration handled by this |
| | | * password storage scheme |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class |
| | | PasswordStorageScheme <T extends PasswordStorageSchemeCfg> |
| | | { |
| | |
| | | * @param storedPassword The stored password to compare against |
| | | * the provided plaintext password. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided plaintext password |
| | | * matches the provided stored password, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the provided plaintext password matches |
| | | * the provided stored password, or {@code false} if not. |
| | | */ |
| | | public abstract boolean passwordMatches( |
| | | ByteString plaintextPassword, |
| | |
| | | * ability to interact with values using the authentication password |
| | | * syntax defined in RFC 3112. |
| | | * |
| | | * @return <CODE>true</CODE> if this password storage scheme |
| | | * supports the ability to interact with values using the |
| | | * authentication password syntax, or <CODE>false</CODE> if |
| | | * it does not. |
| | | * @return {@code true} if this password storage scheme supports |
| | | * the ability to interact with values using the |
| | | * authentication password syntax, or {@code false} if it |
| | | * does not. |
| | | */ |
| | | public abstract boolean supportsAuthPasswordSyntax(); |
| | | |
| | |
| | | * Retrieves the scheme name that should be used with this password |
| | | * storage scheme when it is used in the context of the |
| | | * authentication password syntax. This default implementation will |
| | | * return the same value as the <CODE>getStorageSchemeName</CODE> |
| | | * method. |
| | | * return the same value as the {@code getStorageSchemeName} method. |
| | | * |
| | | * @return The scheme name that should be used with this password |
| | | * storage scheme when it is used in the context of the |
| | |
| | | * password encoded in the authentication |
| | | * password syntax. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided plaintext password |
| | | * matches the encoded password according to the |
| | | * authentication password info syntax, or |
| | | * <CODE>false</CODE> if it does not or this storage scheme |
| | | * does not support the authentication password syntax. |
| | | * @return {@code true} if the provided plaintext password matches |
| | | * the encoded password according to the authentication |
| | | * password info syntax, or {@code false} if it does not or |
| | | * this storage scheme does not support the authentication |
| | | * password syntax. |
| | | */ |
| | | public abstract boolean authPasswordMatches( |
| | | ByteString plaintextPassword, |
| | |
| | | * possible to obtain the original plaintext value from the stored |
| | | * password). |
| | | * |
| | | * @return <CODE>true</CODE> if this is a reversible password |
| | | * storage scheme, or <CODE>false</CODE> if it is not. |
| | | * @return {@code true} if this is a reversible password storage |
| | | * scheme, or {@code false} if it is not. |
| | | */ |
| | | public abstract boolean isReversible(); |
| | | |
| | |
| | | /** |
| | | * Retrieves the original plaintext value for the provided stored |
| | | * password. Note that this should only be called if |
| | | * <CODE>isReversible</CODE> returns <CODE>true</CODE>. |
| | | * {@code isReversible} returns {@code true}. |
| | | * |
| | | * @param storedPassword The password for which to obtain the |
| | | * plaintext value. It should not include |
| | |
| | | /** |
| | | * Retrieves the original plaintext value for the provided password |
| | | * stored in the authPassword syntax. Note that this should only be |
| | | * called if <CODE>isReversible</CODE> returns <CODE>true</CODE>. |
| | | * called if {@code isReversible} returns {@code true}. |
| | | * |
| | | * @param authInfo The authInfo component of the password encoded |
| | | * in the authentication password syntax. |
| | |
| | | * allow the password to be returned but the password is considered |
| | | * too insecure to reveal. |
| | | * |
| | | * @return <CODE>false</CODE> if it may be trivial to discover the |
| | | * @return {@code false} if it may be trivial to discover the |
| | | * original plain-text password from the encoded form, or |
| | | * <CODE>true</CODE> if the scheme offers sufficient |
| | | * protection that revealing the encoded password will not |
| | | * easily reveal the corresponding plain-text value. |
| | | * {@code true} if the scheme offers sufficient protection |
| | | * that revealing the encoded password will not easily |
| | | * reveal the corresponding plain-text value. |
| | | */ |
| | | public abstract boolean isStorageSchemeSecure(); |
| | | } |
| | |
| | | * @param <T> The type of configuration handled by this password |
| | | * validator. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class PasswordValidator |
| | | <T extends PasswordValidatorCfg> |
| | | { |
| | |
| | | * determined that the password is not |
| | | * acceptable. |
| | | * |
| | | * @return <CODE>true</CODE> if the password is acceptable, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the password is acceptable, or |
| | | * {@code false} if not. |
| | | */ |
| | | public abstract boolean passwordIsAcceptable(ByteString newPassword, |
| | | Set<ByteString> currentPasswords, |
| | |
| | | * any class that forms the basis for a protocol element (e.g., an |
| | | * ASN.1 element, an LDAP message, etc.). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public interface ProtocolElement |
| | | { |
| | | /** |
| | |
| | | * will only be invoked for the restore task and not for offline |
| | | * restore processing. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface RestoreTaskListener |
| | | { |
| | | /** |
| | |
| | | * @param <T> The type of configuration handled by this SASL |
| | | * mechanism handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class SASLMechanismHandler |
| | | <T extends SASLMechanismHandlerCfg> |
| | | { |
| | |
| | | * with names of mechanisms for which this |
| | | * handler has previously registered. |
| | | * |
| | | * @return <CODE>true</CODE> if this SASL mechanism is |
| | | * password-based, or <CODE>false</CODE> if it uses some |
| | | * other form of credentials. |
| | | * @return {@code true} if this SASL mechanism is password-based, |
| | | * or {@code false} if it uses some other form of |
| | | * credentials. |
| | | */ |
| | | public abstract boolean isPasswordBased(String mechanism); |
| | | |
| | |
| | | * with names of mechanisms for which this |
| | | * handler has previously registered. |
| | | * |
| | | * @return <CODE>true</CODE> if this SASL mechanism should be |
| | | * considered secure, or <CODE>false</CODE> if not. |
| | | * @return {@code true} if this SASL mechanism should be considered |
| | | * secure, or {@code false} if not. |
| | | */ |
| | | public abstract boolean isSecure(String mechanism); |
| | | } |
| | |
| | | * This interface defines a method that may be used to notify various |
| | | * Directory Server components that the server is shutting down. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface ServerShutdownListener |
| | | { |
| | | /** |
| | |
| | | * implemented by a Directory Server module that implements a matching |
| | | * rule used for substring matching. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class SubstringMatchingRule |
| | | extends MatchingRule<SubstringMatchingRuleCfg> |
| | | { |
| | |
| | | /** |
| | | * Determines whether the provided value matches the given substring |
| | | * filter components. Note that any of the substring filter |
| | | * components may be <CODE>null</CODE> but at least one of them must |
| | | * be non-<CODE>null</CODE>. |
| | | * components may be {@code null} but at least one of them must be |
| | | * non-{@code null}. |
| | | * |
| | | * @param value The normalized value against which to |
| | | * compare the substring components. |
| | |
| | | * that should appear at the end of the |
| | | * target value. |
| | | * |
| | | * @return <CODE>true</CODE> if the provided value does match the |
| | | * given substring components, or <CODE>false</CODE> if |
| | | * not. |
| | | * @return {@code true} if the provided value does match the given |
| | | * substring components, or {@code false} if not. |
| | | */ |
| | | public abstract boolean valueMatchesSubstring( |
| | | ByteString value, |
| | |
| | | * <BR><BR> |
| | | * Note that substring matching rules by default do not support |
| | | * extensible matching, and therefore this method will always return |
| | | * <CODE>UNDEFINED</CODE>. If a substring matching rule does |
| | | * support extensible matching operations, then it should override |
| | | * this method and provide an appropriate implementation. |
| | | * {@code UNDEFINED}. If a substring matching rule does support |
| | | * extensible matching operations, then it should override this |
| | | * method and provide an appropriate implementation. |
| | | * |
| | | * @param attributeValue The attribute value in a form that has |
| | | * been normalized according to this |
| | |
| | | * been normalized according to this |
| | | * matching rule. |
| | | * |
| | | * @return <CODE>true</CODE> if the attribute value should be |
| | | * considered a match for the provided assertion value, or |
| | | * <CODE>false</CODE> if not. |
| | | * @return {@code true} if the attribute value should be considered |
| | | * a match for the provided assertion value, or |
| | | * {@code false} if not. |
| | | */ |
| | | public ConditionResult valuesMatch(ByteString attributeValue, |
| | | ByteString assertionValue) |
| | |
| | | /** |
| | | * Generic subtree specification interface. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class SubtreeSpecification |
| | | { |
| | | /** |
| | |
| | | * Determine if an entry is within the scope of the subtree |
| | | * specification. |
| | | * |
| | | * @param entry |
| | | * The entry. |
| | | * @return Returns <code>true</code> if the entry is within the |
| | | * scope of the subtree specification, or <code>false</code> |
| | | * otherwise. |
| | | * @param entry The entry. |
| | | * |
| | | * @return {@code true} if the entry is within the scope of the |
| | | * subtree specification, or {@code false} if not. |
| | | */ |
| | | public abstract boolean isWithinScope(Entry entry); |
| | | |
| | |
| | | * Append the string representation of the subtree specification to |
| | | * the provided string builder. |
| | | * |
| | | * @param builder |
| | | * The string builder. |
| | | * @return The string builder. |
| | | * @param builder The string builder. |
| | | * @return The string builder. |
| | | */ |
| | | public abstract StringBuilder toString(StringBuilder builder); |
| | | |
| | |
| | | * whether or not an entry is within the scope of one or more |
| | | * contained {@code SubtreeSpecification}s. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SubtreeSpecificationSet |
| | | extends AbstractSet<SubtreeSpecification> |
| | | { |
| | |
| | | * |
| | | * @param <T> the configuration for the synchronization provider. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class |
| | | SynchronizationProvider<T extends SynchronizationProviderCfg> |
| | | { |
| | |
| | | * @param <T> The type of trust manager provider configuration |
| | | * handled by this trust manager provider implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class TrustManagerProvider<T extends TrustManagerCfg> |
| | | { |
| | | /** |
| | |
| | | * @param <T> The type of configuration handled by this virtual |
| | | * attribute provider. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class VirtualAttributeProvider |
| | | <T extends VirtualAttributeCfg> |
| | | { |
| | |
| | | * |
| | | * @param <T> The type of configuration handled by this work queue. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class WorkQueue<T extends WorkQueueCfg> |
| | | { |
| | | /** |
| | |
| | | * effects or that does not work properly across different Directory |
| | | * Server versions. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE) |
| | | package org.opends.server.api; |
| | | |
| | |
| | | * |
| | | * @param <T> The type of configuration handled by this plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public abstract class DirectoryServerPlugin |
| | | <T extends PluginCfg> |
| | | { |
| | |
| | | * plugin must implement a default constructor (it is the only one |
| | | * that will be used to create plugins defined in the |
| | | * configuration), and every plugin constructor must call |
| | | * <CODE>super()</CODE> as its first element. |
| | | * {@code super()} as its first action. |
| | | */ |
| | | protected DirectoryServerPlugin() |
| | | { |
| | |
| | | * @param pluginTypes The set of plugin types for which this |
| | | * plugin is registered. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public final void initializeInternal(DN pluginDN, |
| | | Set<PluginType> pluginTypes) |
| | | { |
| | |
| | | * @param disconnectReason The disconnect reason for the closure. |
| | | * @param message A message providing additional |
| | | * information about the closure, or |
| | | * <CODE>null</CODE> if there is none. |
| | | * {@code null} if there is none. |
| | | * |
| | | * @return The result of the plugin processing. |
| | | */ |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by an intermediate response plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class IntermediateResponsePluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing an LDIF import or export plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class LDIFPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines an enumeration containing the types of plugins |
| | | * that are supported for use in the Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum PluginType |
| | | { |
| | | /** |
| | |
| | | * @param lowerName The name of the plugin type to retrieve, |
| | | * formatted in all lowercase characters. |
| | | * |
| | | * @return The requested plugin type, or <CODE>null</CODE> if there |
| | | * is no type for the provided name. |
| | | * @return The requested plugin type, or {@code null} if there is |
| | | * no type for the provided name. |
| | | */ |
| | | public static PluginType forName(String lowerName) |
| | | { |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a post-connect plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PostConnectPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a post-disconnect plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PostDisconnectPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a post-operation plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PostOperationPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a post-response plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PostResponsePluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a pre-operation plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PreOperationPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a pre-parse plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class PreParsePluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a search result entry plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class SearchEntryPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a search result reference plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class SearchReferencePluginResult |
| | | { |
| | | /** |
| | |
| | | * the result of processing by a plugin invoked during the Directory |
| | | * Server startup process. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class StartupPluginResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a subordinate modify DN plugin. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class SubordinateModifyDNPluginResult |
| | | { |
| | | /** |
| | |
| | | * </LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED) |
| | | package org.opends.server.api.plugin; |
| | | |
| | |
| | | * Contains the Directory Server Sun Java System Directory Server Enterprise |
| | | * Edition (dseecompat) compatability access control handler implementation. |
| | | */ |
| | | package org.opends.server.authorization.dseecompat; |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.authorization.dseecompat; |
| | | |
| | |
| | | * mechanism that the client used to authenticate, the network location of the |
| | | * client, the manner in which the client is communicating with the server, etc. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.authorization; |
| | | |
| | |
| | | |
| | | /** |
| | | * This is an implementation of a Directory Server Backend which stores entries |
| | | * locally in a Sleepycat JE database. |
| | | * locally in a Berkeley DB JE database. |
| | | */ |
| | | public class BackendImpl |
| | | extends Backend |
| | |
| | | // operations. |
| | | envConfig.setConfigParam("je.env.sharedLatches", "true"); |
| | | |
| | | // This parameter was set to false while diagnosing a Sleepycat bug. |
| | | // This parameter was set to false while diagnosing a Berkeley DB JE bug. |
| | | // Normally cleansed log files are deleted, but if this is set false |
| | | // they are instead renamed from .jdb to .del. |
| | | envConfig.setConfigParam("je.cleaner.expunge", "true"); |
| | |
| | | * |
| | | * |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.backends.jeb; |
| | | |
| | |
| | | * information) may reside directly in this package. The code for more complex |
| | | * backends comprised of multiple classes are more appropriate for sub-packages. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.backends; |
| | | |
| | |
| | | * tasks, but a task group must be used to achieve the same result for recurring |
| | | * tasks. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.backends.task; |
| | | |
| | |
| | | * configuration attributes will always be required and will never be |
| | | * multivalued. |
| | | */ |
| | | public class BooleanConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class BooleanConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | |
| | | |
| | | |
| | | // The active value for this attribute. |
| | | private boolean activeValue; |
| | | |
| | |
| | | * values associated with a configurable property within the Directory Server. |
| | | * Subclasses should define and enforce actual data types. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class ConfigAttribute |
| | | { |
| | | |
| | | |
| | | |
| | | // Indicates whether this configuration attribute has pending changes that |
| | | // will be applied after appropriate administrative action has been performed. |
| | | private boolean hasPendingValues; |
| | |
| | | * configuration, including configuration attribute and objectclass names, |
| | | * and attribute options. |
| | | */ |
| | | public class ConfigConstants |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ConfigConstants |
| | | { |
| | | /** |
| | | * The prefix that will be applied to all custom attribute and objectclass |
| | |
| | | * attributes that may control the configuration of various components of the |
| | | * Directory Server. |
| | | */ |
| | | public class ConfigEntry |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ConfigEntry |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * This class defines an exception that may be thrown during the course of |
| | | * interactions with the Directory Server configuration. |
| | | */ |
| | | public class ConfigException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ConfigException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * This class defines a DN configuration attribute, which can hold zero or more |
| | | * DN values. |
| | | */ |
| | | public class DNConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DNConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | /** |
| | |
| | | * <CODE>long</CODE> elements, although it will be possible to interact with |
| | | * them as integers in cases where that scalability is not required. |
| | | */ |
| | | public class IntegerConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class IntegerConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | /** |
| | |
| | | * the actual value not on merely the integer portion. This attribute may only |
| | | * hold a single value and it will always be required. |
| | | */ |
| | | public class IntegerWithUnitConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class IntegerWithUnitConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | /** |
| | |
| | | * read-write access to the configuration, and provide notifications and alerts |
| | | * if a significant event or severe/fatal error occurs. |
| | | */ |
| | | public class JMXMBean |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class JMXMBean |
| | | implements DynamicMBean, DirectoryServerMBean |
| | | { |
| | | /** |
| | |
| | | * zero or more string values. A user-defined set of allowed values will be |
| | | * enforced. |
| | | */ |
| | | public class MultiChoiceConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class MultiChoiceConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | /** |
| | |
| | | * This class defines a configuration attribute that is only intended for use |
| | | * in displaying information. It will not allow its value to be altered. |
| | | */ |
| | | public class ReadOnlyConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ReadOnlyConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | |
| | | |
| | | |
| | | // The set of values for this attribute. |
| | | private List<String> values; |
| | | |
| | |
| | | * This class defines a string configuration attribute, which can hold zero or |
| | | * more string values. |
| | | */ |
| | | public class StringConfigAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class StringConfigAttribute |
| | | extends ConfigAttribute |
| | | { |
| | | /** |
| | |
| | | * existing entry is removed, then any configuration delete listeners associated |
| | | * with that entry's parent will be invoked. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE) |
| | | package org.opends.server.config; |
| | | |
| | |
| | | * Contains classes that represent specific LDAP controls and their values. |
| | | * These classes are all subclasses of com.sun.directory.core.Control. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.controls; |
| | | |
| | |
| | | * </LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.core; |
| | | |
| | |
| | | import java.util.LinkedHashMap; |
| | | import java.util.List; |
| | | import java.util.Map; |
| | | import java.util.Set; |
| | | import java.util.concurrent.TimeUnit; |
| | | import java.util.concurrent.locks.Lock; |
| | | import java.util.concurrent.locks.ReentrantLock; |
| | |
| | | // Obtain a lock on the cache. If this fails, then don't do anything. |
| | | try |
| | | { |
| | | if (! cacheLock.tryLock(lockTimeout, TimeUnit.MILLISECONDS)) |
| | | if (! cacheLock.tryLock(getLockTimeout(), TimeUnit.MILLISECONDS)) |
| | | { |
| | | return; |
| | | } |
| | |
| | | // Obtain a lock on the cache. If this fails, then don't do anything. |
| | | try |
| | | { |
| | | if (! cacheLock.tryLock(lockTimeout, TimeUnit.MILLISECONDS)) |
| | | if (! cacheLock.tryLock(getLockTimeout(), TimeUnit.MILLISECONDS)) |
| | | { |
| | | // We can't rule out the possibility of a conflict, so return false. |
| | | return false; |
| | |
| | | ) |
| | | { |
| | | // Store the current value to detect changes. |
| | | long prevLockTimeout = lockTimeout; |
| | | long prevMaxEntries = maxEntries; |
| | | int prevMaxMemoryPercent = maxMemoryPercent; |
| | | HashSet<SearchFilter> prevIncludeFilters = includeFilters; |
| | | HashSet<SearchFilter> prevExcludeFilters = excludeFilters; |
| | | long prevLockTimeout = getLockTimeout(); |
| | | long prevMaxEntries = maxEntries; |
| | | int prevMaxMemoryPercent = maxMemoryPercent; |
| | | Set<SearchFilter> prevIncludeFilters = getIncludeFilters(); |
| | | Set<SearchFilter> prevExcludeFilters = getExcludeFilters(); |
| | | |
| | | // Activate the new configuration. |
| | | ConfigChangeResult changeResult = applyConfigurationChange(configuration); |
| | |
| | | INFO_FIFOCACHE_UPDATED_MAX_ENTRIES.get(maxEntries)); |
| | | } |
| | | |
| | | if (lockTimeout != prevLockTimeout) |
| | | if (getLockTimeout() != prevLockTimeout) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FIFOCACHE_UPDATED_LOCK_TIMEOUT.get(lockTimeout)); |
| | | INFO_FIFOCACHE_UPDATED_LOCK_TIMEOUT.get(getLockTimeout())); |
| | | } |
| | | |
| | | if (!includeFilters.equals(prevIncludeFilters)) |
| | | if (!getIncludeFilters().equals(prevIncludeFilters)) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FIFOCACHE_UPDATED_INCLUDE_FILTERS.get()); |
| | | } |
| | | |
| | | if (!excludeFilters.equals(prevExcludeFilters)) |
| | | if (!getExcludeFilters().equals(prevExcludeFilters)) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FIFOCACHE_UPDATED_EXCLUDE_FILTERS.get()); |
| | |
| | | if (applyChanges && errorHandler.getIsAcceptable()) |
| | | { |
| | | configEntryDN = newConfigEntryDN; |
| | | lockTimeout = newLockTimeout; |
| | | maxEntries = newMaxEntries; |
| | | maxMemoryPercent = newMaxMemoryPercent; |
| | | maxAllowedMemory = newMaxAllowedMemory; |
| | | includeFilters = newIncludeFilters; |
| | | excludeFilters = newExcludeFilters; |
| | | |
| | | setLockTimeout(newLockTimeout); |
| | | setIncludeFilters(newIncludeFilters); |
| | | setExcludeFilters(newExcludeFilters); |
| | | } |
| | | |
| | | return errorHandler.getIsAcceptable(); |
| | |
| | | |
| | | // Obtain a lock on the cache. If this fails, then don't do anything. |
| | | try { |
| | | if (!cacheWriteLock.tryLock(lockTimeout, TimeUnit.MILLISECONDS)) { |
| | | if (!cacheWriteLock.tryLock(getLockTimeout(), TimeUnit.MILLISECONDS)) { |
| | | return; |
| | | } |
| | | putEntryToDB(entry, backend, entryID); |
| | |
| | | |
| | | try { |
| | | // Obtain a lock on the cache. If this fails, then don't do anything. |
| | | if (! cacheWriteLock.tryLock(lockTimeout, TimeUnit.MILLISECONDS)) { |
| | | if (! cacheWriteLock.tryLock(getLockTimeout(), TimeUnit.MILLISECONDS)) { |
| | | // We can't rule out the possibility of a conflict, so return false. |
| | | return false; |
| | | } |
| | |
| | | ) |
| | | { |
| | | // Store the current value to detect changes. |
| | | long prevLockTimeout = lockTimeout; |
| | | long prevLockTimeout = getLockTimeout(); |
| | | long prevMaxEntries = maxEntries.longValue(); |
| | | Set<SearchFilter> prevIncludeFilters = includeFilters; |
| | | Set<SearchFilter> prevExcludeFilters = excludeFilters; |
| | | Set<SearchFilter> prevIncludeFilters = getIncludeFilters(); |
| | | Set<SearchFilter> prevExcludeFilters = getExcludeFilters(); |
| | | long prevMaxAllowedMemory = maxAllowedMemory; |
| | | int prevJECachePercent = jeCachePercent; |
| | | long prevJECacheSize = jeCacheSize; |
| | |
| | | INFO_FSCACHE_UPDATED_MAX_ENTRIES.get(maxEntries)); |
| | | } |
| | | |
| | | if (lockTimeout != prevLockTimeout) |
| | | if (getLockTimeout() != prevLockTimeout) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FSCACHE_UPDATED_LOCK_TIMEOUT.get(lockTimeout)); |
| | | INFO_FSCACHE_UPDATED_LOCK_TIMEOUT.get(getLockTimeout())); |
| | | } |
| | | |
| | | if (!includeFilters.equals(prevIncludeFilters)) |
| | | if (!getIncludeFilters().equals(prevIncludeFilters)) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FSCACHE_UPDATED_INCLUDE_FILTERS.get()); |
| | | } |
| | | |
| | | if (!excludeFilters.equals(prevExcludeFilters)) |
| | | if (!getExcludeFilters().equals(prevExcludeFilters)) |
| | | { |
| | | changeResult.addMessage( |
| | | INFO_FSCACHE_UPDATED_EXCLUDE_FILTERS.get()); |
| | |
| | | } |
| | | |
| | | configEntryDN = newConfigEntryDN; |
| | | lockTimeout = newLockTimeout; |
| | | maxEntries = new AtomicLong(newMaxEntries); |
| | | maxAllowedMemory = newMaxAllowedMemory; |
| | | includeFilters = newIncludeFilters; |
| | | excludeFilters = newExcludeFilters; |
| | | persistentCache = newPersistentCache; |
| | | |
| | | setLockTimeout(newLockTimeout); |
| | | setIncludeFilters(newIncludeFilters); |
| | | setExcludeFilters(newExcludeFilters); |
| | | } |
| | | |
| | | return errorHandler.getIsAcceptable(); |
| | |
| | | import java.util.LinkedHashSet; |
| | | import java.util.List; |
| | | import java.util.HashSet; |
| | | import java.util.Set; |
| | | import java.util.concurrent.locks.Lock; |
| | | |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | |
| | | // The reference to the identity mapper. |
| | | private IdentityMapper identityMapper; |
| | | |
| | | // The default set of supported control OIDs for this extended |
| | | private Set<String> supportedControlOIDs = new HashSet<String>(0); |
| | | |
| | | |
| | | |
| | | /** |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | @Override() |
| | | public Set<String> getSupportedControls() |
| | | { |
| | | return supportedControlOIDs; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Processes the provided extended operation. |
| | | * |
| | | * @param operation The extended operation to be processed. |
| | |
| | | idMap = new ConcurrentHashMap<Backend, |
| | | ConcurrentHashMap<Long,SoftReference<CacheEntry>>>(); |
| | | |
| | | excludeFilters = new HashSet<SearchFilter>(); |
| | | includeFilters = new HashSet<SearchFilter>(); |
| | | lockTimeout = LockManager.DEFAULT_TIMEOUT; |
| | | setExcludeFilters(new HashSet<SearchFilter>()); |
| | | setIncludeFilters(new HashSet<SearchFilter>()); |
| | | setLockTimeout(LockManager.DEFAULT_TIMEOUT); |
| | | referenceQueue = new ReferenceQueue<CacheEntry>(); |
| | | |
| | | Thread cleanerThread = |
| | |
| | | |
| | | if (applyChanges && errorHandler.getIsAcceptable()) |
| | | { |
| | | configEntryDN = newConfigEntryDN; |
| | | lockTimeout = newLockTimeout; |
| | | includeFilters = newIncludeFilters; |
| | | excludeFilters = newExcludeFilters; |
| | | configEntryDN = newConfigEntryDN; |
| | | |
| | | setLockTimeout(newLockTimeout); |
| | | setIncludeFilters(newIncludeFilters); |
| | | setExcludeFilters(newExcludeFilters); |
| | | } |
| | | |
| | | return errorHandler.getIsAcceptable(); |
| | |
| | | * <LI>Connection Security Providers</LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.extensions; |
| | | |
| | |
| | | * will need to be invoked on the object, the {@code org.opends.server.types.DN} |
| | | * class should be used instead. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true, |
| | | notes="This is only intended for use if a DN will ever only be treated " + |
| | | "as a string and will not be transferred or processed in any way.") |
| | | public class LazyDN |
| | | extends DN |
| | | { |
| | |
| | | * or projects that wish to use them are encouraged to check with the OpenDS |
| | | * developers first to ensure that they are suitable for the intended purpose. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE) |
| | | package org.opends.server.interop; |
| | | |
| | |
| | | extends AccessLogPublisher<FileBasedAccessLogPublisherCfg> |
| | | implements ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> |
| | | { |
| | | private boolean suppressInternalOperations = true; |
| | | |
| | | private boolean suppressSynchronizationOperations = false; |
| | | |
| | | private TextWriter writer; |
| | | |
| | | private FileBasedAccessLogPublisherCfg currentConfig; |
| | |
| | | extends AccessLogPublisher<FileBasedAccessLogPublisherCfg> |
| | | implements ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> |
| | | { |
| | | private boolean suppressInternalOperations = true; |
| | | |
| | | private boolean suppressSynchronizationOperations = false; |
| | | |
| | | private TextWriter writer; |
| | | |
| | | private FileBasedAccessLogPublisherCfg currentConfig; |
| | |
| | | * about the class, method, line number, and threads are automatically included |
| | | * in the debug message. |
| | | */ |
| | | package org.opends.server.loggers.debug; |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.loggers.debug; |
| | | |
| | |
| | | * trigger the generation of log messages, as well as actual implementations |
| | | * that can write the log contents to various targets. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.loggers; |
| | | |
| | |
| | | * the server) and statistical (for tracking information about the volume and |
| | | * rate of processing that the server performs). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.monitors; |
| | | |
| | |
| | | * technical reason that it would not work for them to be placed in this |
| | | * package. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.plugins; |
| | | |
| | |
| | | * command-line mode as well as a more flexible and potentially more useful GUI |
| | | * mode. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.plugins.profiler; |
| | | |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 Boolean elements. |
| | | */ |
| | | public class ASN1Boolean |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Boolean |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * This class defines a number of constants that may be used when interacting |
| | | * with ASN.1 elements. |
| | | */ |
| | | public class ASN1Constants |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Constants |
| | | { |
| | | /** |
| | | * The BER type that is assigned to the universal Boolean element. |
| | |
| | | * with generic ASN.1 elements. Subclasses may provide more specific |
| | | * functionality for individual element types. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class ASN1Element |
| | | implements ProtocolElement, Serializable |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * |
| | | * @return The BER type for this ASN.1 element. |
| | | */ |
| | | public byte getType() |
| | | public final byte getType() |
| | | { |
| | | return type; |
| | | } |
| | |
| | | * |
| | | * @param type The BER type for this ASN.1 element. |
| | | */ |
| | | public void setType(byte type) |
| | | public final void setType(byte type) |
| | | { |
| | | this.type = type; |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element is in the universal class, |
| | | * or <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean isUniversal() |
| | | public final boolean isUniversal() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_CLASS) == TYPE_MASK_UNIVERSAL); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element is in the |
| | | * application-specific class, or <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean isApplicationSpecific() |
| | | public final boolean isApplicationSpecific() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_CLASS) == TYPE_MASK_APPLICATION); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element is in the context-specific |
| | | * class, or <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean isContextSpecific() |
| | | public final boolean isContextSpecific() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_CLASS) == TYPE_MASK_CONTEXT); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element is in the private class, |
| | | * or <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean isPrivate() |
| | | public final boolean isPrivate() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_CLASS) == TYPE_MASK_PRIVATE); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element has a primitive value, or |
| | | * <CODE>false</CODE> if it is constructed. |
| | | */ |
| | | public boolean isPrimitive() |
| | | public final boolean isPrimitive() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_PC) == TYPE_MASK_PRIMITIVE); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this ASN.1 element has a constructed value, |
| | | * or <CODE>false</CODE> if it is primitive. |
| | | */ |
| | | public boolean isConstructed() |
| | | public final boolean isConstructed() |
| | | { |
| | | return ((type & TYPE_MASK_ALL_BUT_PC) == TYPE_MASK_CONSTRUCTED); |
| | | } |
| | |
| | | * |
| | | * @return The encoded value for this ASN.1 element. |
| | | */ |
| | | public byte[] value() |
| | | public final byte[] value() |
| | | { |
| | | return value; |
| | | } |
| | |
| | | * |
| | | * @return The byte array containing the encoded ASN.1 element. |
| | | */ |
| | | public byte[] encode() |
| | | public final byte[] encode() |
| | | { |
| | | if (value.length == 0) |
| | | { |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 Boolean element. |
| | | */ |
| | | public ASN1Boolean decodeAsBoolean() |
| | | public final ASN1Boolean decodeAsBoolean() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Boolean.decodeAsBoolean(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 enumerated element. |
| | | */ |
| | | public ASN1Enumerated decodeAsEnumerated() |
| | | public final ASN1Enumerated decodeAsEnumerated() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Enumerated.decodeAsEnumerated(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 integer element. |
| | | */ |
| | | public ASN1Integer decodeAsInteger() |
| | | public final ASN1Integer decodeAsInteger() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Integer.decodeAsInteger(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 long element. |
| | | */ |
| | | public ASN1Long decodeAsLong() |
| | | public final ASN1Long decodeAsLong() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Long.decodeAsLong(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 null element. |
| | | */ |
| | | public ASN1Null decodeAsNull() |
| | | public final ASN1Null decodeAsNull() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Null.decodeAsNull(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 octet string element. |
| | | */ |
| | | public ASN1OctetString decodeAsOctetString() |
| | | public final ASN1OctetString decodeAsOctetString() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1OctetString.decodeAsOctetString(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 sequence element. |
| | | */ |
| | | public ASN1Sequence decodeAsSequence() |
| | | public final ASN1Sequence decodeAsSequence() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Sequence.decodeAsSequence(this); |
| | |
| | | * @throws ASN1Exception If a problem occurs while attempting to decode this |
| | | * element as an ASN.1 set element. |
| | | */ |
| | | public ASN1Set decodeAsSet() |
| | | public final ASN1Set decodeAsSet() |
| | | throws ASN1Exception |
| | | { |
| | | return ASN1Set.decodeAsSet(this); |
| | |
| | | * |
| | | * @return The name of the protocol associated with this protocol element. |
| | | */ |
| | | public String getProtocolElementName() |
| | | public final String getProtocolElementName() |
| | | { |
| | | return "ASN.1"; |
| | | } |
| | |
| | | * object will be considered equal if it is an ASN.1 element (or a |
| | | * subclass) with the same type and encoded value. |
| | | */ |
| | | public boolean equals(Object o) |
| | | public final boolean equals(Object o) |
| | | { |
| | | if (this == o) |
| | | { |
| | |
| | | * @return <CODE>true</CODE> if the values of the elements are equal, or |
| | | * <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean equalsIgnoreType(ASN1Element element) |
| | | public final boolean equalsIgnoreType(ASN1Element element) |
| | | { |
| | | return Arrays.equals(value, element.value); |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if the values are equal, or <CODE>false</CODE> |
| | | * if not. |
| | | */ |
| | | public boolean equalsIgnoreType(ByteString byteString) |
| | | public final boolean equalsIgnoreType(ByteString byteString) |
| | | { |
| | | return Arrays.equals(value, byteString.value()); |
| | | } |
| | |
| | | * or <CODE>false</CODE> if not. The elements will be considered |
| | | * equal if they have the same type and encoded value. |
| | | */ |
| | | public boolean equalsElement(ASN1Element e) |
| | | public final boolean equalsElement(ASN1Element e) |
| | | { |
| | | if (this == e) |
| | | { |
| | |
| | | * |
| | | * @return The hash code for this ASN.1 element. |
| | | */ |
| | | public int hashCode() |
| | | public final int hashCode() |
| | | { |
| | | int hashCode = type; |
| | | int length = Math.min(20, value.length); |
| | |
| | | * |
| | | * @return A string representation of this ASN.1 element. |
| | | */ |
| | | public String toString() |
| | | public final String toString() |
| | | { |
| | | StringBuilder buffer = new StringBuilder(); |
| | | toString(buffer); |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 enumerated elements. |
| | | */ |
| | | public class ASN1Enumerated |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Enumerated |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * This class defines an exception that may be thrown if a problem occurs while |
| | | * interacting with an ASN.1 element. |
| | | */ |
| | | public class ASN1Exception |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Exception |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a new ASN.1 exception with the provided message. |
| | | * |
| | |
| | | { |
| | | super(message, cause); |
| | | } |
| | | |
| | | |
| | | |
| | | } |
| | | |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 integer elements. |
| | | */ |
| | | public class ASN1Integer |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Integer |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * <CODE>ASN1Integer</CODE> class and therefore that class should be used for |
| | | * cases in which there is no danger of overflowing an <CODE>int</CODE> value. |
| | | */ |
| | | public class ASN1Long |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Long |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 null elements. |
| | | */ |
| | | public class ASN1Null |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Null |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * to ASN.1 elements should be limited to cases in which ASN.1 is actually |
| | | * involved. |
| | | */ |
| | | public class ASN1OctetString |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1OctetString |
| | | extends ASN1Element |
| | | implements ByteString |
| | | { |
| | |
| | | * This class defines a utility that can be used to read ASN.1 elements from a |
| | | * provided socket or input stream. |
| | | */ |
| | | public class ASN1Reader |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Reader |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 sequence elements. |
| | | */ |
| | | public class ASN1Sequence |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Sequence |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * This class defines the data structures and methods to use when interacting |
| | | * with ASN.1 set elements. |
| | | */ |
| | | public class ASN1Set |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Set |
| | | extends ASN1Element |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | * This class defines a utility that can be used to write ASN.1 elements over a |
| | | * provided socket or output stream. |
| | | */ |
| | | public class ASN1Writer |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ASN1Writer |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * the outermost ASN.1 sequence that comprises the LDAPMessage envelope will |
| | | * best be done within the implementation for the LDAP connection handler. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED) |
| | | package org.opends.server.protocols.asn1; |
| | | |
| | |
| | | * This class defines a pseudo-connection object that can be used for |
| | | * performing internal operations. |
| | | */ |
| | | public class InternalClientConnection |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class InternalClientConnection |
| | | extends ClientConnection |
| | | { |
| | | /** |
| | |
| | | super.setAuthenticationInfo(authenticationInfo); |
| | | super.setSizeLimit(0); |
| | | super.setTimeLimit(0); |
| | | super.setIdleTimeLimit(0); |
| | | super.setLookthroughLimit(0); |
| | | } |
| | | catch (DirectoryException de) |
| | |
| | | super.setAuthenticationInfo(authInfo); |
| | | super.setSizeLimit(0); |
| | | super.setTimeLimit(0); |
| | | super.setIdleTimeLimit(0); |
| | | super.setLookthroughLimit(0); |
| | | |
| | | connectionID = nextConnectionID.getAndDecrement(); |
| | |
| | | * @return The unique identifier that has been assigned to this |
| | | * connection. |
| | | */ |
| | | @Override() |
| | | public long getConnectionID() |
| | | { |
| | | return connectionID; |
| | |
| | | * @return The connection handler that accepted this client |
| | | * connection. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public ConnectionHandler getConnectionHandler() |
| | | { |
| | | return InternalConnectionHandler.getInstance(); |
| | |
| | | * @return The protocol that the client is using to communicate |
| | | * with the Directory Server. |
| | | */ |
| | | @Override() |
| | | public String getProtocol() |
| | | { |
| | | return "internal"; |
| | |
| | | * |
| | | * @return A string representation of the address of the client. |
| | | */ |
| | | @Override() |
| | | public String getClientAddress() |
| | | { |
| | | return "internal"; |
| | |
| | | * @return A string representation of the address on the server to |
| | | * which the client connected. |
| | | */ |
| | | @Override() |
| | | public String getServerAddress() |
| | | { |
| | | return "internal"; |
| | |
| | | * if the client is not connected over an IP-based |
| | | * connection. |
| | | */ |
| | | @Override() |
| | | public InetAddress getRemoteAddress() |
| | | { |
| | | return null; |
| | |
| | | * connection. It may be <CODE>null</CODE> if the client |
| | | * is not connected over an IP-based connection. |
| | | */ |
| | | @Override() |
| | | public InetAddress getLocalAddress() |
| | | { |
| | | return null; |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the size limit that will be enforced for searches |
| | | * performed using this client connection. This method does nothing |
| | | * because connection-level size limits will never be enforced for |
| | | * internal client connections. |
| | | * |
| | | * @param sizeLimit The size limit that will be enforced for |
| | | * searches performed using this client |
| | | * connection. |
| | | */ |
| | | @Override() |
| | | public void setSizeLimit(int sizeLimit) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the default maximum number of entries that should |
| | | * be checked for matches during a search. This method does nothing |
| | | * because connection-level lookthrough limits will never be |
| | | * enforced for internal client connections |
| | | * |
| | | * @param lookthroughLimit The default maximum number of |
| | | * entries that should be check for |
| | | * matches during a search. |
| | | */ |
| | | @Override() |
| | | public void setLookthroughLimit(int lookthroughLimit) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the maximum length of time in milliseconds that this |
| | | * client connection will be allowed to remain idle before it should |
| | | * be disconnected. This method does nothing because internal |
| | | * client connections will not be terminated due to an idle time |
| | | * limit. |
| | | * |
| | | * @param idleTimeLimit The maximum length of time in milliseconds |
| | | * that this client connection will be |
| | | * allowed to remain idle before it should be |
| | | * disconnected. |
| | | */ |
| | | @Override() |
| | | public void setIdleTimeLimit(long idleTimeLimit) |
| | | { |
| | | // No implementation rqeuired. We never want to set a nonzero |
| | | // idle time limit for internal client connections. |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies the time limit that will be enforced for searches |
| | | * performed using this client connection. This method does nothing |
| | | * because connection-level tim elimits will never be enforced for |
| | | * internal client connections. |
| | | * |
| | | * @param timeLimit The time limit that will be enforced for |
| | | * searches performed using this client |
| | | * connection. |
| | | */ |
| | | @Override() |
| | | public void setTimeLimit(int timeLimit) |
| | |
| | | * using a secure mechanism to communicate with the server, |
| | | * or <CODE>false</CODE> if not. |
| | | */ |
| | | @Override() |
| | | public boolean isSecure() |
| | | { |
| | | // Internal connections will generally be considered secure, but |
| | |
| | | * @return The connection security provider for this client |
| | | * connection. |
| | | */ |
| | | @Override() |
| | | public ConnectionSecurityProvider getConnectionSecurityProvider() |
| | | { |
| | | return securityProvider; |
| | |
| | | * for communication on this client |
| | | * connection. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void setConnectionSecurityProvider(ConnectionSecurityProvider |
| | | securityProvider) |
| | | { |
| | |
| | | * is used to protect communication with this client, or |
| | | * <CODE>null</CODE> if no security is in place. |
| | | */ |
| | | @Override() |
| | | public String getSecurityMechanism() |
| | | { |
| | | return securityProvider.getSecurityMechanismName(); |
| | |
| | | * <CODE>false</CODE>, then it must have already |
| | | * disconnected the client. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public boolean processDataRead(ByteBuffer buffer) |
| | | { |
| | | // This method will not do anything with the data because there is |
| | |
| | | * |
| | | * @param operation The operation for which to send the response. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void sendResponse(Operation operation) |
| | | { |
| | | // There will not be any response sent by this method, since there |
| | |
| | | * @return Information about the user that is currently |
| | | * authenticated on this connection. |
| | | */ |
| | | @Override() |
| | | public AuthenticationInfo getAuthenticationInfo() |
| | | { |
| | | return authenticationInfo; |
| | |
| | | * connection. It should not be |
| | | * <CODE>null</CODE>. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void setAuthenticationInfo(AuthenticationInfo |
| | | authenticationInfo) |
| | | { |
| | |
| | | * internal client connections is set when the connection is created |
| | | * and cannot be changed after the fact. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void setUnauthenticated() |
| | | { |
| | | // No implementation required. |
| | |
| | | * the entry and the search should be |
| | | * terminated. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void sendSearchEntry(SearchOperation searchOperation, |
| | | SearchResultEntry searchEntry) |
| | | throws DirectoryException |
| | |
| | | * the entry and the search should be |
| | | * terminated. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public boolean sendSearchReference(SearchOperation searchOperation, |
| | | SearchResultReference searchReference) |
| | | throws DirectoryException |
| | |
| | | * @return <CODE>true</CODE> if processing on the associated |
| | | * operation should continue, or <CODE>false</CODE> if not. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | protected boolean sendIntermediateResponseMessage( |
| | | IntermediateResponse intermediateResponse) |
| | | { |
| | |
| | | * may be <CODE>null</CODE> if no |
| | | * notification is to be sent. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void disconnect(DisconnectReason disconnectReason, |
| | | boolean sendNotification, |
| | | Message message) |
| | |
| | | * @return <CODE>true</CODE> if a bind operation is in progress on |
| | | * this connection, or <CODE>false</CODE> if not. |
| | | */ |
| | | @Override() |
| | | public boolean bindInProgress() |
| | | { |
| | | // For internal operations, we don't care if there are any binds |
| | |
| | | * @param bindInProgress Specifies whether a bind operation is in |
| | | * progress on this client connection. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void setBindInProgress(boolean bindInProgress) |
| | | { |
| | | // No implementation is required. |
| | |
| | | * @return The set of operations in progress for this client |
| | | * connection. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public Collection<AbstractOperation> getOperationsInProgress() |
| | | { |
| | | return operationList; |
| | |
| | | * or <CODE>null</CODE> if no such operation could be |
| | | * found. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public AbstractOperation getOperationInProgress(int messageID) |
| | | { |
| | | // Internal operations will not be tracked. |
| | |
| | | * from the set of operations in progress, or |
| | | * <CODE>false</CODE> if not. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public boolean removeOperationInProgress(int messageID) |
| | | { |
| | | // No implementation is required, since internal operations will |
| | |
| | | * @return A cancel result that either indicates that the cancel |
| | | * was successful or provides a reason that it was not. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public CancelResult cancelOperation(int messageID, |
| | | CancelRequest cancelRequest) |
| | | { |
| | |
| | | * @param cancelRequest An object providing additional information |
| | | * about how the cancel should be processed. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void cancelAllOperations(CancelRequest cancelRequest) |
| | | { |
| | | // No implementation is required since internal operations cannot |
| | |
| | | * @param messageID The message ID of the operation that |
| | | * should not be canceled. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void cancelAllOperationsExcept(CancelRequest cancelRequest, |
| | | int messageID) |
| | | { |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a one-line summary of this client connection in a form |
| | | * that is suitable for including in the monitor entry for the |
| | | * associated connection handler. It should be in a format that is |
| | | * both humand readable and machine parseable (e.g., a |
| | | * space-delimited name-value list, with quotes around the values). |
| | | * |
| | | * @return A one-line summary of this client connection in a form |
| | | * that is suitable for including in the monitor entry for |
| | | * the associated connection handler. |
| | | */ |
| | | @Override() |
| | | public String getMonitorSummary() |
| | | { |
| | | StringBuilder buffer = new StringBuilder(); |
| | |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | @Override() |
| | | public void toString(StringBuilder buffer) |
| | | { |
| | | buffer.append("InternalClientConnection(connID="); |
| | |
| | | import org.opends.server.admin.std.server.*; |
| | | import org.opends.server.api.ClientConnection; |
| | | import org.opends.server.api.ConnectionHandler; |
| | | import org.opends.server.config.ConfigEntry; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.types.InitializationException; |
| | | import org.opends.server.types.HostPort; |
| | |
| | | * This class defines a Directory Server connection handler that will |
| | | * handle internal "connections". |
| | | */ |
| | | public class InternalConnectionHandler |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public final class InternalConnectionHandler |
| | | extends ConnectionHandler |
| | | { |
| | | |
| | | |
| | | |
| | | // The singleton instance of this internal connection handler. |
| | | private static InternalConnectionHandler handlerInstance = |
| | | new InternalConnectionHandler(); |
| | |
| | | |
| | | |
| | | /** |
| | | * Initializes this connection handler based on the information in |
| | | * the provided configuration entry. |
| | | * Initializes this connection handler provider based on the |
| | | * information in the provided connection handler configuration. |
| | | * |
| | | * @param configEntry The configuration entry that contains the |
| | | * information to use to initialize this |
| | | * connection handler. |
| | | * @param configuration The connection handler configuration that |
| | | * contains the information to use to |
| | | * initialize this connection handler. |
| | | * |
| | | * @throws ConfigException If there is a problem with the |
| | | * configuration for this connection |
| | | * handler. |
| | | * @throws ConfigException If an unrecoverable problem arises in |
| | | * the process of performing the |
| | | * initialization as a result of the |
| | | * server configuration. |
| | | * |
| | | * @throws InitializationException If a problem occurs while |
| | | * attempting to initialize this |
| | | * connection handler. |
| | | * @throws InitializationException If a problem occurs during |
| | | * initialization that is not |
| | | * related to the server |
| | | * configuration. |
| | | */ |
| | | public void initializeConnectionHandler(ConfigEntry configEntry) |
| | | throws ConfigException, InitializationException |
| | | public void initializeConnectionHandler( |
| | | ConnectionHandlerCfg configuration) |
| | | throws ConfigException, InitializationException |
| | | { |
| | | // No implementation required. |
| | | } |
| | | |
| | | |
| | |
| | | * connection handler should also be |
| | | * closed. |
| | | */ |
| | | @Override() |
| | | public void finalizeConnectionHandler(Message finalizeReason, |
| | | boolean closeConnections) |
| | | { |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a name that may be used to refer to this connection |
| | | * handler. Every connection handler instance (even handlers of the |
| | | * same type) must have a unique name. |
| | | * |
| | | * @return A unique name that may be used to refer to this |
| | | * connection handler. |
| | | */ |
| | | @Override() |
| | | public String getConnectionHandlerName() |
| | | { |
| | | return "Internal Connection Handler"; |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the name of the protocol used to communicate with |
| | | * clients. It should take into account any special naming that may |
| | | * be needed to express any security mechanisms or other constraints |
| | | * in place (e.g., "LDAPS" for LDAP over SSL). |
| | | * |
| | | * @return The name of the protocol used to communicate with |
| | | * clients. |
| | | */ |
| | | @Override() |
| | | public String getProtocol() |
| | | { |
| | | return protocol; |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves information about the listener(s) that will be used to |
| | | * accept client connections. |
| | | * |
| | | * @return Information about the listener(s) that will be used to |
| | | * accept client connections, or an empty list if this |
| | | * connection handler does not accept connections from |
| | | * network clients. |
| | | */ |
| | | @Override() |
| | | public Collection<HostPort> getListeners() |
| | | { |
| | | return listeners; |
| | |
| | | * @return The set of active client connections that have been |
| | | * established through this connection handler. |
| | | */ |
| | | @Override() |
| | | public Collection<ClientConnection> getClientConnections() |
| | | { |
| | | return connectionList; |
| | |
| | | * Operates in a loop, accepting new connections and ensuring that |
| | | * requests on those connections are handled properly. |
| | | */ |
| | | @Override() |
| | | public void run() |
| | | { |
| | | // No implementation is required since this connection handler |
| | |
| | | * |
| | | * @return A string representation of this connection handler. |
| | | */ |
| | | @Override() |
| | | public String toString() |
| | | { |
| | | return "Internal Connection Handler"; |
| | |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | @Override() |
| | | public void toString(StringBuilder buffer) |
| | | { |
| | | buffer.append("Internal Connection Handler"); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | @Override |
| | | public void initializeConnectionHandler( |
| | | ConnectionHandlerCfg configuration) |
| | | throws ConfigException, InitializationException { |
| | | // No implementation required. |
| | | } |
| | | } |
| | | |
| | |
| | | * notified of matching entries and referrals as they arrive rather |
| | | * than altogether when the search has completed. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=false) |
| | | public interface InternalSearchListener |
| | | { |
| | | /** |
| | |
| | | * and references will be queued in memory rather than sent to a |
| | | * client since there is no real client. |
| | | */ |
| | | public class InternalSearchOperation |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class InternalSearchOperation |
| | | extends SearchOperationBasis |
| | | { |
| | | // The internal search listener for this search, if one was |
| | |
| | | * the provided entry and the search |
| | | * should be terminated. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public void addSearchEntry(SearchResultEntry searchEntry) |
| | | throws DirectoryException |
| | | { |
| | |
| | | * the provided reference and the |
| | | * search should be terminated. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public void addSearchReference( |
| | | SearchResultReference searchReference) |
| | | throws DirectoryException |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Sends the provided search result entry to the client. |
| | | * |
| | | * @param searchEntry The search result entry to be sent to the |
| | | * client. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while attempting |
| | | * to send the entry to the client and |
| | | * the search should be terminated. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public void sendSearchEntry(SearchResultEntry searchEntry) |
| | | throws DirectoryException |
| | | { |
| | | throws DirectoryException |
| | | { |
| | | addSearchEntry(searchEntry); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Sends the provided search result reference to the client. |
| | | * |
| | | * @param searchReference The search result reference to be sent |
| | | * to the client. |
| | | * |
| | | * @return {@code true} if the client is able to accept referrals, |
| | | * or {@code false} if the client cannot handle referrals |
| | | * and no more attempts should be made to send them for the |
| | | * associated search operation. |
| | | * |
| | | * @throws DirectoryException If a problem occurs while attempting |
| | | * to send the reference to the client |
| | | * and the search should be terminated. |
| | | */ |
| | | public boolean sendSearchReference(SearchResultReference |
| | | searchReference) |
| | | throws DirectoryException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | @Override() |
| | | public boolean sendSearchReference( |
| | | SearchResultReference searchReference) |
| | | throws DirectoryException |
| | | { |
| | | addSearchReference(searchReference); |
| | | return true; |
| | | } |
| | | |
| | | } |
| | | |
| | |
| | | * received from a remote client using some other protocol (e.g., |
| | | * LDAP). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED) |
| | | package org.opends.server.protocols.internal; |
| | | |
| | |
| | | * </LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.protocols.jmx; |
| | | |
| | |
| | | * </LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.protocols.ldap; |
| | | |
| | |
| | | * clients over various protocols. Note that it is expected that each protocol |
| | | * will be sufficiently complex so as to warrant its own sub-package. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.protocols; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * This package contains utilities that can are used by all the packages |
| | | * below org.opends.server.replication. |
| | |
| | | * </li> |
| | | * </ul> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.replication.common; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * This package contains the code for the Multi-Master replication. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.replication; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * This package contains the part of the Multi-master |
| | | * replication code that works on the Directory Server side. |
| | |
| | | * </li> |
| | | * </ul> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.replication.plugin; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * This package contains the code used by the replication server and by the |
| | | * code running on the Directory Server side to exchange their information. |
| | |
| | | * </li> |
| | | * </ul> |
| | | */ |
| | | |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.replication.protocol; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * This package contains the code for the Replication Server part |
| | | * of the Multimaster replication feature. |
| | |
| | | * </li> |
| | | * </ul> |
| | | */ |
| | | |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.replication.server; |
| | | |
| | |
| | | * those more generic objects are defined elsewhere in the Directory Server |
| | | * codebase. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.schema; |
| | | |
| | |
| | | * only provided for historical reasons, and all active code can be found in the |
| | | * org.opends.server.replication package and its sub-packages. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.synchronization.plugin; |
| | | |
| | |
| | | * stopping and restarting the Directory Server, and adding new files into the |
| | | * server schema. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.tasks; |
| | | |
| | |
| | | * This package contains the implementation of the directory server |
| | | * configuration tool. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.tools.dsconfig; |
| | | |
| | |
| | | * types of information. The template can also define the DIT structure for the |
| | | * data to generate, as well as the number of entries of each type. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.tools.makeldif; |
| | | |
| | |
| | | * a set of default values for the protocol, address, port, use or non-use of |
| | | * SSL, etc. if no value is given. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.tools; |
| | | |
| | |
| | | * extended by the operation types included in the |
| | | * {@code org.opends.server.core} package. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class AbstractOperation |
| | | implements Operation, PreParseOperation, PostResponseOperation, |
| | | Runnable |
| | |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the operation type for this operation. |
| | | * |
| | | * @return The operation type for this operation. |
| | | */ |
| | | public abstract OperationType getOperationType(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Terminates the client connection being used to process this |
| | | * operation. If this is called by a plugin, then that plugin must |
| | | * return a result indicating that the client connection has been |
| | | * teriminated. |
| | | * |
| | | * @param disconnectReason The disconnect reason that provides the |
| | | * generic cause for the disconnect. |
| | | * @param sendNotification Indicates whether to try to provide |
| | | * notification |
| | | * to the client that the connection will |
| | | * be closed. |
| | | * @param message The message to send to the client. It |
| | | * may be {@code null} if no notification |
| | | * is to be sent. |
| | | */ |
| | | public abstract void disconnectClient( |
| | | DisconnectReason disconnectReason, |
| | | boolean sendNotification, |
| | | Message message); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a set of standard elements that should be logged in all |
| | | * requests and responses for all types of operations. Each element |
| | | * in the array will itself be a two-element array in which the |
| | | * first element is the name of the field and the second is a string |
| | | * representation of the value, or {@code null} if there is no value |
| | | * for that field. |
| | | * |
| | | * @return A standard set of elements that should be logged in |
| | | * requests and responses for all types of operations. |
| | | */ |
| | | public final String[][] getCommonLogElements() |
| | | { |
| | |
| | | }; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a standard set of elements that should be logged in |
| | | * requests for this type of operation. Each element in the array |
| | | * will itself be a two-element array in which the first element is |
| | | * the name of the field and the second is a string representation |
| | | * of the value, or {@code null} if there is no value for that |
| | | * field. |
| | | * |
| | | * @return A standard set of elements that should be logged in |
| | | * requests for this type of operation. |
| | | */ |
| | | public abstract String[][] getRequestLogElements(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a standard set of elements that should be logged in |
| | | * responses for this type of operation. Each element in the array |
| | | * will itself be a two-element array in which the first element is |
| | | * the name of the field and the second is a string representation |
| | | * of the value, or {@code null} if there is no value for that |
| | | * field. |
| | | * |
| | | * @return A standard set of elements that should be logged in |
| | | * responses for this type of operation. |
| | | */ |
| | | public abstract String[][] getResponseLogElements(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the client connection with which this operation is |
| | | * associated. |
| | | * |
| | | * @return The client connection with which this operation is |
| | | * associated. |
| | | */ |
| | | public final ClientConnection getClientConnection() |
| | | { |
| | | return clientConnection; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the unique identifier that is assigned to the client |
| | | * connection that submitted this operation. |
| | | * |
| | | * @return The unique identifier that is assigned to the client |
| | | * connection that submitted this operation. |
| | | */ |
| | | public final long getConnectionID() |
| | | { |
| | | return clientConnection.getConnectionID(); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the operation ID for this operation. |
| | | * |
| | | * @return The operation ID for this operation. |
| | | */ |
| | | public final long getOperationID() |
| | | { |
| | | return operationID; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the message ID assigned to this operation. |
| | | * |
| | | * @return The message ID assigned to this operation. |
| | | */ |
| | | public final int getMessageID() |
| | | { |
| | | return messageID; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the set of controls included in the request from the |
| | | * client. The returned list must not be altered. |
| | | * |
| | | * @return The set of controls included in the request from the |
| | | * client. |
| | | */ |
| | | public final List<Control> getRequestControls() |
| | | { |
| | | return requestControls; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Adds the provided control to the set of request controls for this |
| | | * operation. This method may only be called by pre-parse plugins. |
| | | * |
| | | * @param control The control to add to the set of request |
| | | * controls for this operation. |
| | | */ |
| | | public final void addRequestControl(Control control) |
| | | { |
| | | requestControls.add(control); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Removes the provided control from the set of request controls for |
| | | * this operation. This method may only be called by pre-parse |
| | | * plugins. |
| | | * |
| | | * @param control The control to remove from the set of request |
| | | * controls for this operation. |
| | | */ |
| | | public final void removeRequestControl(Control control) |
| | | { |
| | | requestControls.remove(control); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the set of controls to include in the response to the |
| | | * client. The contents of this list must not be altered. |
| | | * |
| | | * @return The set of controls to include in the response to the |
| | | * client. |
| | | */ |
| | | public abstract List<Control> getResponseControls(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Adds the provided control to the set of controls to include in |
| | | * the response to the client. This method may not be called by |
| | | * post-response plugins. |
| | | * |
| | | * @param control The control to add to the set of controls to |
| | | * include in the response to the client. |
| | | */ |
| | | public abstract void addResponseControl(Control control); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Removes the provided control from the set of controls to include |
| | | * in the response to the client. This method may not be called by |
| | | * post-response plugins. |
| | | * |
| | | * @param control The control to remove from the set of controls |
| | | * to include in the response to the client. |
| | | */ |
| | | public abstract void removeResponseControl(Control control); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the result code for this operation. |
| | | * |
| | | * @return The result code associated for this operation, or |
| | | * {@code UNDEFINED} if the operation has not yet |
| | | * completed. |
| | | */ |
| | | public final ResultCode getResultCode() |
| | | { |
| | | return resultCode; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the result code for this operation. This method may |
| | | * not be called by post-response plugins. |
| | | * |
| | | * @param resultCode The result code for this operation. |
| | | */ |
| | | public final void setResultCode(ResultCode resultCode) |
| | | { |
| | | this.resultCode = resultCode; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the error message for this operation. Its contents may |
| | | * be altered by pre-parse, pre-operation, and post-operation |
| | | * plugins, but not by post-response plugins. |
| | | * |
| | | * @return The error message for this operation. |
| | | */ |
| | | public final MessageBuilder getErrorMessage() |
| | | { |
| | | return errorMessage; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the error message for this operation. This method may |
| | | * not be called by post-response plugins. |
| | | * |
| | | * @param errorMessage The error message for this operation. |
| | | */ |
| | | public final void setErrorMessage(MessageBuilder errorMessage) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends the provided message to the error message buffer. If the |
| | | * buffer has not yet been created, then this will create it first |
| | | * and then add the provided message. This method may not be called |
| | | * by post-response plugins. |
| | | * |
| | | * @param message The message to append to the error message |
| | | * buffer. |
| | | */ |
| | | public final void appendErrorMessage(Message message) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the additional log message for this operation, which |
| | | * should be written to the log but not included in the response to |
| | | * the client. The contents of this buffer may be altered by |
| | | * pre-parse, pre-operation, and post-operation plugins, but not by |
| | | * post-response plugins. |
| | | * |
| | | * @return The additional log message for this operation. |
| | | */ |
| | | public final MessageBuilder getAdditionalLogMessage() |
| | | { |
| | |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the additional log message for this operation, which |
| | | * should be written to the log but not included in the response to |
| | | * the client. This method may not be called by post-response |
| | | * plugins. |
| | | * |
| | | * @param additionalLogMessage The additional log message for this |
| | | * operation. |
| | | */ |
| | | public final void setAdditionalLogMessage(MessageBuilder |
| | | additionalLogMessage) |
| | | public final void setAdditionalLogMessage( |
| | | MessageBuilder additionalLogMessage) |
| | | { |
| | | if (additionalLogMessage == null) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends the provided message to the additional log information |
| | | * for this operation. This method may not be called by |
| | | * post-response plugins. |
| | | * |
| | | * @param message The message that should be appended to the |
| | | * additional log information for this operation. |
| | | */ |
| | | public final void appendAdditionalLogMessage(Message message) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the matched DN for this operation. |
| | | * |
| | | * @return The matched DN for this operation, or {@code null} if |
| | | * the operation has not yet completed or does not have a |
| | | * matched DN. |
| | | */ |
| | | public final DN getMatchedDN() |
| | | { |
| | | return matchedDN; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the matched DN for this operation. This may not be |
| | | * called by post-response plugins. |
| | | * |
| | | * @param matchedDN The matched DN for this operation. |
| | | */ |
| | | public final void setMatchedDN(DN matchedDN) |
| | | { |
| | | this.matchedDN = matchedDN; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the set of referral URLs for this operation. Its |
| | | * contents must not be altered by the caller. |
| | | * |
| | | * @return The set of referral URLs for this operation, or |
| | | * {@code null} if the operation is not yet complete or |
| | | * does not have a set of referral URLs. |
| | | */ |
| | | public final List<String> getReferralURLs() |
| | | { |
| | | return referralURLs; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the set of referral URLs for this operation. This may |
| | | * not be called by post-response plugins. |
| | | * |
| | | * @param referralURLs The set of referral URLs for this |
| | | * operation. |
| | | */ |
| | | public final void setReferralURLs(List<String> referralURLs) |
| | | { |
| | | this.referralURLs = referralURLs; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Sets the response elements for this operation based on the |
| | | * information contained in the provided {@code DirectoryException} |
| | | * object. This method may not be called by post-response plugins. |
| | | * |
| | | * @param directoryException The exception containing the |
| | | * information to use for the response |
| | | * elements. |
| | | */ |
| | | public final void setResponseData(DirectoryException |
| | | directoryException) |
| | | public final void setResponseData( |
| | | DirectoryException directoryException) |
| | | { |
| | | this.resultCode = directoryException.getResultCode(); |
| | | this.matchedDN = directoryException.getMatchedDN(); |
| | |
| | | appendErrorMessage(directoryException.getMessageObject()); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this is an internal operation rather than one |
| | | * that was requested by an external client. |
| | | * |
| | | * @return {@code true} if this is an internal operation, or |
| | | * {@code false} if it is not. |
| | | */ |
| | | public final boolean isInternalOperation() |
| | | { |
| | | return isInternalOperation; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies whether this is an internal operation rather than one |
| | | * that was requested by an external client. This may not be called |
| | | * from within a plugin. |
| | | * |
| | | * @param isInternalOperation Specifies whether this is an |
| | | * internal operation rather than one |
| | | * that was requested by an external |
| | | * client. |
| | | */ |
| | | public final void setInternalOperation(boolean isInternalOperation) |
| | | { |
| | | this.isInternalOperation = isInternalOperation; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this is a synchronization operation rather than |
| | | * one that was requested by an external client. |
| | | * |
| | | * @return {@code true} if this is a data synchronization |
| | | * operation, or {@code false} if it is not. |
| | | */ |
| | | public final boolean isSynchronizationOperation() |
| | | { |
| | | return isSynchronizationOperation; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies whether this is a synchronization operation rather than |
| | | * one that was requested by an external client. This method may |
| | | * not be called from within a plugin. |
| | | * |
| | | * @param isSynchronizationOperation Specifies whether this is a |
| | | * synchronization operation |
| | | * rather than one that was |
| | | * requested by an external |
| | | * client. |
| | | */ |
| | | public final void setSynchronizationOperation( |
| | | boolean isSynchronizationOperation) |
| | |
| | | this.isSynchronizationOperation = isSynchronizationOperation; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this operation needs to be synchronized to |
| | | * other copies of the data. |
| | | * |
| | | * @return {@code true} if this operation should not be |
| | | * synchronized, or {@code false} if it should be |
| | | * synchronized. |
| | | */ |
| | | public boolean dontSynchronize() |
| | | { |
| | | return dontSynchronizeFlag; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies whether this operation must be synchronized to other |
| | | * copies of the data. |
| | | * |
| | | * @param dontSynchronize Specifies whether this operation must be |
| | | * synchronized to other copies |
| | | * of the data. |
| | | */ |
| | | public final void setDontSynchronize(boolean dontSynchronize) |
| | | { |
| | | this.dontSynchronizeFlag = dontSynchronize; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the entry for the user that should be considered the |
| | | * authorization identity for this operation. In many cases, it |
| | | * will be the same as the authorization entry for the underlying |
| | | * client connection, or {@code null} if no authentication has been |
| | | * performed on that connection. However, it may be some other |
| | | * value if special processing has been requested (e.g., the |
| | | * operation included a proxied authorization control). This method |
| | | * should not be called by pre-parse plugins because the correct |
| | | * value may not yet have been determined. |
| | | * |
| | | * @return The entry for the user that should be considered the |
| | | * authorization identity for this operation, or |
| | | * {@code null} if the authorization identity should be the |
| | | * unauthenticated user. |
| | | */ |
| | | public final Entry getAuthorizationEntry() |
| | | { |
| | | return authorizationEntry; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Provides the entry for the user that should be considered the |
| | | * authorization identity for this operation. This must not be |
| | | * called from within a plugin. |
| | | * |
| | | * @param authorizationEntry The entry for the user that should be |
| | | * considered the authorization identity |
| | | * for this operation, or {@code null} |
| | | * if it should be the unauthenticated |
| | | * user. |
| | | */ |
| | | public final void setAuthorizationEntry(Entry authorizationEntry) |
| | | { |
| | | this.authorizationEntry = authorizationEntry; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the authorization DN for this operation. In many |
| | | * cases, it will be the same as the DN of the authenticated user |
| | | * for the underlying connection, or the null DN if no |
| | | * authentication has been performed on that connection. However, |
| | | * it may be some other value if special processing has been |
| | | * requested (e.g., the operation included a proxied authorization |
| | | * control). This method should not be called by pre-parse plugins |
| | | * because the correct value may not have yet been determined. |
| | | * |
| | | * @return The authorization DN for this operation, or the null DN |
| | | * if it should be the unauthenticated user.. |
| | | */ |
| | | public final DN getAuthorizationDN() |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the set of attachments defined for this operation, as a |
| | | * mapping between the attachment name and the associated object. |
| | | * |
| | | * @return The set of attachments defined for this operation. |
| | | */ |
| | | public final Map<String,Object> getAttachments() |
| | | { |
| | | return attachments; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Set the attachments to the operation. |
| | | * |
| | | * @param attachments - Attachments to register within the |
| | | * operation |
| | | */ |
| | | public final void setAttachments(Map<String, Object> attachments) |
| | | { |
| | | this.attachments = attachments; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the attachment with the specified name. |
| | | * |
| | | * @param name The name for the attachment to retrieve. It will |
| | | * be treated in a case-sensitive manner. |
| | | * |
| | | * @return The requested attachment object, or {@code null} if it |
| | | * does not exist. |
| | | */ |
| | | public final Object getAttachment(String name) |
| | | { |
| | | return attachments.get(name); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Removes the attachment with the specified name. |
| | | * |
| | | * @param name The name for the attachment to remove. It will be |
| | | * treated in a case-sensitive manner. |
| | | * |
| | | * @return The attachment that was removed, or {@code null} if it |
| | | * does not exist. |
| | | */ |
| | | public final Object removeAttachment(String name) |
| | | { |
| | | return attachments.remove(name); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Sets the value of the specified attachment. If an attachment |
| | | * already exists with the same name, it will be replaced. |
| | | * Otherwise, a new attachment will be added. |
| | | * |
| | | * @param name The name to use for the attachment. |
| | | * @param value The value to use for the attachment. |
| | | * |
| | | * @return The former value held by the attachment with the given |
| | | * name, or {@code null} if there was previously no such |
| | | * attachment. |
| | | */ |
| | | public final Object setAttachment(String name, Object value) |
| | | { |
| | | return attachments.put(name, value); |
| | | } |
| | | |
| | | /** |
| | | * Performs the work of actually processing this operation. |
| | | * This should include all processing for the operation, including |
| | | * invoking plugins, logging messages, performing access control, |
| | | * managing synchronization, and any other work that might need to |
| | | * be done in the course of processing. |
| | | */ |
| | | /*public abstract void run();*/ |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates that processing on this operation has completed |
| | | * successfully and that the client should perform any associated |
| | | * cleanup work. |
| | | */ |
| | | public final void operationCompleted() |
| | | { |
| | |
| | | clientConnection.removeOperationInProgress(messageID); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Attempts to cancel this operation before processing has |
| | | * completed. |
| | | * |
| | | * @param cancelRequest Information about the way in which the |
| | | * operation should be canceled. |
| | | * |
| | | * @return A code providing information on the result of the |
| | | * cancellation. |
| | | */ |
| | | public abstract CancelResult cancel(CancelRequest cancelRequest); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Sets the cancel request for this operation, if applicable. This |
| | | * should only be used for testing purposes (e.g., for ensuring a |
| | | * cancel request is submitted before processing begins on an |
| | | * operation, or to allow for cancelling an internal operation). It |
| | | * must not be used for any other purpose. |
| | | * |
| | | * @param cancelRequest The cancel request to set for this |
| | | * operation. |
| | | * |
| | | * @return {@code true} if the cancel request was set, or |
| | | * {@code false} if it was not for some reason (e.g., the |
| | | * specified operation cannot be cancelled). |
| | | */ |
| | | public abstract boolean setCancelRequest(CancelRequest |
| | | cancelRequest); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the cancel request that has been issued for this |
| | | * operation, if there is one. This method should not be called by |
| | | * post-operation or post-response plugins. |
| | | * |
| | | * @return The cancel request that has been issued for this |
| | | * operation, or {@code null} if there has not been any |
| | | * request to cancel. |
| | | */ |
| | | public abstract CancelRequest getCancelRequest(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the cancel result for this operation. |
| | | * |
| | | * @return The cancel result for this operation. It will be |
| | | * {@code null} if the operation has not seen and reacted |
| | | * to a cancel request. |
| | | */ |
| | | public final CancelResult getCancelResult() |
| | | { |
| | | return cancelResult; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Specifies the cancel result for this operation. |
| | | * |
| | | * @param cancelResult The cancel result for this operation. |
| | | */ |
| | | public final void setCancelResult(CancelResult cancelResult) |
| | | { |
| | | this.cancelResult = cancelResult; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates that this operation has been cancelled. If |
| | | * appropriate, it will send a response to the client to indicate |
| | | * that. This method must not be called by abandon, bind, or unbind |
| | | * operations under any circumstances, nor by extended operations if |
| | | * the request OID is that of the cancel or the StartTLS operation. |
| | | * |
| | | * @param cancelRequest The request to cancel this operation. |
| | | */ |
| | | public final void indicateCancelled(CancelRequest cancelRequest) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a string representation of this operation. |
| | | * |
| | | * @return A string representation of this operation. |
| | | */ |
| | | public final String toString() |
| | | { |
| | |
| | | return buffer.toString(); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends a string representation of this operation to the provided |
| | | * buffer. |
| | | * |
| | | * @param buffer The buffer into which a string representation of |
| | | * this operation should be appended. |
| | | */ |
| | | public abstract void toString(StringBuilder buffer); |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public boolean dontSynchronize() |
| | | { |
| | | return dontSynchronizeFlag; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public final void setAttachments(Map<String, Object> attachments){ |
| | | this.attachments = attachments; |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the time that processing started for this operation. |
| | | * |
| | | * @return The time that processing started for this operation. |
| | | */ |
| | | public final long getProcessingStartTime() |
| | | { |
| | | return processingStartTime; |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public final long getProcessingStopTime() |
| | | { |
| | | return processingStopTime; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | */ |
| | | public final void setProcessingStopTime() |
| | | { |
| | | this.processingStopTime = System.currentTimeMillis(); |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Set the time at which the processing started for this operation. |
| | | */ |
| | | public final void setProcessingStartTime() |
| | | { |
| | | processingStartTime = System.currentTimeMillis(); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the time that processing stopped for this operation. |
| | | * This will actually hold a time immediately before the response |
| | | * was sent to the client. |
| | | * |
| | | * @return The time that processing stopped for this operation. |
| | | */ |
| | | public final long getProcessingStopTime() |
| | | { |
| | | return processingStopTime; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Set the time at which the processing stopped for this operation. |
| | | * This will actually hold a time immediately before the response |
| | | * was sent to the client. |
| | | */ |
| | | public final void setProcessingStopTime() |
| | | { |
| | | this.processingStopTime = System.currentTimeMillis(); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves the length of time in milliseconds that the server |
| | | * spent processing this operation. This should not be called until |
| | | * after the server has sent the response to the client. |
| | | * |
| | | * @return The length of time in milliseconds that the server spent |
| | | * processing this operation. |
| | | */ |
| | | public final long getProcessingTime() |
| | | { |
| | | return (processingStopTime - processingStartTime); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Performs the work of actually processing this operation. This |
| | | * should include all processing for the operation, including |
| | |
| | | * configuration items that may have three possible values: accept, |
| | | * reject, or warn. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum AcceptRejectWarn |
| | | { |
| | | /** |
| | |
| | | * This class defines a data type for storing information associated |
| | | * with an account status notification. |
| | | */ |
| | | public class AccountStatusNotification |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AccountStatusNotification |
| | | { |
| | | |
| | | |
| | | |
| | | // The notification type for this account status notification. |
| | | private AccountStatusNotificationType notificationType; |
| | | |
| | |
| | | * This class implements an enumeration that holds the possible event |
| | | * types that can trigger an account status notification. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum AccountStatusNotificationType |
| | | { |
| | | /** |
| | |
| | | * efficient comparisons against IP addresses to determine whether a |
| | | * particular IP address is in a given range. |
| | | */ |
| | | |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AddressMask |
| | | { |
| | | |
| | | /** |
| | | * Types of rules we have. |
| | | * |
| | |
| | | * This class defines a data structure for storing and interacting |
| | | * with an attribute that may be used in the Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class Attribute |
| | | { |
| | | /** |
| | |
| | | * ordering will be preserved when the associated fields are accessed |
| | | * via their getters or via the {@link #toString()} methods. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AttributeType |
| | | extends CommonSchemaElements |
| | | implements SchemaFileElement |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends a string representation of this schema definition's |
| | | * non-generic properties to the provided buffer. |
| | | * |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | protected void toStringContent(StringBuilder buffer) |
| | | { |
| | |
| | | * This enumeration defines the set of possible attribute usage values |
| | | * that may apply to an attribute type, as defined in RFC 2252. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum AttributeUsage |
| | | { |
| | | /** |
| | |
| | | * equality matching between two values can be performed with |
| | | * byte-for-byte comparisons of the normalized values. |
| | | */ |
| | | public class AttributeValue |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AttributeValue |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * attribute values which do not have the correct options set. This is |
| | | * achieved without having to duplicate the set of attributes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AttributeValueIterable implements |
| | | Iterable<AttributeValue> { |
| | | |
| | |
| | | /** |
| | | * Create a new attribute value iterable object. |
| | | * |
| | | * @param attributes |
| | | * The set of attributes having the same type. Can be |
| | | * <code>null</code>. |
| | | * @param attributes The set of attributes having the same type. |
| | | * Can be {@code null}. |
| | | */ |
| | | public AttributeValueIterable(Iterable<Attribute> attributes) { |
| | | this(attributes, null); |
| | |
| | | /** |
| | | * Create a new attribute value iterable object. |
| | | * |
| | | * @param attributes |
| | | * The set of attributes having the same type. Can be |
| | | * <code>null</code>. |
| | | * @param options |
| | | * The set of options which all values must contain, or |
| | | * <code>null</code> if no options are required. |
| | | * @param attributes The set of attributes having the same type. |
| | | * Can be {@code null}. |
| | | * @param options The set of options which all values must |
| | | * contain, or {@code null} if no options are |
| | | * required. |
| | | */ |
| | | public AttributeValueIterable(Iterable<Attribute> attributes, |
| | | HashSet<String> options) { |
| | | HashSet<String> options) { |
| | | |
| | | this.attributes = attributes; |
| | | this.options = options; |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves an iterator that can be used to cursor through the set |
| | | * of attribute values. |
| | | * |
| | | * @return An iterator that can be used to cursor through the set |
| | | * of attribute values. |
| | | */ |
| | | public Iterator<AttributeValue> iterator() { |
| | | |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether there are more attribute values to return. |
| | | * |
| | | * @return {@code true} if there are more attribute values to |
| | | * return, or {@code false} if not. |
| | | */ |
| | | public boolean hasNext() { |
| | | |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the next attribute value in the set. |
| | | * |
| | | * @return The next attribute value in the set. |
| | | * |
| | | * @throws NoSuchElementException If there are no more values to |
| | | * return. |
| | | */ |
| | | public AttributeValue next() { |
| | | |
| | | public AttributeValue next() |
| | | throws NoSuchElementException |
| | | { |
| | | if (hasNext == false) { |
| | | throw new NoSuchElementException(); |
| | | } |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Removes the last attribute value retrieved from the set. Note |
| | | * that this operation is not supported and will always cause an |
| | | * {@code UnsupportedOperationException} to be thrown. |
| | | * |
| | | * @throws UnsupportedOperationException If the last value |
| | | * cannot be removed. |
| | | */ |
| | | public void remove() { |
| | | |
| | | public void remove() |
| | | throws UnsupportedOperationException |
| | | { |
| | | throw new UnsupportedOperationException(); |
| | | } |
| | | |
| | |
| | | * the correct set of options until we find one that contains some |
| | | * values. |
| | | * |
| | | * @return <code>true</code> if iteration can continue, |
| | | * <code>false</code> otherwise. |
| | | * @return {@code true} if iteration can continue, or |
| | | * {@code false} if not. |
| | | */ |
| | | private boolean skipNonMatchingAttributes() { |
| | | |
| | |
| | | * user, which is not currently supported by LDAP but may be offered |
| | | * through some type of extension. |
| | | */ |
| | | public class AuthenticationInfo |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AuthenticationInfo |
| | | { |
| | | |
| | | |
| | | |
| | | // The password used to authenticate using simple authentication. |
| | | private ByteString simplePassword; |
| | | |
| | |
| | | * that may be used for a bind request. This is based on the LDAP |
| | | * specification defined in RFC 2251. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum AuthenticationType |
| | | { |
| | | /** |
| | |
| | | * prevent restoring an earlier incremental backup or the original |
| | | * full backup with which the incremental backups are associated). |
| | | */ |
| | | public class BackupConfig |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class BackupConfig |
| | | { |
| | | |
| | | |
| | | |
| | | // The path to the directory in which the backup file(s) should be |
| | | // created. |
| | | private BackupDirectory backupDirectory; |
| | |
| | | * associated with a backend. Only backups for a single backend may |
| | | * be placed in any given directory. |
| | | */ |
| | | public class BackupDirectory |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class BackupDirectory |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * This class defines a data structure for holding information about a |
| | | * backup that is available in a backup directory. |
| | | */ |
| | | public class BackupInfo |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class BackupInfo |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * also includes the necessary {@code equals} and {@code hashCode} |
| | | * methods to make it suitable for use in maps. |
| | | */ |
| | | public class ByteArray |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ByteArray |
| | | { |
| | | // The array that will be wrapped by this object. |
| | | private final byte[] array; |
| | |
| | | * a <CODE>ByteString</CODE> object is to use one of the |
| | | * <CODE>ByteStringFactory.create</CODE> methods. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface ByteString |
| | | { |
| | | /** |
| | |
| | | * This class provides static factory methods for creating ByteString |
| | | * objects. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ByteStringFactory |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a new <CODE>ByteString</CODE> object with no value. |
| | | * |
| | |
| | | |
| | | |
| | | |
| | | |
| | | /** |
| | | * This class defines a Directory Server cache entry, which is simply |
| | | * used to store an entry with its associated backend and entry ID. |
| | | */ |
| | | public class CacheEntry |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true, |
| | | notes="This should only be used within a backend") |
| | | public final class CacheEntry |
| | | { |
| | | |
| | | |
| | | |
| | | // The backend with which this cache entry is associated. |
| | | private Backend backend; |
| | | |
| | |
| | | * information about a request to cancel or abandon an operation in |
| | | * progress. |
| | | */ |
| | | public class CancelRequest |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class CancelRequest |
| | | { |
| | | |
| | | |
| | | |
| | | // Indicates whether to send a response to the original request if |
| | | // the operation is canceled. |
| | | private final boolean notifyOriginalRequestor; |
| | |
| | | * receive a response if the operation is canceled, or |
| | | * <CODE>false</CODE> if not. |
| | | */ |
| | | public final boolean notifyOriginalRequestor() |
| | | public boolean notifyOriginalRequestor() |
| | | { |
| | | return notifyOriginalRequestor; |
| | | } |
| | |
| | | * @return A message that explains the purpose for this |
| | | * cancellation. |
| | | */ |
| | | public final Message getCancelReason() |
| | | public Message getCancelReason() |
| | | { |
| | | return cancelReason; |
| | | } |
| | |
| | | * response that the server provided for the result of this |
| | | * cancellation. |
| | | */ |
| | | public final MessageBuilder getResponseMessage() |
| | | public MessageBuilder getResponseMessage() |
| | | { |
| | | return responseMessage; |
| | | } |
| | |
| | | * @param message The message to append to the response message |
| | | * buffer. |
| | | */ |
| | | public final void addResponseMessage(Message message) |
| | | public void addResponseMessage(Message message) |
| | | { |
| | | responseMessage.append(message); |
| | | } |
| | |
| | | * result from processing a cancel request. This is based on the |
| | | * specification contained in RFC 3909. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum CancelResult |
| | | { |
| | | /** |
| | |
| | | * being processed is cancelled for some reason (e.g., an abandon or |
| | | * cancel request from the client). |
| | | */ |
| | | public class CancelledOperationException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class CancelledOperationException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * @return The cancel result for this cancelled operation |
| | | * exception. |
| | | */ |
| | | public final CancelResult getCancelResult() |
| | | public CancelResult getCancelResult() |
| | | { |
| | | return cancelResult; |
| | | } |
| | | |
| | | |
| | | } |
| | | |
| | |
| | | * associated schema file to be edited so that an element created over |
| | | * protocol may be associated with a particular schema file. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class CommonSchemaElements { |
| | | |
| | | // Indicates whether this definition is declared "obsolete". |
| | |
| | | * This class provides a utility for interacting with compressed |
| | | * representations of schema elements. |
| | | */ |
| | | public class CompressedSchema |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public final class CompressedSchema |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * be undefined (i.e., "maybe"). A result of undefined indicates that |
| | | * further investigation may be required. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ConditionResult |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that can be used to hold |
| | | * information about the result of processing a configuration change. |
| | | */ |
| | | public class ConfigChangeResult |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ConfigChangeResult |
| | | { |
| | | |
| | | |
| | | |
| | | // A set of messages describing the changes that were made, any |
| | | // action that may be required, or any problems that were |
| | | // encountered. |
| | |
| | | * This class defines a data structure that holds information about a |
| | | * control that can be included in a request or response. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public class Control |
| | | { |
| | | |
| | | |
| | | |
| | | // The value for this control. |
| | | private ASN1OctetString value; |
| | | |
| | |
| | | * @param value The value for this control. |
| | | */ |
| | | public Control(String oid, boolean isCritical, |
| | | ASN1OctetString value) |
| | | ASN1OctetString value) |
| | | { |
| | | this.oid = oid; |
| | | this.isCritical = isCritical; |
| | |
| | | * |
| | | * @return The OID for this control. |
| | | */ |
| | | public String getOID() |
| | | public final String getOID() |
| | | { |
| | | return oid; |
| | | } |
| | |
| | | * |
| | | * @param oid The OID for this control. |
| | | */ |
| | | public void setOID(String oid) |
| | | public final void setOID(String oid) |
| | | { |
| | | this.oid = oid; |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this code should be considered |
| | | * critical, or <CODE>false</CODE> if not. |
| | | */ |
| | | public boolean isCritical() |
| | | public final boolean isCritical() |
| | | { |
| | | return isCritical; |
| | | } |
| | |
| | | * considered critical in processing the |
| | | * request. |
| | | */ |
| | | public void setCritical(boolean isCritical) |
| | | public final void setCritical(boolean isCritical) |
| | | { |
| | | this.isCritical = isCritical; |
| | | } |
| | |
| | | * @return The value for this control, or <CODE>null</CODE> if |
| | | * there is no value. |
| | | */ |
| | | public ASN1OctetString getValue() |
| | | public final ASN1OctetString getValue() |
| | | { |
| | | return value; |
| | | } |
| | |
| | | * @return <CODE>true</CODE> if this control has a value, or |
| | | * <CODE>false</CODE> if it does not. |
| | | */ |
| | | public boolean hasValue() |
| | | public final boolean hasValue() |
| | | { |
| | | return (value != null); |
| | | } |
| | |
| | | * |
| | | * @param value The value for this control. |
| | | */ |
| | | public void setValue(ASN1OctetString value) |
| | | public final void setValue(ASN1OctetString value) |
| | | { |
| | | this.value = value; |
| | | } |
| | |
| | | * accelerated compression may be available just as it is for |
| | | * cryptographic operations. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class CryptoManager |
| | | { |
| | | /** |
| | |
| | | * given structural objectclass, and also indicates which auxiliary |
| | | * classes that may be included in the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DITContentRule |
| | | implements SchemaFileElement |
| | | { |
| | |
| | | * This class defines a DIT structure rule, which is used to indicate |
| | | * the types of children that entries may have. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DITStructureRule |
| | | implements SchemaFileElement |
| | | { |
| | |
| | | |
| | | |
| | | |
| | | /******************** |
| | | * NOTE: Any changes to the set of non-static public methods defined |
| | | * in this class or the arguments that they contain must also |
| | | * be made in the org.opends.server.interop.LazyDN package to |
| | | * ensure continued interoperability with third-party |
| | | * applications that rely on that functionality. |
| | | ********************/ |
| | | |
| | | |
| | | |
| | | import java.io.Serializable; |
| | | import java.util.ArrayList; |
| | | |
| | |
| | | * with the distinguished names associated with entries in the |
| | | * Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class DN |
| | | implements Comparable<DN>, Serializable |
| | | { |
| | | /* |
| | | * NOTE: Any changes to the set of non-static public methods defined |
| | | * in this class or the arguments that they contain must also |
| | | * be made in the org.opends.server.interop.LazyDN package to |
| | | * ensure continued interoperability with third-party |
| | | * applications that rely on that functionality. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * The tracer object for the debug logger. |
| | | */ |
| | |
| | | /** |
| | | * Logging categories for the debug log messages. |
| | | */ |
| | | public class DebugLogCategory extends LogCategory |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DebugLogCategory extends LogCategory |
| | | { |
| | | /** |
| | | * The log category that will be used for general debug messages. |
| | |
| | | /** |
| | | * Logging levels for the debug log messages. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class DebugLogLevel extends LogLevel |
| | | { |
| | | |
| | |
| | | * operation can exhibit whenever an alias is encountered. This is |
| | | * based on the LDAP specification defined in RFC 2251. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum DereferencePolicy |
| | | { |
| | | /** |
| | |
| | | * third-party code. It is merely used to control which elements are |
| | | * intended for use by external classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DirectoryConfig |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * Retrieves a reference to the Directory Server crypto manager. |
| | | * |
| | |
| | | * attempt to change an environment configuration property while the |
| | | * server is running will be rejected. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DirectoryEnvironmentConfig |
| | | { |
| | | // The set of access loggers that should be put in place before the |
| | |
| | | * This class defines an exception that may be thrown if a problem |
| | | * occurs in the Directory Server. |
| | | */ |
| | | public class DirectoryException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DirectoryException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * |
| | | * @return The result code for this directory exception. |
| | | */ |
| | | public final ResultCode getResultCode() |
| | | public ResultCode getResultCode() |
| | | { |
| | | return resultCode; |
| | | } |
| | |
| | | * @return The matched DN for this directory exception, or |
| | | * <CODE>null</CODE> if there is none. |
| | | */ |
| | | public final DN getMatchedDN() |
| | | public DN getMatchedDN() |
| | | { |
| | | return matchedDN; |
| | | } |
| | |
| | | * @return The set of referral URLs for this directory exception, |
| | | * or <CODE>null</CODE> if there are none. |
| | | */ |
| | | public final List<String> getReferralURLs() |
| | | public List<String> getReferralURLs() |
| | | { |
| | | return referralURLs; |
| | | } |
| | |
| | | * This enumeration defines the set of possible reasons for the |
| | | * closure of a connection between a client and the Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum DisconnectReason |
| | | { |
| | | /** |
| | |
| | | * be removed or overwritten at any time, and it will be invalidated |
| | | * and removed if the entry is altered in any way. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class Entry |
| | | implements ProtocolElement |
| | | { |
| | |
| | | * This class defines a data structure that contains configuration |
| | | * information about how an entry should be encoded. |
| | | */ |
| | | public class EntryEncodeConfig |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class EntryEncodeConfig |
| | | { |
| | | /** |
| | | * The encode mask value that can be used to indicate that the |
| | |
| | | * |
| | | * TODO: delete me |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ErrorLogSeverity |
| | | { |
| | | } |
| | |
| | | * This enumeration defines the set of possible behaviors that should |
| | | * be taken when attempting to write to a file that already exists. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ExistingFileBehavior |
| | | { |
| | | /** |
| | |
| | | * the <CODE>org.opends.server.DisableExec</CODE> system property with |
| | | * a value of "true". |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class FilePermission |
| | | { |
| | | /** |
| | |
| | | * be used for search filters. This is based on the LDAP |
| | | * specification defined in RFC 2251. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum FilterType |
| | | { |
| | | /** |
| | |
| | | * port number, as may be used to accept a connection from or initiate |
| | | * a connection to a remote system. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class HostPort |
| | | { |
| | | |
| | | |
| | | // The host for this object. |
| | | private String host; |
| | | private final String host; |
| | | |
| | | // The port for this object; |
| | | private int port; |
| | | private final int port; |
| | | |
| | | |
| | | |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a hash code for this HostPort object. |
| | | * |
| | | * @return A hash code for this HostPort object. |
| | | */ |
| | | public int hashCode() |
| | | { |
| | |
| | | * exception that exposes a unique identifier for the associated |
| | | * message. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class IdentifiedException |
| | | extends OpenDsException |
| | | { |
| | |
| | | * This class defines an exception that may be thrown if a problem |
| | | * occurs while trying to initialize a Directory Server component. |
| | | */ |
| | | public class InitializationException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class InitializationException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * may be sent to the client in the form of an intermediate response. |
| | | * It may contain an OID, value, and/or set of controls. |
| | | */ |
| | | public class IntermediateResponse |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class IntermediateResponse |
| | | { |
| | | |
| | | |
| | | |
| | | // The value for this intermediate response. |
| | | private ASN1OctetString value; |
| | | |
| | |
| | | * This class defines a data structure that holds information about a |
| | | * method that may be invoked for an invokable component. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class InvokableMethod |
| | | { |
| | | /** |
| | |
| | | * This class defines an exception that may be thrown if a problem |
| | | * occurs while interacting with an LDAP protocol element. |
| | | */ |
| | | public class LDAPException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDAPException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * create an LDAP URL based on all of these individual components, as |
| | | * well as parsing them from their string representations. |
| | | */ |
| | | public class LDAPURL |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDAPURL |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * This class defines a data structure for holding configuration |
| | | * information to use when performing an LDIF export. |
| | | */ |
| | | public class LDIFExportConfig |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFExportConfig |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * This class defines a data structure for holding configuration |
| | | * information to use when performing an LDIF import. |
| | | */ |
| | | public class LDIFImportConfig |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFImportConfig |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * the state of a completed LDIF import, including the total number of |
| | | * entries read, skipped, and rejected. |
| | | */ |
| | | public class LDIFImportResult |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFImportResult |
| | | { |
| | | // The total number of entries read during the import. |
| | | private final long entriesRead; |
| | |
| | | * intended primarily for entry locking but support for other types of |
| | | * objects might be added in the future. |
| | | */ |
| | | public class LockManager |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LockManager |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * requesting that a lock be obtained for an entry or some other |
| | | * object. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum LockType |
| | | { |
| | | /** |
| | |
| | | * the set of attribute types that may be used for a given matching |
| | | * rule. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class MatchingRuleUse |
| | | implements SchemaFileElement |
| | | { |
| | |
| | | * to retrieve the next member (e.g., if the group contains a |
| | | * malformed DN or references a member that doesn't exist). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=true, |
| | | mayInvoke=true) |
| | | public abstract class MemberList |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether the group contains any more members. |
| | | * |
| | |
| | | * This class defines an exception that may be thrown if a problem |
| | | * occurs while attempting to iterate across the members of a group. |
| | | */ |
| | | public class MembershipException |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class MembershipException |
| | | extends IdentifiedException |
| | | { |
| | | /** |
| | |
| | | * |
| | | * @return The error message for this membership exception. |
| | | */ |
| | | public final Message getErrorMessage() |
| | | public Message getErrorMessage() |
| | | { |
| | | return getMessageObject(); |
| | | } |
| | |
| | | * through the list of group members, or {@code false} if |
| | | * not. |
| | | */ |
| | | public final boolean continueIterating() |
| | | public boolean continueIterating() |
| | | { |
| | | return continueIterating; |
| | | } |
| | |
| | | * with a modification that may be requested of an entry in the |
| | | * Directory Server. |
| | | */ |
| | | public class Modification |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class Modification |
| | | { |
| | | |
| | | |
| | | // The attribute for this modification. |
| | | private Attribute attribute; |
| | | |
| | |
| | | * @param modificationType The modification type for this |
| | | * modification. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public void setModificationType(ModificationType modificationType) |
| | | { |
| | | this.modificationType = modificationType; |
| | |
| | | * |
| | | * @param attribute The attribute for this modification. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public void setAttribute(Attribute attribute) |
| | | { |
| | | this.attribute = attribute; |
| | |
| | | * that may be used for an attribute modification. This is based on |
| | | * the LDAP specification defined in RFC 2251. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ModificationType |
| | | { |
| | | /** |
| | |
| | | * and/or may be used in the RDN of an entry with a given structural |
| | | * objectclass. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class NameForm |
| | | implements SchemaFileElement |
| | | { |
| | |
| | | * associate a name with a given set of characters. The name must |
| | | * consist only of ASCII alphabetic characters. |
| | | */ |
| | | public class NamedCharacterSet |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class NamedCharacterSet |
| | | { |
| | | |
| | | |
| | | |
| | | // The characters contained in this character set. |
| | | private char[] characters; |
| | | |
| | |
| | | * This class defines a custom output stream that simply discards any |
| | | * data written to it. |
| | | */ |
| | | public class NullOutputStream |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class NullOutputStream |
| | | extends OutputStream |
| | | { |
| | | /** |
| | |
| | | * fields are accessed via their getters or via the |
| | | * {@link #toString()} methods. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ObjectClass |
| | | extends CommonSchemaElements |
| | | implements SchemaFileElement |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends a string representation of this schema definition's |
| | | * non-generic properties to the provided buffer. |
| | | * |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | protected void toStringContent(StringBuilder buffer) { |
| | | |
| | |
| | | * This enumeration defines the set of possible objectclass types that |
| | | * may be used, as defined in RFC 2252. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ObjectClassType |
| | | { |
| | | /** |
| | |
| | | /** |
| | | * This class defines a base exception for OpenDS exceptions. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class OpenDsException |
| | | extends Exception |
| | | { |
| | |
| | | public Message getMessageObject() { |
| | | return this.message; |
| | | } |
| | | |
| | | } |
| | |
| | | * the quicksetup. If this must be done, the references to this |
| | | * class in SetupUtils must be removed. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum OperatingSystem |
| | | { |
| | | /** |
| | |
| | | * extended by the operation types included in the |
| | | * {@code org.opends.server.core} package. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface Operation |
| | | { |
| | | /** |
| | |
| | | * Indicates whether this operation needs to be synchronized to |
| | | * other copies of the data. |
| | | * |
| | | * @return <CODE>true</CODE> if this operation don't need to be |
| | | * synchronized, or |
| | | * <CODE>false</CODE> if it needs to be synchronized. |
| | | * @return {@code true} if this operation should not be |
| | | * synchronized, or {@code false} if it should be |
| | | * synchronized. |
| | | */ |
| | | public abstract boolean dontSynchronize(); |
| | | |
| | |
| | | * This enumeration defines the set of possible operation types that |
| | | * may be processed by the Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum OperationType |
| | | { |
| | | /** |
| | |
| | | * This class implements an enumeration that defines the set of |
| | | * privileges available in the Directory Server. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum Privilege |
| | | { |
| | | /** |
| | |
| | | ElementType.TYPE, |
| | | ElementType.METHOD, |
| | | ElementType.CONSTRUCTOR }) |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public @interface PublicAPI |
| | | { |
| | | /** |
| | |
| | | * with the relative distinguished names associated with entries in |
| | | * the Directory Server. |
| | | */ |
| | | public class RDN |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class RDN |
| | | implements Comparable<RDN> |
| | | { |
| | | /** |
| | |
| | | * unprocessed element, so it will not have undergone any syntax or |
| | | * other forms of validity checking. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class RawAttribute |
| | | { |
| | | /** |
| | |
| | | */ |
| | | private static final DebugTracer TRACER = getTracer(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a new raw attribute with the provided type and no values. |
| | | * |
| | |
| | | * interacting with a raw search filter, which defines a set of |
| | | * criteria for locating entries in a search request. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class RawFilter |
| | | { |
| | | /** |
| | |
| | | * interacting with a raw modification, which describes a change that |
| | | * should be made to an attribute. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class RawModification |
| | | { |
| | | /** |
| | |
| | | * incremental backup or the original full backup with which the |
| | | * incremental backups are associated). |
| | | */ |
| | | public class RestoreConfig |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class RestoreConfig |
| | | { |
| | | |
| | | |
| | | |
| | | // The reference to the directory containing the backup file(s) to |
| | | // restore. |
| | | private BackupDirectory backupDirectory; |
| | |
| | | * be used for providing clients with information about result of |
| | | * processing an operation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ResultCode |
| | | { |
| | | /** |
| | |
| | | * their own certificates, and whether or not to accept client |
| | | * connections in which the client did not provide a certificate. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum SSLClientAuthPolicy |
| | | { |
| | | /** |
| | |
| | | * <LI>Name form definitions</LI> |
| | | * </UL> |
| | | */ |
| | | public class Schema |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class Schema |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * |
| | | * @return The attribute type definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,AttributeType> |
| | | getAttributeTypes() |
| | | public ConcurrentHashMap<String,AttributeType> getAttributeTypes() |
| | | { |
| | | return attributeTypes; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined attribute types for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getAttributeTypeSet() |
| | | public LinkedHashSet<AttributeValue> getAttributeTypeSet() |
| | | { |
| | | return attributeTypeSet; |
| | | } |
| | |
| | | * @return The requested attribute type, or <CODE>null</CODE> if no |
| | | * type is registered with the provided name or OID. |
| | | */ |
| | | public final AttributeType getAttributeType(String lowerName) |
| | | public AttributeType getAttributeType(String lowerName) |
| | | { |
| | | return attributeTypes.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerAttributeType(AttributeType attributeType, |
| | | boolean overwriteExisting) |
| | | public void registerAttributeType(AttributeType attributeType, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (attributeTypes) |
| | |
| | | * @param attributeType The attribute type to deregister with this |
| | | * schema. |
| | | */ |
| | | public final void deregisterAttributeType( |
| | | AttributeType attributeType) |
| | | public void deregisterAttributeType(AttributeType attributeType) |
| | | { |
| | | synchronized (attributeTypes) |
| | | { |
| | |
| | | * @param superiorType The superior type for which to register |
| | | * the given attribute type as a subtype. |
| | | */ |
| | | private final void registerSubordinateType( |
| | | AttributeType attributeType, |
| | | AttributeType superiorType) |
| | | private void registerSubordinateType(AttributeType attributeType, |
| | | AttributeType superiorType) |
| | | { |
| | | List<AttributeType> subTypes = subordinateTypes.get(superiorType); |
| | | if (subTypes == null) |
| | |
| | | * @param superiorType The superior type for which to deregister |
| | | * the given attribute type as a subtype. |
| | | */ |
| | | private final void deregisterSubordinateType( |
| | | AttributeType attributeType, |
| | | AttributeType superiorType) |
| | | private void deregisterSubordinateType(AttributeType attributeType, |
| | | AttributeType superiorType) |
| | | { |
| | | List<AttributeType> subTypes = subordinateTypes.get(superiorType); |
| | | if (subTypes != null) |
| | |
| | | * type, or an empty set if there are no subtypes |
| | | * registered for the attribute type. |
| | | */ |
| | | public final Iterable<AttributeType> |
| | | getSubTypes(AttributeType attributeType) |
| | | public Iterable<AttributeType> |
| | | getSubTypes(AttributeType attributeType) |
| | | { |
| | | List<AttributeType> subTypes = |
| | | subordinateTypes.get(attributeType); |
| | |
| | | * |
| | | * @return The objectclass definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,ObjectClass> |
| | | getObjectClasses() |
| | | public ConcurrentHashMap<String,ObjectClass> getObjectClasses() |
| | | { |
| | | return objectClasses; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined objectclasses for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getObjectClassSet() |
| | | public LinkedHashSet<AttributeValue> getObjectClassSet() |
| | | { |
| | | return objectClassSet; |
| | | } |
| | |
| | | * @return The requested objectclass, or <CODE>null</CODE> if no |
| | | * class is registered with the provided name or OID. |
| | | */ |
| | | public final ObjectClass getObjectClass(String lowerName) |
| | | public ObjectClass getObjectClass(String lowerName) |
| | | { |
| | | return objectClasses.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE>. |
| | | */ |
| | | public final void registerObjectClass(ObjectClass objectClass, |
| | | boolean overwriteExisting) |
| | | public void registerObjectClass(ObjectClass objectClass, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (objectClasses) |
| | |
| | | * @param objectClass The objectclass to deregister with this |
| | | * schema. |
| | | */ |
| | | public final void deregisterObjectClass(ObjectClass objectClass) |
| | | public void deregisterObjectClass(ObjectClass objectClass) |
| | | { |
| | | synchronized (objectClasses) |
| | | { |
| | |
| | | * |
| | | * @return The attribute syntax definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,AttributeSyntax> getSyntaxes() |
| | | public ConcurrentHashMap<String,AttributeSyntax> getSyntaxes() |
| | | { |
| | | return syntaxes; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined attribute syntaxes for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getSyntaxSet() |
| | | public LinkedHashSet<AttributeValue> getSyntaxSet() |
| | | { |
| | | return syntaxSet; |
| | | } |
| | |
| | | * @return The requested attribute syntax, or <CODE>null</CODE> if |
| | | * no syntax is registered with the provided OID. |
| | | */ |
| | | public final AttributeSyntax getSyntax(String lowerName) |
| | | public AttributeSyntax getSyntax(String lowerName) |
| | | { |
| | | return syntaxes.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerSyntax(AttributeSyntax syntax, |
| | | boolean overwriteExisting) |
| | | public void registerSyntax(AttributeSyntax syntax, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (syntaxes) |
| | |
| | | * @param syntax The attribute syntax to deregister with this |
| | | * schema. |
| | | */ |
| | | public final void deregisterSyntax(AttributeSyntax syntax) |
| | | public void deregisterSyntax(AttributeSyntax syntax) |
| | | { |
| | | synchronized (syntaxes) |
| | | { |
| | |
| | | * |
| | | * @return The matching rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,MatchingRule> |
| | | getMatchingRules() |
| | | public ConcurrentHashMap<String,MatchingRule> getMatchingRules() |
| | | { |
| | | return matchingRules; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined matching rules for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getMatchingRuleSet() |
| | | public LinkedHashSet<AttributeValue> getMatchingRuleSet() |
| | | { |
| | | return matchingRuleSet; |
| | | } |
| | |
| | | * @return The requested matching rule, or <CODE>null</CODE> if no |
| | | * rule is registered with the provided name or OID. |
| | | */ |
| | | public final MatchingRule getMatchingRule(String lowerName) |
| | | public MatchingRule getMatchingRule(String lowerName) |
| | | { |
| | | return matchingRules.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerMatchingRule(MatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | public void registerMatchingRule(MatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | if (matchingRule instanceof ApproximateMatchingRule) |
| | |
| | | * @param matchingRule The matching rule to deregister with this |
| | | * schema. |
| | | */ |
| | | public final void deregisterMatchingRule(MatchingRule matchingRule) |
| | | public void deregisterMatchingRule(MatchingRule matchingRule) |
| | | { |
| | | if (matchingRule instanceof ApproximateMatchingRule) |
| | | { |
| | |
| | | * @return The approximate matching rule definitions for this |
| | | * schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,ApproximateMatchingRule> |
| | | getApproximateMatchingRules() |
| | | public ConcurrentHashMap<String,ApproximateMatchingRule> |
| | | getApproximateMatchingRules() |
| | | { |
| | | return approximateMatchingRules; |
| | | } |
| | |
| | | * approximate matching rule is registered with the |
| | | * provided name or OID. |
| | | */ |
| | | public final ApproximateMatchingRule |
| | | getApproximateMatchingRule(String lowerName) |
| | | public ApproximateMatchingRule getApproximateMatchingRule( |
| | | String lowerName) |
| | | { |
| | | return approximateMatchingRules.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerApproximateMatchingRule( |
| | | ApproximateMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | public void registerApproximateMatchingRule( |
| | | ApproximateMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (matchingRules) |
| | |
| | | * @param matchingRule The approximate matching rule to deregister |
| | | * with this schema. |
| | | */ |
| | | public final void deregisterApproximateMatchingRule( |
| | | ApproximateMatchingRule matchingRule) |
| | | public void deregisterApproximateMatchingRule( |
| | | ApproximateMatchingRule matchingRule) |
| | | { |
| | | synchronized (matchingRules) |
| | | { |
| | |
| | | * |
| | | * @return The equality matching rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,EqualityMatchingRule> |
| | | getEqualityMatchingRules() |
| | | public ConcurrentHashMap<String,EqualityMatchingRule> |
| | | getEqualityMatchingRules() |
| | | { |
| | | return equalityMatchingRules; |
| | | } |
| | |
| | | * equality matching rule is registered with the provided |
| | | * name or OID. |
| | | */ |
| | | public final EqualityMatchingRule getEqualityMatchingRule( |
| | | String lowerName) |
| | | public EqualityMatchingRule getEqualityMatchingRule( |
| | | String lowerName) |
| | | { |
| | | return equalityMatchingRules.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerEqualityMatchingRule( |
| | | EqualityMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | public void registerEqualityMatchingRule( |
| | | EqualityMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (matchingRules) |
| | |
| | | * @param matchingRule The equality matching rule to deregister |
| | | * with this schema. |
| | | */ |
| | | public final void deregisterEqualityMatchingRule( |
| | | EqualityMatchingRule matchingRule) |
| | | public void deregisterEqualityMatchingRule( |
| | | EqualityMatchingRule matchingRule) |
| | | { |
| | | synchronized (matchingRules) |
| | | { |
| | |
| | | * |
| | | * @return The ordering matching rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,OrderingMatchingRule> |
| | | getOrderingMatchingRules() |
| | | public ConcurrentHashMap<String,OrderingMatchingRule> |
| | | getOrderingMatchingRules() |
| | | { |
| | | return orderingMatchingRules; |
| | | } |
| | |
| | | * ordering matching rule is registered with the provided |
| | | * name or OID. |
| | | */ |
| | | public final OrderingMatchingRule getOrderingMatchingRule( |
| | | String lowerName) |
| | | public OrderingMatchingRule getOrderingMatchingRule( |
| | | String lowerName) |
| | | { |
| | | return orderingMatchingRules.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerOrderingMatchingRule( |
| | | OrderingMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | public void registerOrderingMatchingRule( |
| | | OrderingMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (matchingRules) |
| | |
| | | * @param matchingRule The ordering matching rule to deregister |
| | | * with this schema. |
| | | */ |
| | | public final void deregisterOrderingMatchingRule( |
| | | OrderingMatchingRule matchingRule) |
| | | public void deregisterOrderingMatchingRule( |
| | | OrderingMatchingRule matchingRule) |
| | | { |
| | | synchronized (matchingRules) |
| | | { |
| | |
| | | * |
| | | * @return The substring matching rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,SubstringMatchingRule> |
| | | getSubstringMatchingRules() |
| | | public ConcurrentHashMap<String,SubstringMatchingRule> |
| | | getSubstringMatchingRules() |
| | | { |
| | | return substringMatchingRules; |
| | | } |
| | |
| | | * substring matching rule is registered with the provided |
| | | * name or OID. |
| | | */ |
| | | public final SubstringMatchingRule getSubstringMatchingRule( |
| | | String lowerName) |
| | | public SubstringMatchingRule getSubstringMatchingRule( |
| | | String lowerName) |
| | | { |
| | | return substringMatchingRules.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerSubstringMatchingRule( |
| | | SubstringMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | public void registerSubstringMatchingRule( |
| | | SubstringMatchingRule matchingRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (matchingRules) |
| | |
| | | * @param matchingRule The substring matching rule to deregister |
| | | * with this schema. |
| | | */ |
| | | public final void deregisterSubstringMatchingRule( |
| | | SubstringMatchingRule matchingRule) |
| | | public void deregisterSubstringMatchingRule( |
| | | SubstringMatchingRule matchingRule) |
| | | { |
| | | synchronized (matchingRules) |
| | | { |
| | |
| | | * |
| | | * @return The matching rule use definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<MatchingRule,MatchingRuleUse> |
| | | getMatchingRuleUses() |
| | | public ConcurrentHashMap<MatchingRule,MatchingRuleUse> |
| | | getMatchingRuleUses() |
| | | { |
| | | return matchingRuleUses; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined matching rule uses for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getMatchingRuleUseSet() |
| | | public LinkedHashSet<AttributeValue> getMatchingRuleUseSet() |
| | | { |
| | | return matchingRuleUseSet; |
| | | } |
| | |
| | | * @return The matching rule use definition, or <CODE>null</CODE> |
| | | * if none exists for the specified matching rule. |
| | | */ |
| | | public final MatchingRuleUse getMatchingRuleUse( |
| | | MatchingRule matchingRule) |
| | | public MatchingRuleUse getMatchingRuleUse(MatchingRule matchingRule) |
| | | { |
| | | return matchingRuleUses.get(matchingRule); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerMatchingRuleUse( |
| | | MatchingRuleUse matchingRuleUse, |
| | | boolean overwriteExisting) |
| | | public void registerMatchingRuleUse(MatchingRuleUse matchingRuleUse, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (matchingRuleUses) |
| | |
| | | * @param matchingRuleUse The matching rule use to deregister with |
| | | * this schema. |
| | | */ |
| | | public final void deregisterMatchingRuleUse( |
| | | MatchingRuleUse matchingRuleUse) |
| | | public void deregisterMatchingRuleUse( |
| | | MatchingRuleUse matchingRuleUse) |
| | | { |
| | | synchronized (matchingRuleUses) |
| | | { |
| | |
| | | * |
| | | * @return The DIT content rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<ObjectClass,DITContentRule> |
| | | getDITContentRules() |
| | | public ConcurrentHashMap<ObjectClass,DITContentRule> |
| | | getDITContentRules() |
| | | { |
| | | return ditContentRules; |
| | | } |
| | |
| | | * |
| | | * @return The set of defined DIT content rules for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getDITContentRuleSet() |
| | | public LinkedHashSet<AttributeValue> getDITContentRuleSet() |
| | | { |
| | | return ditContentRuleSet; |
| | | } |
| | |
| | | * no DIT content rule is registered with the provided |
| | | * objectclass. |
| | | */ |
| | | public final DITContentRule getDITContentRule( |
| | | ObjectClass objectClass) |
| | | public DITContentRule getDITContentRule(ObjectClass objectClass) |
| | | { |
| | | return ditContentRules.get(objectClass); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerDITContentRule( |
| | | DITContentRule ditContentRule, |
| | | boolean overwriteExisting) |
| | | public void registerDITContentRule(DITContentRule ditContentRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (ditContentRules) |
| | |
| | | * @param ditContentRule The DIT content rule to deregister with |
| | | * this schema. |
| | | */ |
| | | public final void deregisterDITContentRule( |
| | | DITContentRule ditContentRule) |
| | | public void deregisterDITContentRule(DITContentRule ditContentRule) |
| | | { |
| | | synchronized (ditContentRules) |
| | | { |
| | |
| | | * |
| | | * @return The set of defined DIT structure rules for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getDITStructureRuleSet() |
| | | public LinkedHashSet<AttributeValue> getDITStructureRuleSet() |
| | | { |
| | | return ditStructureRuleSet; |
| | | } |
| | |
| | | * |
| | | * @return The DIT structure rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<Integer,DITStructureRule> |
| | | getDITStructureRulesByID() |
| | | public ConcurrentHashMap<Integer,DITStructureRule> |
| | | getDITStructureRulesByID() |
| | | { |
| | | return ditStructureRulesByID; |
| | | } |
| | |
| | | * |
| | | * @return The DIT structure rule definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<NameForm,DITStructureRule> |
| | | getDITStructureRulesByNameForm() |
| | | public ConcurrentHashMap<NameForm,DITStructureRule> |
| | | getDITStructureRulesByNameForm() |
| | | { |
| | | return ditStructureRulesByNameForm; |
| | | } |
| | |
| | | * if no DIT structure rule is registered with the provided |
| | | * rule ID. |
| | | */ |
| | | public final DITStructureRule getDITStructureRule(int ruleID) |
| | | public DITStructureRule getDITStructureRule(int ruleID) |
| | | { |
| | | return ditStructureRulesByID.get(ruleID); |
| | | } |
| | |
| | | * if no DIT structure rule is registered with the provided |
| | | * name form. |
| | | */ |
| | | public final DITStructureRule getDITStructureRule(NameForm nameForm) |
| | | public DITStructureRule getDITStructureRule(NameForm nameForm) |
| | | { |
| | | return ditStructureRulesByNameForm.get(nameForm); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerDITStructureRule( |
| | | DITStructureRule ditStructureRule, |
| | | boolean overwriteExisting) |
| | | public void registerDITStructureRule( |
| | | DITStructureRule ditStructureRule, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (ditStructureRulesByNameForm) |
| | |
| | | * @param ditStructureRule The DIT structure rule to deregister |
| | | * with this schema. |
| | | */ |
| | | public final void deregisterDITStructureRule( |
| | | DITStructureRule ditStructureRule) |
| | | public void deregisterDITStructureRule( |
| | | DITStructureRule ditStructureRule) |
| | | { |
| | | synchronized (ditStructureRulesByNameForm) |
| | | { |
| | |
| | | * |
| | | * @return The set of defined name forms for this schema. |
| | | */ |
| | | public final LinkedHashSet<AttributeValue> getNameFormSet() |
| | | public LinkedHashSet<AttributeValue> getNameFormSet() |
| | | { |
| | | return nameFormSet; |
| | | } |
| | |
| | | * |
| | | * @return The name form definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<ObjectClass,NameForm> |
| | | getNameFormsByObjectClass() |
| | | public ConcurrentHashMap<ObjectClass,NameForm> |
| | | getNameFormsByObjectClass() |
| | | { |
| | | return nameFormsByOC; |
| | | } |
| | |
| | | * |
| | | * @return The name form definitions for this schema. |
| | | */ |
| | | public final ConcurrentHashMap<String,NameForm> |
| | | getNameFormsByNameOrOID() |
| | | public ConcurrentHashMap<String,NameForm> getNameFormsByNameOrOID() |
| | | { |
| | | return nameFormsByName; |
| | | } |
| | |
| | | * @return The requested name form, or <CODE>null</CODE> if no name |
| | | * form is registered with the provided objectClass. |
| | | */ |
| | | public final NameForm getNameForm(ObjectClass objectClass) |
| | | public NameForm getNameForm(ObjectClass objectClass) |
| | | { |
| | | return nameFormsByOC.get(objectClass); |
| | | } |
| | |
| | | * @return The requested name form, or <CODE>null</CODE> if no name |
| | | * form is registered with the provided name or OID. |
| | | */ |
| | | public final NameForm getNameForm(String lowerName) |
| | | public NameForm getNameForm(String lowerName) |
| | | { |
| | | return nameFormsByName.get(lowerName); |
| | | } |
| | |
| | | * <CODE>overwriteExisting</CODE> flag |
| | | * is set to <CODE>false</CODE> |
| | | */ |
| | | public final void registerNameForm(NameForm nameForm, |
| | | boolean overwriteExisting) |
| | | public void registerNameForm(NameForm nameForm, |
| | | boolean overwriteExisting) |
| | | throws DirectoryException |
| | | { |
| | | synchronized (nameFormsByOC) |
| | |
| | | * |
| | | * @param nameForm The name form definition to deregister. |
| | | */ |
| | | public final void deregisterNameForm(NameForm nameForm) |
| | | public void deregisterNameForm(NameForm nameForm) |
| | | { |
| | | synchronized (nameFormsByOC) |
| | | { |
| | |
| | | * @throws DirectoryException If a problem occurs while rebuilding |
| | | * any of the schema elements. |
| | | */ |
| | | public final void rebuildDependentElements( |
| | | SchemaFileElement element) |
| | | public void rebuildDependentElements(SchemaFileElement element) |
| | | throws DirectoryException |
| | | { |
| | | try |
| | |
| | | * @throws DirectoryException If a problem occurs while rebuilding |
| | | * any of the schema elements. |
| | | */ |
| | | private final void rebuildDependentElements( |
| | | SchemaFileElement element, int depth) |
| | | private void rebuildDependentElements(SchemaFileElement element, |
| | | int depth) |
| | | throws DirectoryException |
| | | { |
| | | if (depth > 20) |
| | |
| | | * @return A new <CODE>Schema</CODE> object that is a duplicate of |
| | | * this one. |
| | | */ |
| | | public final Schema duplicate() |
| | | public Schema duplicate() |
| | | { |
| | | Schema dupSchema = new Schema(); |
| | | |
| | |
| | | * <LI>{@code org.opends.server.types.MatchingRuleUse}</LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface SchemaFileElement |
| | | { |
| | | /** |
| | |
| | | * with a search filter that may serve as criteria for locating |
| | | * entries in the Directory Server. |
| | | */ |
| | | public class SearchFilter |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SearchFilter |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * types and values, the objectclass attribute will not be present in |
| | | * the user attributes. |
| | | */ |
| | | public class SearchResultEntry |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SearchResultEntry |
| | | extends Entry |
| | | { |
| | | |
| | | |
| | | |
| | | // The set of controls associated with this search result entry. |
| | | private List<Control> controls; |
| | | |
| | |
| | | * This class defines a data structure for storing information about a |
| | | * referral returned while processing a search request. |
| | | */ |
| | | public class SearchResultReference |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SearchResultReference |
| | | { |
| | | |
| | | |
| | | |
| | | // The set of controls associated with this search result reference. |
| | | private List<Control> controls; |
| | | |
| | |
| | | * defined in RFC 2251 but also includes the subordinate subtree |
| | | * search scope defined in draft-sermersheim-ldap-subordinate-scope. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum SearchScope |
| | | { |
| | | /** |
| | |
| | | * the sorting process, although if none is provided it will use the |
| | | * default ordering matching rule for the attribute type. |
| | | */ |
| | | public class SortKey |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SortKey |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * If all of the sort key attributes for two entries are identical, |
| | | * then the relative order for those entries is undefined. |
| | | */ |
| | | public class SortOrder |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SortOrder |
| | | { |
| | | // The set of sort keys in this sort order. |
| | | private SortKey[] sortKeys; |
| | |
| | | * explicit stability level, then it should be assumed that it has the |
| | | * same stability level as the class that contains it. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum StabilityLevel |
| | | { |
| | | /** |
| | |
| | | * This class defines a data structure that holds information about |
| | | * the result of processing by a synchronization provider. |
| | | */ |
| | | public class SynchronizationProviderResult |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SynchronizationProviderResult |
| | | { |
| | | |
| | | |
| | | |
| | | // Indicates whether processing should continue on the operation. |
| | | private boolean continueOperationProcessing; |
| | | |
| | |
| | | * attribute whose values do not actually exist in persistent storage |
| | | * but rather are computed or otherwise obtained dynamically. |
| | | */ |
| | | public class VirtualAttribute |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class VirtualAttribute |
| | | extends Attribute |
| | | { |
| | | // The entry with which this virtual attribute is associated. |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves the set of values for this attribute. The returned set |
| | | * of values may be altered by the caller. |
| | | * |
| | | * @return The set of values for this attribute. |
| | | */ |
| | | @Override() |
| | | public LinkedHashSet<AttributeValue> getValues() |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute contains one or more values. |
| | | * |
| | | * @return <CODE>true</CODE> if this attribute contains one or more |
| | | * values, or <CODE>false</CODE> if it does not. |
| | | */ |
| | | @Override() |
| | | public boolean hasValue() |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute contains the specified value. |
| | | * |
| | | * @param value The value for which to make the determination. |
| | | * |
| | | * @return <CODE>true</CODE> if this attribute has the specified |
| | | * value, or <CODE>false</CODE> if not. |
| | | */ |
| | | @Override() |
| | | public boolean hasValue(AttributeValue value) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute contains all the values in the |
| | | * collection. |
| | | * |
| | | * @param values The set of values for which to make the |
| | | * determination. |
| | | * |
| | | * @return <CODE>true</CODE> if this attribute contains all the |
| | | * values in the provided collection, or <CODE>false</CODE> |
| | | * if it does not contain at least one of them. |
| | | */ |
| | | @Override() |
| | | public boolean hasAllValues(Collection<AttributeValue> values) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute contains any of the values in |
| | | * the collection. |
| | | * |
| | | * @param values The set of values for which to make the |
| | | * determination. |
| | | * |
| | | * @return <CODE>true</CODE> if this attribute contains at least |
| | | * one of the values in the provided collection, or |
| | | * <CODE>false</CODE> if it does not contain any of the |
| | | * values. |
| | | */ |
| | | @Override() |
| | | public boolean hasAnyValue(Collection<AttributeValue> values) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute has any value(s) that match the |
| | | * provided substring. |
| | | * |
| | | * @param subInitial The subInitial component to use in the |
| | | * determination. |
| | | * @param subAny The subAny components to use in the |
| | | * determination. |
| | | * @param subFinal The subFinal component to use in the |
| | | * determination. |
| | | * |
| | | * @return <CODE>UNDEFINED</CODE> if this attribute does not have a |
| | | * substring matching rule, <CODE>TRUE</CODE> if at least |
| | | * one value matches the provided substring, or |
| | | * <CODE>FALSE</CODE> otherwise. |
| | | */ |
| | | @Override() |
| | | public ConditionResult matchesSubstring(ByteString subInitial, |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute has any value(s) that are |
| | | * greater than or equal to the provided value. |
| | | * |
| | | * @param value The value for which to make the determination. |
| | | * |
| | | * @return <CODE>UNDEFINED</CODE> if this attribute does not have |
| | | * an ordering matching rule, <CODE>TRUE</CODE> if at least |
| | | * one value is greater than or equal to the provided |
| | | * value, or <CODE>false</CODE> otherwise. |
| | | */ |
| | | @Override() |
| | | public ConditionResult greaterThanOrEqualTo(AttributeValue value) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute has any value(s) that are less |
| | | * than or equal to the provided value. |
| | | * |
| | | * @param value The value for which to make the determination. |
| | | * |
| | | * @return <CODE>UNDEFINED</CODE> if this attribute does not have |
| | | * an ordering matching rule, <CODE>TRUE</CODE> if at least |
| | | * one value is less than or equal to the provided value, |
| | | * or <CODE>false</CODE> otherwise. |
| | | */ |
| | | @Override() |
| | | public ConditionResult lessThanOrEqualTo(AttributeValue value) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this attribute has any value(s) that are |
| | | * approximately equal to the provided value. |
| | | * |
| | | * @param value The value for which to make the determination. |
| | | * |
| | | * @return <CODE>UNDEFINED</CODE> if this attribute does not have |
| | | * an approximate matching rule, <CODE>TRUE</CODE> if at |
| | | * least one value is approximately equal to the provided |
| | | * value, or <CODE>false</CODE> otherwise. |
| | | */ |
| | | @Override() |
| | | public ConditionResult approximatelyEqualTo(AttributeValue value) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Indicates whether this is a virtual attribute rather than a real |
| | | * attribute. |
| | | * |
| | | * @return {@code true} if this is a virtual attribute, or |
| | | * {@code false} if it is a real attribute. |
| | | */ |
| | | @Override() |
| | | public boolean isVirtual() |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Creates a duplicate of this attribute that can be modified |
| | | * without impacting this attribute. |
| | | * |
| | | * @param omitValues <CODE>true</CODE> if the values should be |
| | | * omitted. |
| | | * |
| | | * @return A duplicate of this attribute that can be modified |
| | | * without impacting this attribute. |
| | | */ |
| | | @Override() |
| | | public Attribute duplicate(boolean omitValues) |
| | |
| | | |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Appends a one-line string representation of this attribute to the |
| | | * provided buffer. |
| | | * |
| | | * @param buffer The buffer to which the information should be |
| | | * appended. |
| | | */ |
| | | @Override() |
| | | public void toString(StringBuilder buffer) |
| | |
| | | * attribute, and how conflicts between real and virtual values should |
| | | * be handled. |
| | | */ |
| | | public class VirtualAttributeRule |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class VirtualAttributeRule |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * backend. The writability mode may be "enabled", "disabled", or |
| | | * "internal-only". |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum WritabilityMode |
| | | { |
| | | /** |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface InProgressOperation |
| | | extends PluginOperation |
| | | { |
| | |
| | | * this interface is intended only to define an API for use by plugins |
| | | * and is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PluginOperation |
| | | { |
| | | /** |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationAbandonOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationAddOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationBindOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationCompareOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationDeleteOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationExtendedOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationModifyDNOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationModifyOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationOperation |
| | | extends PluginOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationSearchOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostOperationUnbindOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseAddOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseBindOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseCompareOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseDeleteOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseExtendedOperation |
| | | extends PostOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseModifyDNOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseModifyOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseOperation |
| | | extends PluginOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PostResponseSearchOperation |
| | | extends PostResponseOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationAddOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationBindOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationCompareOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationDeleteOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationExtendedOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationModifyDNOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationModifyOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationOperation |
| | | extends PluginOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreOperationSearchOperation |
| | | extends PreOperationOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseAbandonOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseAddOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseBindOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseCompareOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseDeleteOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseExtendedOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseModifyDNOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseModifyOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * interface is intended only to define an API for use by plugins and |
| | | * is not intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseOperation |
| | | extends PluginOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseSearchOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface PreParseUnbindOperation |
| | | extends PreParseOperation |
| | | { |
| | |
| | | * only to define an API for use by plugins and is not intended to be |
| | | * implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface SearchEntrySearchOperation |
| | | extends InProgressOperation |
| | | { |
| | |
| | | * intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface SearchReferenceSearchOperation |
| | | extends InProgressOperation |
| | | { |
| | |
| | | * is intended only to define an API for use by plugins and is not |
| | | * intended to be implemented by any custom classes. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public interface SubordinateModifyDNOperation |
| | | extends InProgressOperation |
| | | { |
| | |
| | | * intended to be implemented by any custom code. They should be |
| | | * implemented only by the core Directory Server operation types. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED) |
| | | package org.opends.server.types.operation; |
| | | |
| | |
| | | * authoritative information on what classes are considered part of |
| | | * the public API. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE) |
| | | package org.opends.server.types; |
| | | |
| | |
| | | * an add operation. It includes a DN and a set of attributes, as well as |
| | | * methods to decode the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class AddChangeRecordEntry extends ChangeRecordEntry |
| | | { |
| | | |
| | |
| | | * sets of three bytes with eight significant bits each to sets of four bytes |
| | | * with six significant bits each. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class Base64 |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * The set of characters that may be used in base64-encoded values. |
| | | */ |
| | |
| | | * Represents a particular version of OpenDS useful for making |
| | | * comparisons between versions. |
| | | */ |
| | | public class BuildVersion implements Comparable<BuildVersion> { |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class BuildVersion implements Comparable<BuildVersion> { |
| | | |
| | | /** Major release number. */ |
| | | int major; |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves an integer value that indicates the relative order between this |
| | | * build version and the provided build version object. |
| | | * |
| | | * @param version The build version object for which to make the |
| | | * determination. |
| | | * |
| | | * @return A negative integer if this build version should be ordered before |
| | | * the provided build version in a sorted list, a positive integer if |
| | | * this build version should be ordered after the provided build |
| | | * version in a sorted list, or zero if there is no difference in the |
| | | * relative order between the build version objects. |
| | | */ |
| | | public int compareTo(BuildVersion version) { |
| | | if (major == version.major) { |
| | |
| | | * the caller should gracefully degrade and suggest that the user perform the |
| | | * operation manually. |
| | | */ |
| | | public class CertificateManager |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class CertificateManager |
| | | { |
| | | /** |
| | | * The path to the keytool command, which will be required to perform |
| | |
| | | /** |
| | | * This enumeration defines the days of the week. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public enum ChangeOperationType |
| | | { |
| | | /** |
| | |
| | | * includes operations to get the DN, as well as methods to |
| | | * decode the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public abstract class ChangeRecordEntry |
| | | { |
| | | |
| | | |
| | | // The DN for this entry. |
| | | private DN dn; |
| | | |
| | |
| | | /** |
| | | * UNIX Crypt cipher, ported from the Sun OpenSolaris project. |
| | | * */ |
| | | public class Crypt |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class Crypt |
| | | { |
| | | |
| | | /* LINTLIBRARY */ |
| | |
| | | * an delete operation. It includes a DN and a set of attributes, as well as |
| | | * methods to decode the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class DeleteChangeRecordEntry extends ChangeRecordEntry |
| | | { |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a new entry with the provided information. |
| | | * |
| | |
| | | { |
| | | return ChangeOperationType.DELETE; |
| | | } |
| | | |
| | | } |
| | | |
| | |
| | | * recipients via SMTP. This is a wrapper around JavaMail to make this process |
| | | * more convenient and fit better into the Directory Server framework. |
| | | */ |
| | | public class EMailMessage |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class EMailMessage |
| | | { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * embedded manner (i.e., running within the same JVM as another application and |
| | | * controlled by that application). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class EmbeddedUtils |
| | | { |
| | | /** |
| | |
| | | * existing trust manager and makes it possible to reject a presented |
| | | * certificate if that certificate is outside the validity window. |
| | | */ |
| | | public class ExpirationCheckTrustManager |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ExpirationCheckTrustManager |
| | | implements X509TrustManager |
| | | { |
| | | // The trust manager that is wrapped by this trust manager. |
| | |
| | | * This class defines an exception that may be thrown while attempting to parse |
| | | * LDIF content. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFException |
| | | extends IdentifiedException |
| | | { |
| | |
| | | * provides support for both standard entries and change entries (as would be |
| | | * used with a tool like ldapmodify). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFReader |
| | | { |
| | | /** |
| | |
| | | * This class provides a mechanism for writing entries in LDIF form to a file or |
| | | * an output stream. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LDIFWriter |
| | | { |
| | | /** |
| | |
| | | * Doing it in this way eliminates copyright and licensing concerns associated |
| | | * with using an existing implementation. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class LevenshteinDistance |
| | | { |
| | | /** |
| | |
| | | * an modify operation. It includes a DN and a set of attributes, as well as |
| | | * methods to decode the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ModifyChangeRecordEntry extends ChangeRecordEntry |
| | | { |
| | | |
| | | |
| | | /** |
| | | * The modifications for this change record. |
| | | */ |
| | |
| | | * an modifyDN operation. It includes a DN and a set of attributes, as well as |
| | | * methods to decode the entry. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ModifyDNChangeRecordEntry extends ChangeRecordEntry |
| | | { |
| | | |
| | | // The new RDN. |
| | | private final RDN newRDN; |
| | | |
| | |
| | | * write all messages to multiple targets at the same time, much like the UNIX |
| | | * "tee" command. Note that this class will never throw any exceptions |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class MultiOutputStream |
| | | extends OutputStream |
| | | { |
| | |
| | | * available and to invoke it if it is so that the code will still compile |
| | | * cleanly on Java 5 systems. |
| | | */ |
| | | public class PasswordReader |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class PasswordReader |
| | | extends DirectoryThread |
| | | { |
| | | // Indicates whether the backspace thread should keep looping, sending |
| | |
| | | * maximum allowed value to reduce the chance of one or more characters being |
| | | * displayed temporarily before they can be erased. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=false) |
| | | public void run() |
| | | { |
| | | Thread currentThread = Thread.currentThread(); |
| | |
| | | * selection will be based on the alias (also called the nickname) of the |
| | | * certificate. |
| | | */ |
| | | public class SelectableCertificateKeyManager |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=true, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class SelectableCertificateKeyManager |
| | | extends X509ExtendedKeyManager |
| | | { |
| | | // The alias of the certificate that should be selected from the key manager. |
| | |
| | | * This class defines a set of constants that may be referenced throughout the |
| | | * Directory Server source. |
| | | */ |
| | | public class ServerConstants |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class ServerConstants |
| | | { |
| | | /** |
| | | * The end-of-line character for this platform. |
| | |
| | | * This class provides a number of utility methods that may be used during the |
| | | * graphical or command-line setup process. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class SetupUtils |
| | | { |
| | | /** |
| | |
| | | * to prevent the log from filling up with unimportant calls and to reduce the |
| | | * impact that debugging may have on performance. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class StaticUtils |
| | | { |
| | | /** |
| | |
| | | * debugging will be performed in this class due to the frequency with which it |
| | | * will be called. |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class TimeThread |
| | | extends DirectoryThread |
| | | { |
| | |
| | | * failed</li> |
| | | * </ul> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.UNCOMMITTED, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public class Validator { |
| | | /** |
| | | * The tracer object for the debug logger. |
| | |
| | | * or reversion may required additional steps, notification of issues, or |
| | | * be prohibitted altogether. |
| | | */ |
| | | public class VersionCompatibilityIssue { |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE, |
| | | mayInstantiate=false, |
| | | mayExtend=false, |
| | | mayInvoke=true) |
| | | public final class VersionCompatibilityIssue { |
| | | |
| | | //*************************************************** |
| | | // |
| | |
| | | } |
| | | |
| | | /** |
| | | * {@inheritDoc} |
| | | * Retrieves a string representation of this version compatibility issue. |
| | | * |
| | | * @return A string representation of this version compatibility issue. |
| | | */ |
| | | public String toString() { |
| | | return Integer.toString(cause.getId()); |
| | |
| | | * command has a number of sub-commands like "checkout" and "commit" and "diff", |
| | | * each of which has its own set of options). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.util.args; |
| | | |
| | |
| | | * </LI> |
| | | * </UL> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.VOLATILE) |
| | | package org.opends.server.util; |
| | | |
| | |
| | | * Portions Copyright 2006-2007 Sun Microsystems, Inc. |
| | | */ |
| | | |
| | | |
| | | |
| | | /** |
| | | * Provides support for construction and display of tables in text based |
| | | * applications. Applications construct tables using the {@link TableBuilder} |
| | |
| | | * Charlie : 33 |
| | | * </pre> |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.util.table; |
| | | |
| | | |
| | | |
| | |
| | | * are used to process operations against data stored in local backend databases |
| | | * and other repositories that are considered "local". |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.workflowelement.localbackend; |
| | | |
| | |
| | | * Different kinds of workflow elements are needed for different server roles |
| | | * (e.g., local data storage, proxy/distribution/virtual access, etc.). |
| | | */ |
| | | @org.opends.server.types.PublicAPI( |
| | | stability=org.opends.server.types.StabilityLevel.PRIVATE) |
| | | package org.opends.server.workflowelement; |
| | | |
| | |
| | | InternalConnectionHandler handler = InternalConnectionHandler.getInstance(); |
| | | assertNotNull(handler); |
| | | |
| | | handler.initializeConnectionHandler((ConfigEntry) null); |
| | | handler.initializeConnectionHandler(null); |
| | | } |
| | | |
| | | |