| | |
| | | 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); |
| | | } |
| | | |
| | | |