UnboundID LDAP SDK for Java

Product Information

Release Notes

Version 1.1.2

The following changes were made between the 1.1.1 and 1.1.2 releases:

Improved the behavior of the AttributeTypeDefinition class so that it can better deal with attribute type definitions whose syntax element contains the optional minimum upper bound component. The getSyntaxOID() method still returns the complete syntax OID (including the minimum upper bound, if present), but a new getBaseSyntaxOID() method has been added that can be used to obtain the syntax OID without the minimum upper bound, and a getSyntaxMinimumUpperBound() method has been added that can be used to obtain the minimum upper bound (or -1 if no minimum upper bound is defined). In addition, the Schema.getAttributeSyntax method has been updated so that it will ignore any minimum upper bound portion that may be included in the provided OID.
Added a new Entry.diff method that makes it possible to indicate whether you want the resulting modifications to be reversible. If the modifications should be reversible (which was always the case in the past), then the resulting list will contain only modifications with the ADD and DELETE modification types, which could be played in reverse to recreate the source entry from the target entry, but is more likely to fail if the entry has been altered in some way since attempting to apply the modifications. If the modifications should not be reversible, then they will all use the REPLACE modification type, which is not reversible but more likely to succeed even if the entry has been altered.
Improved the way that the LDAP SDK generates string representations of DNs and RDNs. When creating a DN from a set of RDNs (or from an RDN and parent DN), it will now use the string representations of the provided RDNs (and optionally DN) rather than reconstructing the entire string representation. This can help preserve a user-supplied string representation if you do something like "new DN(existingDN.getRDNs())", particularly if the existing DN had characters that may be escaped but don't have to be. In addition, a new toMinimallyEncodedString method has been added to both the DN and RDN classes which will construct a string representation of the DN or RDN with a minimal set of escaped characters (e.g., non-ASCII characters and non-printible ASCII characters will not be escaped).
Fixed a bug in the LDIF reader in which it would refuse to decode an entry containing only a DN but no attributes (e.g., like might be the case with a search result entry where the requested attribute set contained only "1.1").
Fixed a bug in the way that LDAP URLs were generated for URLs containing the subordinate subtree search scope. Previously, the string representation of such URLs would have a scope of "subord" instead of the correct "subordinates" as specified in draft-sermersheim-ldap-subordinate-scope. It will still accept URLs containing "subord", but will no longer generate them.
Fixed a bug in the LDAPCommandLineTool class that prevented the --bindPasswordFile argument from being used in conjunction with the --bindDN argument. Due to an oversight, --bindPasswordFile could only be used when performing SASL authentication when no bind DN was given.

Version 1.1.1

The following changes were made between the 1.1.0 and 1.1.1 releases:

Updated the searchrate, modrate, and authrate tools to change the way that they signal the processing threads to start. The previous approach could lead to resource starvation causing the system to run with 100% CPU utilization for a period of time.
Improved the accuracy of the searchrate, modrate, and authrate tools. The overall rates were accurate, but the recent rates could be slightly off. In addition, the recent and overall rates for the first interval often didn't match up. These problems have been resolved.
Updated the searchrate and modrate tools to support the use of the proxied authorization v2 control. The authorization ID may be specified as a value pattern, which makes it possible to specify a range of alternate authorization identities.
Added isClosed methods to the connection pool implementations which can be used to determine whether the connection pool has been closed.
Updated the value pattern implementation to provide support for reading values from files. Files should be referenced by URL, and it supports both local files (using a URL like "file:///path/to/file") and remote files via HTTP (using a URL like "http://server.example.com/path/to/file"), and that URL should be enclosed in square brackets. For example, a value pattern of "[file:///tmp/filters.txt]" will cause the individual lines of the file "/tmp/filters.txt" to be read and randomly substituted for that portion of the value pattern.
Updated the searchrate, modrate, and authrate tools so that they provide the ability to display information about the result codes for operations that don't complete successfully. If any errors are encountered during processing, then the result codes for those failures will be displayed along with the number of times that result was returned. The "--suppressErrorResultCodes" argument may be provided to disable this capability.
Improved the behavior exhibited by the LDAP SDK when interacting with a server that is completely unresponsive (e.g., as in the case in which the network cable has been removed, or the server process has been halted with a command like pstop). This includes improved support for honoring any configured connect timeout, even for SSL-based connections which did not previously support it. Bind and extended requests can now have an explicit timeout assigned to them, like was already possible for all other types of requests. When duplicating a request, any assigned timeout is also duplicated along with the other details of that request.
Improved the error message in the exception thrown if a client-side timeout occurs. The updated message now includes the type of operation and the length of time the client waited before considering the operation to have timed out.
Updated the RootDSE and Schema classes so that their constructors which take Entry objects are made public, since they can be useful in code outside of the LDAP SDK.
Made the SearchRequest.getSearchResultListener method public so that code outside of the LDAP SDK can determine whether a search result listener has been configured for the search.
Updated the message properties files to use better format strings for messages containing numbers. Previously, large numbers could be formatted awkwardly (e.g., including commas as grouping separators, like "12,345" instead of just "12345").
Updated the LDAP SDK so that the thread-local ASN1Buffer object used for connections is made static rather than per-instance. This can dramatically reduce the amount of memory consumed for applications with large numbers of connections that can be used by multiple threads.
Added methods that can be used to determine whether an attribute value needs to be base64-encoded when represented in LDIF. Also, updated the Attribute.toString methods so that values will be base64-encoded in that string representation if they should be base64-encoded in LDIF.
Updated the LDAP SDK so that it allows working with ASN.1 elements whose values are contained in a portion of a byte array rather than always requiring them to be the full array. The sequence and set parsing code now takes advantage of this, and elements decoded from them no longer require allocation of new arrays for holding their values.
Improved support for client-side use of matching rules. All matching rule classes now provide the ability to retrieve the name and OID of the equality, ordering, and substring matching rules that they implement. The MatchingRule class now provides the ability to select a matching rule instance from the OID of the desired matching rule. The EntrySorter class has been updated so that if a sort key contains a matching rule ID, then it will be used to select the matching rule to use for the client-side sorting.
Updated the schema parsing code so that when reading schema definitions from LDAP or LDIF, any leading and trailing spaces will be trimmed before attempting to parse the elements. Technically, leading and trailing spaces are illegal and should not be present in such definitions, but some servers are lenient and allow them so the LDAP SDK should attempt to accommodate such definitions. It will still never generate schema element definitions containing leading or trailing spaces.
Updated the LDAP SDK so that any debug messages or string representations of exception stack traces that it generates will include the revision number of the source repository from which the LDAP SDK was built. This can help make it easier to troubleshoot problems, since it is easier to identify the version of the source used to generate the LDAP SDK build being used.
Fixed a bug that can cause problems for clients operating in the default asynchronous mode if the server sends response messages broken up into small pieces rather than all a once. In particular, if a response message contains only the BER type, or only the BER type and a portion (but not all of) the length, then the LDAP SDK may not be able to properly decode the full message if there is a delay between the first and second packets with portions of the type and length. If this problem occurs, then the client would terminate the connection to the server.

Version 1.1.0

The following changes were made between the 1.0.0 and 1.1.0 releases:

A new license has been added to the UnboundID LDAP SDK for Java. In addition to the previous GNU General Public License (GPLv2) and UnboundID LDAP SDK Free Use License, the Standard Edition of the LDAP SDK is now available under the terms of the GNU Lesser General Public License (LGPLv2.1). This is an OSI-approved open source license which allows the SDK to be used in a very wide range of applications (including proprietary and commercial applications).
The Standard Edition of the LDAP SDK is now available in a SourceForge project at http://sourceforge.net/projects/ldap-sdk/. This includes a subversion repository containing the source code, as well as a new set of project mailing lists and a forum.
The Standard Edition of the LDAP SDK is now available for use with Maven. It is available at http://ldap-sdk.sourceforge.net/maven/ with a groupId of "com.unboundid", an artifactId of "unboundid-ldapsdk", and a version of "1.1.0". In the near future, it will also be included in the Central Repository.
Updated the LDAPCommandLineTool class to provide support for handling connections to multiple servers. If this capability is enabled, then it will allow multiple occurrences of the "--hostname" and "--port" arguments to be provided. If multiple addresses and ports are provided, then the same number of each must be given, and a RoundRobinServerSet will be used when creating connections so that each subsequent connection will be established to the next server in the list, looping back to the beginning of the list when all servers have been used. The searchrate, modrate, and authrate tools have been updated to take advantage of this capability, so they may now be used to process operations concurrently against multiple servers.
Updated the build process so that the manifest for the generated jar file contains an appropriate set of attributes to make the LDAP SDK more suitable for use in an OSGi environment. The added attributes include: Bundle-Name, Bundle-Version, Bundle-Vendor, Bundle-Copyright, Bundle-ManifestVersion, Bundle-RequiredExecutionEnvironment, Bundle-Category, Bundle-DocURL, and Export-Package.
Updated the ResultCode.isConnectionUsable() method to be more conservative so that it is more likely to return a false positive (i.e., the connection will be considered unusable when it may still be usable) than a false negative (the connection will be considered usable when it that is not the case). Also, non-static versions of the isClientSideResultCode() and isConnectionUsable() methods have been added for convenience.
Added finalize() methods for the connection pool implementations so that the pool will be closed when it is reaped by the garbage collector if that was not already done.
Added support to make it easier to migrate applications written to use the Netscape Directory SDK for Java to the UnboundID LDAP SDK for Java. This includes wrappers for a number of commonly-used classes in the Netscape API so that in many cases it may be sufficient to simply change the import statements of the application so that they reference "com.unboundid.ldap.sdk.migrate.ldapjdk" instead of "netscape.ldap". This is not a complete re-implementation of the Netscape API (e.g., it does not directly support applications written to use asynchronous operations), but in the common case it should help significantly reduce the code change required to migrate an application from the Netscape API to the UnboundID LDAP SDK for Java.
Added support to make it easier to migrate applications written to use the Java Naming and Directory Interface (JNDI) to the UnboundID LDAP SDK for Java, or to allow applications which use functionality provided by both APIs concurrently. A new JNDIConverter class has been added which provides support for converting between corresponding JNDI and LDAP SDK implementations of common data structures, including attributes, controls, extended requests and responses, modifications, and search result entries.
Added a new "use schema" LDAP connection option which can be used to cause operations on the connection to make use of schema information when reading data from the directory server. In particular, the schema will be used to select the appropriate matching rule for each attribute included in search result entries. The Attribute class has been updated to provide new constructors which take Schema objects that allow that schema to be used to select the appropriate matching rule for that attribute.
Added a set of Attribute.nameIsValid methods which can be used to determine whether a provided string is a valid attribute name.
Added additional Attribute.hasValue and Entry.hasAttributeValue methods which allow an alternate matching rule to be provided which will be used when making the determination rather than the matching rule with which that attribute type is associated.
Added support for the case-ignore list equality and substring matching rules, as used by the postal address syntax.
Updated the searchrate, modrate, and authrate tools to include new command-line options. The "--timestampFormat" argument may be used to indicate whether timestamps should be included in the output, and if so what format should be used (either the time only or both the date and the time). The "--warmUpIntervals" argument may be used to indicate that the tool should be allowed to run for a specified number of intervals before beginning overall statistics collection to allow the client and the server to warm up.

Version 1.0.0

The following changes were made between the 0.9.10 and 1.0.0 releases:

Updated the code used to read server responses so that it uses a result code of "server down" rather than "protocol error" whenever an I/O error occurs while reading the response.
Added support for the permissive modify control, which may be used to request that the directory server accept modify requests which attempt to add an attribute value that already exists in the target entry, or to remove an attribute value which does not exist in the target entry.
Updated the code used to parse schema elements to be more lenient and standards-compliant when handling optional spaces in definitions.
Added a new LDAPThreadLocalConnectionPool class, which is very similar to the existing LDAPConnectionPool class, except that it uses a thread-local mechanism to maintain a separate connection for each client thread that attempts to communicate with the server. This can help eliminate some thread contention, and can help avoid the need to define an explicit size for the pool, since it will have as many connections as threads attempting to use the pool.
Added the ability to create a Schema object by reading schema definitions from one or more LDIF files. It was previously only possible to read schema information from a directory server over LDAP.
Updated the LDIF reader to provide the ability to reject entries containing duplicate values for the same attribute. Previously, if an entry had multiple occurrences of the same value for the same attribute, the LDIF reader would simply silently ignore the duplicate values. This is still the default behavior, but it is now possible to configure the LDIF reader to reject entries with duplicate attribute values.
Updated the LDIF reader to provide the ability to use schema information when reading entries and change records. This can be used to help better handle treatment of different values which might have otherwise been considered duplicates using the default case-ignore string matching rule (e.g., attributes that should use case-exact matching and have values that differ only in capitalization).
Updated the validate-ldif tool provided with the LDAP SDK so that it offers the ability to use schema definitions read from files rather than over LDAP (so that it can be used in a completely offline manner). It will also now reject entries with duplicate attribute values by default, but provides an option to ignore such errors.
Updated the EntryValidator class so that it properly handles entries with the extensibleObject object class.
Fixed a bug that could prevent LDAP connection statistics from being updated for asynchronous search operations.
Added convenience methods to the Attribute and Entry classes which may be used to retrieve attribute values as DNs.
Added convenience methods to the DN and Entry classes which may be used to determine whether a given DN or entry is within the range of a specified search base and scope.

Version 0.9.10

The following changes were made between the 0.9.9 and 0.9.10 releases:

Updated the schema parsing code so that schema elements will be held in ordered maps so that they can be accessed in the order they were returned by the server. This can help ensure that order-based dependencies (e.g., an object class which inherits from a superior class) may be properly maintained if they are returned from the server in that order.
Fixed a bug in the schema parsing code that incorrectly selected a generalized time matching rule when it should have chosen an integer matching rule. This could cause the validate-ldif tool to incorrectly report syntax violations for data using an integer syntax, along with other failures for code relying on this capability in the LDAP SDK.
Updated the LDAP SDK to add an option to operate in synchronous mode. For connections which do not need to invoke asynchronous operations and which will not be used concurrently by multiple threads, then the application can use the LDAPConnectionOptions.setUseSynchronousMode(true) method to enable synchronous mode for the connection options before connecting to the directory server. When in this mode, responses will be read by the same thread which sent the request, rather than by a separate reader thread. This can significantly improve performance when communicating with the server.

Other performance improvements have also been made in the LDAP SDK which may benefit both the default asynchronous mode as well as the new synchronous mode.
Fixed a bug that could cause intermittent failures with a "server down" result in which the connection was terminated. The problem would be triggered if the client could not read an entire LDAP message at once and there was a significant delay of greater than 50 milliseconds when attempting to read additional data as part of the message. This could cause the SDK to attempt to read the middle of an LDAP message as if it were the beginning, which would cause a decoding failure that would trigger the SDK to terminate the connection.
Fixed a bug in the ObjectClassDefinition class that caused it to ignore the recursive argument. Previously, it would always recursively get all superior classes even if the recursive argument was set to false.
Fixed a bug that prevented entries returned by automatically following a referral from being included in the search result entry count.
Updated the LDAPSearch example tool to include an option for following referrals encountered during processing.

Version 0.9.9

The following changes were made between the 0.9.8 and 0.9.9 releases:

Updated the javadoc documentation to make the EntrySource API (and in particular the LDAPEntrySource class) more visible. References to LDAPEntrySource are now present in the class-level documentation for the SearchRequest class and SearchResultListener interface.
Created a new SearchResultReferenceEntrySourceException as a subclass of EntrySourceException that will be thrown if a search result reference is returned when using the LDAPEntrySource class. This makes it easier to access the contents of any search result references returned through this API.
Added LDAPException.hasControl methods that mirror the LDAPResult.hasControl methods and provide additional convenience when working with controls in results for operations that returned with a non-successful result.
Placed a maximum size on the blocking queue used to hold search result entries and references while waiting for them to be processed. This can help prevent problems in which a client could be potentially overwhelmed or required to use a lot of memory for a search that returns a large number of entries when a search result listener is used and the client cannot process entries as quickly as they are returned. If the queue becomes full, then the LDAP SDK will push back against the directory server so that it will only be able to send entries as fast as the client can consume them.
Added the ability to control automatic referral following at a per-request level. By default, the LDAP SDK will still use the behavior defined at the connection level, but it is now possible to override that on a per-request level if desired.
Added the ability to include a call stack trace in debug log messages.
Updated the LDAP connection pool implementation to ensure that the auto-reconnect connection option is ignored for connections which are part of a connection pool. In some cases, the use of this option for pooled connections could cause connections to be re-established when the pool had attempted to close them.
Added the ability to assign user-friendly names to connections and connection pools. This can be helpful in applications which maintain multiple connections or connection pools for different purposes. The name of the connection or connection pool can be queried via code and will also appear in the names of the threads used to read responses from the directory server for those connections so that they will be more visible in thread stack traces.
Fixed a bug in the LDIF writer that could cause an extra space to be added to the beginning of the last line of a multi-line comment.
Updated LDAP connection pool implementations so that releasing a defunct connection will not automatically cause a new connection to be created to replace it if the pool already has the maximum number of available connections. Previously, the connection pool could have created and then immediately closed a connection in that scenario.
Added additional connection pool statistics that can be used to help distinguish between differences in behavior when a connection was successfully checked out of the pool. It is now possible to differentiate between cases in which an existing connection was returned without any wait, an existing connection was returned after waiting for it to become available, or a new connection was created to return to the client. This can help make information available for applications to understand whether their connection pools are sized appropriately.
Updated the LDAP SDK to change the manner in which a connection is closed if it is done by the Java finalizer (which would presumably only occur if a connection was leaked by the application using it). If the connection is part of a connection pool, then it will now simply be terminated rather than released back to the pool as a defunct connection.
Made the LDAPRequest.getLastMessageID() method public. This was previously used internally, but may be useful when trying to cancel a synchronous request from a different thread.
Added the ability to control the send and receive buffer sizes for sockets used when communicating with the directory server.
Updated the LDAP SDK to provide better information to clients in the event that a connection is terminated because of an unrecoverable error encountered while reading responses from the directory server. This information was previously only available through the debugging framework, but the LDAP SDK will now attempt to generate a response to provide to the client with information about the failure so that it will be available when debugging isn't enabled.
Added a static Attribute.getBaseName(String) method that may be used to retrieve the base name without any attribute options for a specified attribute description.
Updated the format of LDAP SDK debug messages to make them more consistent and easier to parse.
Added the ability to capture a thread stack trace at the time that an attempt is made to establish a connection. This can be useful for debugging purposes, especially for tracking down the source of a leaked connection.
Added the ability to update an Entry object with one or more modifications.
Fixed a bug that could prevent the LDAP SDK from correctly following referrals for search operations.

Version 0.9.8

The following changes were made between the 0.9.7 and 0.9.8 releases:

Fixed a bug that could prevent the LDAP SDK from returning a response to the StartTLS extended request if the server certificate was not trusted.
Fixed a bug that could cause the connection pool implementation to leak a connection when performing a background health check if that connection was examined multiple times in the same health check sequence.
Fixed a bug in the LDAPConnectionPool.getRootDSE() method in which it could inadvertently check out two connections when only one was required. Both connections were properly returned to the pool, but holding the unnecessary connection could create an artificial shortage of available connections.
Fixed a problem that caused the name of the background thread used by the internal LDAPConnectionReader class to be set to "Connection reader for LDAPConnection(not connected)" even when the connection was established. This has been changed so that it will be "Connection reader for {host}:{port}" when the connection is established, and "Connection reader for {host}:{port} (closed)" when the connection has been closed.
Added a new com.unboundid.util.FixedRateBarrier class which can be used to help try to perform operations no faster than a specified rate. The authrate, modrate, and searchrate tools have been updated to include a new "--ratePerSecond" argument that can be used to attempt to process authentications, modifies, and searches at the specified rate.
Updated the CompareRequest class to make the setAssertionValue(ASN1OctetString) method public, since it can be useful in code outside of the LDAP SDK itself.
Added an Attribute.getMatchingRule() method that can be used to get the matching rule that will be used by default for matching operations involving that attribute.
Added the ability to easily convert between Filter objects (which are normal search filters) and MatchedValuesFilter objects (which are used in the matched values request control). Not all search filters are valid matched values filters, so an attempt to convert a search filter using an AND, OR, or NOT component, or using an extensible match component with the "dnAttributes" flag set will throw an exception.
Message strings used by the LDAP SDK have been updated so that they use single quotes rather than double quotes. If the messages generated by the LDAP SDK (especially those included in exceptions) are consumed by and embedded in messages from another application, then single quotes are less likely to create confusion or need escaping if anything tries to parse those messages.
Updated the output of the authrate, modrate, and searchrate tools so that a row of dashes is displayed between the column headings and the data, which moderately improves the appearance. This will not be used when CSV-formatted output is requested.

Version 0.9.7

The following changes were made between the 0.9.6 and 0.9.7 releases:

Further improved the performance of the LDIFReader for entries containing multi-valued attributes. The change introduced the 0.9.6 version was only applicable for entries with an LDIF representation of at least 100 lines. The new implementation works for entries of any size and can help dramatically improve read performance for smaller static groups, whereas the previous change only worked for large groups.
Added a new com.unboundid.ldap.sdk.CompactEntry class that provides much of the same functionality of the Entry class but in a manner that requires much less memory. This is particularly useful for cases in which it may be necessary to store a large number of entries in memory. For one test involving typical user entries, CompactEntry has been found to require only about 25% as much memory as Entry. For another test involving static groups with 20 members each, CompactEntry has been found to require only about 31% as much memory as Entry.
Note that some operations involving CompactEntry may not perform as well as with the corresponding methods in the Entry class, so it is generally recommended that CompactEntry only be used when it is necessary to store a large number of entries in memory. Further, CompactEntry objects are read-only and the API does not expose any way to directly alter their contents.
Fixed a potential null pointer exception that could arise as a result of a race condition when closing a connection.
Made a minor change to the com.unboundid.ldif.LDIFChangeRecord class so that the processChange method now takes an LDAPInterface argument rather than an LDAPConnection. This change is completely backward compatible, since LDAPConnection implements LDAPInterface, but the new version makes it more convenient to use with connection pools.
Added source code for a simple application that allows the UnboundID LDAP SDK for Java to be used to communicate with an LDAP directory server on Android mobile devices. This application makes it possible to perform searches against an LDAP directory server, and can parse user entries to make it possible to call or e-mail a user found in the directory, show a map of their location, or add information about that user to the device's local contacts. More information about this application can be found at http://directorymanager.wordpress.com/2009/03/24/using-ldap-on-android/, including a video demonstrating its use.

Version 0.9.6

The following changes were made between the 0.9.5 and 0.9.6 releases:

Added support for the LDAP intermediate response protocol op type as described in RFC 3771. Intermediate responses provide the ability for operations to return multiple responses to a single request. A new IntermediateResponseListener interface has been added, and clients can use the LDAPRequest.setIntermediateResponseListener method to indicate that any intermediate response messages returned in response to that request should be made available via that interface. If no intermediate response listener is defined for a request, then any intermediate response messages returned in response to that request will be silently discarded (although a debug message will be generated).
Fixed a problem in the LDIFReader class in which it did not properly propagate the LDIFException that was thrown if the first line of an LDIF record started with a space.
Fixed a potential problem in the searchrate and modrate tools in which the auto-reconnect flag did not get properly set on the connections that they used. Before this fix, if the connection to the server was lost for some reason, then they would not make any attempt to re-establish the connection.
Added a new authrate tool as an example. It can be used to measure authentication performance, where each authentication consists of a search to retrieve a user entry followed by a bind to verify the password for that user. It supports simple authentication, as well as the CRAM-MD5, DIGEST-MD5, and PLAIN SASL mechanisms.
Updated the CommandLineTool API to make it possible to include example usages for tools that will be included whenever the usage information is displayed. This can make it easier to understand how a given tool might be used. The example tools provided with the LDAP SDK have been updated to provide this capability.
Updated LDAP connection pools to provide support for a maximum connection age. If a maximum connection age is defined, then any connection which has been established for a longer period than this will be closed and replaced with a new connection.
Created a new LDAPConnectionStatistics class that can be used to provide information about the processing performed by the LDAP SDK. The connection statistics can be retrieved using the LDAPConnection.getConnectionStatistics method, and they include information about the number of times the connection has been established and closed, the number of times each type of request message has been sent, the number of times each type of response message has been received, and the total and average response times for those operations. This feature was suggested by Philip Peake.
Created a new LDAPConnectionPoolStatistics class that can be used to provide information about the processing performed by the connection pool. The connection pool statistics can be retrieved using the LDAPConnectionPool.getConnectionPoolStatistics() method, and they include the number of connections currently available in the pool, the maximum number of connections that may be maintained in the pool, the number of successful and failed attempts to create connections, the number of connections that have been closed as defunct, expired, or unneeded, the number of successful and failed attempts to retrieve a connection, and the number of valid connections released back to the pool. This feature was suggested by Philip Peake.
Updated LDAP connection pools to provide support for connection health checking. Health check implementations may be used to perform custom checks to determine whether a connection is valid at any of the following times:
- Whenever a new connection is created for use in the pool
- Whenever a connection is checked out of the pool
- Whenever a connection is released back to the pool
- After an exception has been caught while processing an operation in the pool
In addition, a background thread will be used to periodically invoke health checks against all available connections. The ServerSet API has been updated to provide the ability to make use of a health check in the course of creating new connections. A health check implementation has been provided that can be used to retrieve a specified entry from the directory server. The ability or inability to retrieve the entry, as well as the time required to do so, can be taken into consideration. This feature was suggested by Philip Peake.
Added a number of convenience methods to the DN and RDN class that make it easier to interact with them using their string representations. For example, there are now methods for determining if a string represents a valid DN or RDN, if two strings represent the same DN or RDN, to determine whether there is a hierarchical relationship between two strings representing DNs, and to compare two DNs or RDNs based on their string representations. This feature was suggested by Felix Gaehtgens.
Updated the LDIF reader to significantly improve performance when reading entries containing attributes with a large number of values (e.g., large static groups). In a single-threaded test case involving reading static group entries with 2000 members each, performance has been improved by over 360x (i.e., over 36,000%). This problem was reported by Felix Gaehtgens.

Version 0.9.5

This was the initial public release of the UnboundID LDAP SDK for Java.