UnboundID Server SDK

Ping Identity
UnboundID Server SDK Documentation

ExampleProxiedExtendedOperationHandler.java

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * docs/licenses/cddl.txt
 * or http://www.opensource.org/licenses/cddl1.php.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * docs/licenses/cddl.txt.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2014-2023 Ping Identity Corporation
 */
package com.unboundid.directory.sdk.examples;



import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.unboundid.directory.sdk.common.operation.ExtendedRequest;
import com.unboundid.directory.sdk.common.schema.AttributeType;
import com.unboundid.directory.sdk.common.types.OperationContext;
import com.unboundid.directory.sdk.proxy.api.ProxiedExtendedOperationHandler;
import com.unboundid.directory.sdk.proxy.config.
            ProxiedExtendedOperationHandlerConfig;
import com.unboundid.directory.sdk.proxy.types.BackendSet;
import com.unboundid.directory.sdk.proxy.types.EntryBalancingRequestProcessor;
import com.unboundid.directory.sdk.proxy.types.ProxyingRequestProcessor;
import com.unboundid.directory.sdk.proxy.types.ProxyServerContext;
import com.unboundid.ldap.sdk.DN;
import com.unboundid.ldap.sdk.ExtendedResult;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.ldap.sdk.extensions.PasswordModifyExtendedRequest;
import com.unboundid.ldap.sdk.unboundidds.controls.NoOpRequestControl;
import com.unboundid.ldap.sdk.unboundidds.controls.PasswordPolicyRequestControl;
import com.unboundid.ldap.sdk.unboundidds.controls.PurgePasswordRequestControl;
import com.unboundid.ldap.sdk.unboundidds.controls.RetirePasswordRequestControl;
import com.unboundid.ldap.sdk.unboundidds.controls.
            SuppressOperationalAttributeUpdateRequestControl;
import com.unboundid.util.ObjectPair;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.args.Argument;
import com.unboundid.util.args.ArgumentException;
import com.unboundid.util.args.ArgumentParser;
import com.unboundid.util.args.StringArgument;



/**
 * This class provides an example of a proxied extended operation handler that
 * can be used to forward password modify extended requests (as defined in
 * <A HREF="http://www.ietf.org/rfc/rfc3062.txt">RFC 3062</A>) through the
 * Directory Proxy Server to one or more backend servers in simple proxy and/or
 * entry-balanced configurations.
 * <BR><BR>
 * This proxied extended operation handler takes the following configuration
 * arguments:
 * <UL>
 *   <LI>username-attribute -- This specifies the name of the attribute that
 *       will be used in an attempt to locate the target entry for an
 *       authentication identity that starts with "u:".  If this is not
 *       specified, a default of "uid" will be used.
 * </UL>
 */
public final class ExampleProxiedExtendedOperationHandler
       extends ProxiedExtendedOperationHandler
{
  /**
   * The name of the argument that will be used to specify the username
   * attribute.
   */
  private static final String ARG_NAME_USERNAME_ATTRIBUTE =
       "username-attribute";



  /**
   * The default value that will be used for the username attribute.
   */
  private static final String DEFAULT_USERNAME_ATTRIBUTE = "uid";



  /**
   * The name of the operation attachment that may be used to hold a pre-decoded
   * version of the request.
   */
  private static final String ATTACHMENT_NAME_DECODED_REQUEST =
       ExampleProxiedExtendedOperationHandler.class.getName() +
            ".decodedRequest";



  /**
   * The name of the operation attachment that may be used to hold a pre-decoded
   * version of the target user DN from the request.
   */
  private static final String ATTACHMENT_NAME_DECODED_USER_DN =
       ExampleProxiedExtendedOperationHandler.class.getName() +
            ".decodedUserDN";



  /**
   * The name of the operation attachment that may be used to hold a pre-decoded
   * version of the target username from the request.
   */
  private static final String ATTACHMENT_NAME_DECODED_USERNAME =
       ExampleProxiedExtendedOperationHandler.class.getName() +
            ".decodedUsername";



  // The name of the attribute that will be used for username lookups.
  private volatile String usernameAttribute = DEFAULT_USERNAME_ATTRIBUTE;



  /**
   * Creates a new instance of this proxied extended operation handler.  All
   * proxied extended operation handler implementations must include a default
   * constructor, but any initialization should generally be done in the
   * {@code initializeProxiedExtendedOperationHandler} method.
   */
  public ExampleProxiedExtendedOperationHandler()
  {
    // No implementation is required.
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public String getExtensionName()
  {
    return "Password Modify Proxied Extended Operation Handler";
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public String[] getExtensionDescription()
  {
    return new String[]
    {
      "This example is intended to demonstrate the process for creating a " +
           "custom proxied extended operation handler via the UnboundID " +
           "Server SDK.  In this case, it has the ability to examine a " +
           "password modify extended request to determine which backend " +
           "server(s) should be used to process it.  The userIdentity field " +
           "of the request will be used in conjunction with the " +
           "authentication identity of the underlying client connection in " +
           "order to determine where the request should be sent."
    };
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public void defineConfigArguments(final ArgumentParser parser)
         throws ArgumentException
  {
    final String usernameAttrArgDescription = "The name of the attribute " +
         "that will be used to look up user entries for a given username.";
    final StringArgument usernameAttrArg = new StringArgument(
         null,                     // The short identifier -- none will be used.
         ARG_NAME_USERNAME_ATTRIBUTE,                    // The long identifier.
         false,                                        // Argument not required.
         1,                              // It may be provided at most one time.
         "{attr}",                      // A placeholder for the argument value.
         usernameAttrArgDescription,                // The argument description.
         DEFAULT_USERNAME_ATTRIBUTE);                      // The default value.
    parser.addArgument(usernameAttrArg);
  }



  /**
   * Initializes this proxied extended operation handler.
   *
   * @param  serverContext  A handle to the server context for the server in
   *                        which this extension is running.
   * @param  config         The general configuration for this extended
   *                        operation handler.
   * @param  parser         The argument parser which has been initialized from
   *                        the configuration for this extended operation
   *                        handler.
   *
   * @throws  LDAPException  If a problem occurs while initializing this
   *                         extended operation handler.
   */
  @Override()
  public void initializeProxiedExtendedOperationHandler(
                   final ProxyServerContext serverContext,
                   final ProxiedExtendedOperationHandlerConfig config,
                   final ArgumentParser parser)
         throws LDAPException
  {
    usernameAttribute = getUsernameAttribute(parser);
  }



  /**
   * Indicates whether the configuration represented by the provided argument
   * parser is acceptable for use by this extension.  The parser will have been
   * used to parse any configuration available for this extension, and any
   * automatic validation will have been performed.  This method may be used to
   * perform any more complex validation which cannot be performed automatically
   * by the argument parser.
   *
   * @param  config               The general configuration for this extension.
   * @param  parser               The argument parser that has been used to
   *                              parse the proposed configuration for this
   *                              extension.
   * @param  unacceptableReasons  A list to which messages may be added to
   *                              provide additional information about why the
   *                              provided configuration is not acceptable.
   *
   * @return  {@code true} if the configuration in the provided argument parser
   *          appears to be acceptable, or {@code false} if not.
   */
  @Override()
  public boolean isConfigurationAcceptable(
                      final ProxiedExtendedOperationHandlerConfig config,
                      final ArgumentParser parser,
                      final List<String> unacceptableReasons)
  {
    boolean acceptable = true;

    // If a username attribute was specified, then make sure it's defined in the
    // server schema.
    final ProxyServerContext serverContext = config.getServerContext();
    final String usernameAttr = getUsernameAttribute(parser);
    final AttributeType attrType =
         serverContext.getSchema().getAttributeType(usernameAttr, false);
    if (attrType == null)
    {
      unacceptableReasons.add("Username attribute '" + usernameAttr +
           "' is not defined in the server schema.");
      acceptable = false;
    }

    return acceptable;
  }



  /**
   * Attempts to apply the configuration from the provided argument parser to
   * this extension.
   *
   * @param  config                The general configuration for this extension.
   * @param  parser                The argument parser that has been used to
   *                               parse the new configuration for this
   *                               extension.
   * @param  adminActionsRequired  A list to which messages may be added to
   *                               provide additional information about any
   *                               additional administrative actions that may
   *                               be required to apply some of the
   *                               configuration changes.
   * @param  messages              A list to which messages may be added to
   *                               provide additional information about the
   *                               processing performed by this method.
   *
   * @return  A result code providing information about the result of applying
   *          the configuration change.  A result of {@code SUCCESS} should be
   *          used to indicate that all processing completed successfully.  Any
   *          other result will indicate that a problem occurred during
   *          processing.
   */
  @Override()
  public ResultCode applyConfiguration(
                         final ProxiedExtendedOperationHandlerConfig config,
                         final ArgumentParser parser,
                         final List<String> adminActionsRequired,
                         final List<String> messages)
  {
    // Update the username attribute.  We'll do this regardless of whether it
    // has actually changed.
    usernameAttribute = getUsernameAttribute(parser);

    return ResultCode.SUCCESS;
  }



  /**
   * Performs any cleanup which may be necessary when this proxied extended
   * operation handler is to be taken out of service.
   */
  @Override()
  public void finalizeProxiedExtendedOperationHandler()
  {
    // No implementation is required.
  }



  /**
   * Retrieves the name of the extended operation with the provided OID.
   *
   * @param  oid  The OID of the extended operation for which to retrieve the
   *              corresponding name.
   *
   * @return  The name of the extended operation with the specified OID, or
   *          {@code null} if the specified OID is not recognized by this
   *          proxied extended operation handler.
   */
  @Override()
  public String getExtendedOperationName(final String oid)
  {
    if (oid.equals(PasswordModifyExtendedRequest.PASSWORD_MODIFY_REQUEST_OID))
    {
      return "Password Modify Extended Request";
    }
    else
    {
      return null;
    }
  }



  /**
   * Retrieves the OIDs of the extended operation types supported by this
   * proxied extended operation handler.
   *
   * @return  The OIDs of the extended operation types supported by this proxied
   *          extended operation handler.  It must not be {@code null} or
   *          empty, and the contents of the set returned must not change over
   *          the life of this proxied extended operation handler.
   */
  @Override()
  public Set<String> getSupportedExtensions()
  {
    // This extended operation handler only supports the password modify
    // operation.
    final LinkedHashSet<String> oids = new LinkedHashSet<String>(1);
    oids.add(PasswordModifyExtendedRequest.PASSWORD_MODIFY_REQUEST_OID);

    return Collections.unmodifiableSet(oids);
  }



  /**
   * Retrieves the OIDs of any controls supported by this proxied extended
   * operation handler.
   *
   * @return  The OIDs of any controls supported by this proxied extended
   *          operation handler.  It may be {@code null} or empty if this
   *          proxied extended operation handler does not support any controls.
   */
  @Override()
  public Set<String> getSupportedControls()
  {
    // A number of controls are supported for use with the password modify
    // extended operation.  Note, however, that this implementation does not
    // supported proxied password modify in conjunction with transactions.
    final LinkedHashSet<String> oids = new LinkedHashSet<String>(5);
    oids.add(NoOpRequestControl.NO_OP_REQUEST_OID);
    oids.add(PasswordPolicyRequestControl.PASSWORD_POLICY_REQUEST_OID);
    oids.add(PurgePasswordRequestControl.PURGE_PASSWORD_REQUEST_OID);
    oids.add(RetirePasswordRequestControl.RETIRE_PASSWORD_REQUEST_OID);
    oids.add(SuppressOperationalAttributeUpdateRequestControl.
         SUPPRESS_OP_ATTR_UPDATE_REQUEST_OID);

    return Collections.unmodifiableSet(oids);
  }



  /**
   * Retrieves the OIDs of any features supported by this proxied extended
   * operation handler that should be advertised in the server root DSE.
   *
   * @return  The OIDs of any features supported by this proxied extended
   *          operation handler.  It may be {@code null} or empty if this
   *          proxied extended operation handler does not support any features.
   */
  @Override()
  public Set<String> getSupportedFeatures()
  {
    // There are no additional features supported by this extension.
    return Collections.emptySet();
  }



  /**
   * Selects the entry-balancing backend set(s) to which the provided extended
   * request should be forwarded.  This method will only be invoked for
   * operations in which the requester's client connection policy includes one
   * or more subtree views which reference an entry-balancing request processor.
   * <BR><BR>
   * This method returns two groups of backend sets, with the first representing
   * an initial guess (e.g., based on information obtained from the
   * entry-balancing global index), and the second representing a fallback if
   * the initial guess was found to be incorrect.
   * <BR><BR>
   * If it can be determined that no backend sets associated with the provided
   * entry-balancing request processor should be used to process the extended
   * operation, then the object returned may have both elements set to
   * {@code null} or empty sets.  If it is possible to definitively determine
   * the set of backend sets to which the operation should be forwarded and no
   * fallback option is required, then the first element of the returned object
   * should be populated with a non-empty set and the second element should be
   * {@code null} or empty.
   * <BR><BR>
   * For the password modify extended operation, since the request should target
   * a single entry, the first set may include the one backend set in which we
   * believe the target entry exists (based on information from the global
   * index), and the second set may include all other backend sets in case it
   * was not found in the first set.  If the entry-balancing global index cannot
   * be used to provide any hint about the location of the entry, then the first
   * set will include all backend sets and the second set will be null to
   * indicate that there is no fallback option.
   *
   * @param  operationContext  The operation context for the extended operation.
   * @param  request           The extended request to be processed.
   * @param  requestProcessor  The entry-balancing request processor in which
   *                           the extended operation should be processed.
   *
   * @return  The set of backend sets to which the request should be forwarded.
   *          It may be {@code null} (or it may be an {@code ObjectPair} with
   *          both elements empty or {@code null}) if the request should not be
   *          forwarded to any backend set for the entry-balancing request
   *          processor.
   *
   * @throws  LDAPException  If the request should not be forwarded to any of
   *                         the backend sets for the provided entry-balancing
   *                         request processor, and the result contained in the
   *                         exception should be used instead.
   */
  @Override()
  public ObjectPair<Set<BackendSet>,Set<BackendSet>> selectBackendSets(
              final OperationContext operationContext,
              final ExtendedRequest request,
              final EntryBalancingRequestProcessor requestProcessor)
         throws LDAPException
  {
    // Extract the relevant details from the request.  Since this extended
    // operation handler could be invoked multiple times for the same request
    // (if the Directory Proxy Server is configured to forward multiple portions
    // of the DIT), we'll use operation attachments to avoid decoding things
    // multiple times.
    final PasswordModifyExtendedRequest passwordModifyRequest =
         getPasswordModifyRequest(operationContext, request);


    // Although a password modify request is allowed to not include a new
    // password (which indicates that the server should generate the new
    // password on behalf of the user), we won't allow that here.  The reason is
    // that there are cases in which the request might need to be forwarded to
    // multiple backend sets (especially if the targeted entry is outside the
    // balancing point) and there's no way to have different servers generate
    // the same new password.  Technically we could allow this for cases in
    // which we know the target entry is below the balancing point, but it's
    // simpler to not allow this at all.
    if (passwordModifyRequest.getRawNewPassword() == null)
    {
      throw new LDAPException(ResultCode.UNWILLING_TO_PERFORM,
           "The password modify proxied extended operation handler cannot be " +
                "used to proxy requests that do not specify an explicit new " +
                "password.");
    }


    // See if the request targets a user by DN (whether implicitly or
    // explicitly) or by username.
    final DN userDN = getTargetUserDN(operationContext, passwordModifyRequest);
    if (userDN == null)
    {
      // This means that the target user was specified as a username rather than
      // a DN.  In this case, we'll always process the request in this
      // entry-balancing request processor, but we can still try to use the
      // global index to figure out where to route the request based on the
      // username attribute.
      final String username =
           getTargetUsername(operationContext, passwordModifyRequest);
      final BackendSet indexedSet = requestProcessor.getGlobalIndexHint(
           usernameAttribute, username);
      if (indexedSet == null)
      {
        // It's not in the global index, so send it everywhere.
        return new ObjectPair<Set<BackendSet>,Set<BackendSet>>(
             new LinkedHashSet<BackendSet>(requestProcessor.getBackendSets()),
             null);
      }
      else
      {
        // Prioritize for the case where the entry is where the global index
        // thinks it is, but fall back to the rest of the servers.
        final LinkedHashSet<BackendSet> firstGuess =
             new LinkedHashSet<BackendSet>(1);
        firstGuess.add(indexedSet);

        final LinkedHashSet<BackendSet> remaining =
             new LinkedHashSet<BackendSet>(requestProcessor.getBackendSets());
        remaining.remove(indexedSet);

        return new ObjectPair<Set<BackendSet>,Set<BackendSet>>(firstGuess,
             remaining);
      }
    }
    else
    {
      // We have a DN, so first see if it's below the request processor.  If
      // not, then we won't process it here at all.
      if (! userDN.isDescendantOf(requestProcessor.getRequestProcessorBaseDN(),
           true))
      {
        return null;
      }

      // If the user DN is not below the entry-balancing base DN, then we'll
      // send it everywhere.
      if (! userDN.isDescendantOf(requestProcessor.getBalancingPointBaseDN(),
           false))
      {
        return new ObjectPair<Set<BackendSet>,Set<BackendSet>>(
             new LinkedHashSet<BackendSet>(requestProcessor.getBackendSets()),
             null);
      }

      // See if we can use the global index to get a hint as to the location of
      // the entry.
      final BackendSet indexedSet = requestProcessor.getGlobalIndexHint(userDN);
      if (indexedSet == null)
      {
        // It's not in the global index, so send it everywhere.
        return new ObjectPair<Set<BackendSet>,Set<BackendSet>>(
             new LinkedHashSet<BackendSet>(requestProcessor.getBackendSets()),
             null);
      }
      else
      {
        // Prioritize for the case where the entry is where the global index
        // thinks it is, but fall back to the rest of the servers.
        final LinkedHashSet<BackendSet> firstGuess =
             new LinkedHashSet<BackendSet>(1);
        firstGuess.add(indexedSet);

        final LinkedHashSet<BackendSet> remaining =
             new LinkedHashSet<BackendSet>(requestProcessor.getBackendSets());
        remaining.remove(indexedSet);

        return new ObjectPair<Set<BackendSet>,Set<BackendSet>>(firstGuess,
             remaining);
      }
    }
  }



  /**
   * Obtains the extended result that should be used as a result of processing
   * an operation in one or more entry-balanced backend sets, or throws an
   * exception to indicate that the request should instead be forwarded to the
   * fallback server set(s).
   * <BR><BR>
   * This method will only be invoked for cases in which the
   * {@link #selectBackendSets} method indicates that multiple backend sets
   * should be accessed in the course of processing an extended request.  For
   * the password modify extended operation, this will be any case in which the
   * global index cannot be used, or for the fallback set of servers in the
   * event that the global index hint is incorrect.
   *
   * @param  operationContext   The operation context for the extended
   *                            operation.
   * @param  request            The extended request that was processed.
   * @param  requestProcessor   The entry-balancing request processor in which
   *                            the extended operation was processed.
   * @param  results            A list of the extended results obtained from
   *                            processing the operation in the selected set of
   *                            backend sets, with each result paired with
   *                            information about the backend set from which it
   *                            was obtained.
   * @param  fallbackAvailable  Indicates whether a fallback group of backend
   *                            sets is available and may be used as a second
   *                            attempt at processing the operation if the
   *                            result from the initial attempt is not
   *                            acceptable.
   *
   * @return  An extended result that represents the merged result from the
   *          provided list of results.  It must not be {@code null}.
   *
   * @throws  LDAPException  To indicate that the initial set of results was not
   *                         acceptable and that the operation should instead be
   *                         forwarded to the fallback group of backend sets.
   *                         If no fallback set of results is available, then an
   *                         extended result will be generated from the content
   *                         of this exception.
   */
  @Override()
  public ExtendedResult mergeEntryBalancedResults(
              final OperationContext operationContext,
              final ExtendedRequest request,
              final EntryBalancingRequestProcessor requestProcessor,
              final List<ObjectPair<ExtendedResult,BackendSet>> results,
              final boolean fallbackAvailable)
         throws LDAPException
  {
    // If there are no results at all, then that's an error.  This should
    // never happen, but we'll check for it just in case.
    if (results.isEmpty())
    {
      throw new LDAPException(ResultCode.OTHER,
           "No results were obtained from the entry-balancing request " +
                "processor with base DN '" +
                requestProcessor.getRequestProcessorBaseDN() + "'.");
    }


    // Look at the set of results and categorize them as either successes or
    // failures.
    final ArrayList<ObjectPair<ExtendedResult,BackendSet>> successes =
         new ArrayList<ObjectPair<ExtendedResult,BackendSet>>(results.size());
    final ArrayList<ObjectPair<ExtendedResult,BackendSet>> failures =
         new ArrayList<ObjectPair<ExtendedResult,BackendSet>>(results.size());
    for (final ObjectPair<ExtendedResult,BackendSet> r : results)
    {
      if (r.getFirst().getResultCode() == ResultCode.SUCCESS)
      {
        successes.add(r);
      }
      else
      {
        failures.add(r);
      }
    }


    // If we only got successes, then return the first success result.
    if (failures.isEmpty())
    {
      return successes.get(0).getFirst();
    }


    // If we only got failures, then we may either return an error result or
    // throw an exception to indicate that the fallback servers should be used.
    if (successes.isEmpty())
    {
      // If an operation fails because the entry doesn't exist, then the result
      // code should be either NO_SUCH_OBJECT or INVALID_CREDENTIALS (if the
      // request included the user's current password and the server shouldn't
      // divulge the reason for the failure).  If we find any failure with a
      // different result, then we'll return that result even if there are
      // fallback servers.
      for (final ObjectPair<ExtendedResult,BackendSet> r : failures)
      {
        switch (r.getFirst().getResultCode().intValue())
        {
          case ResultCode.NO_SUCH_OBJECT_INT_VALUE:
          case ResultCode.INVALID_CREDENTIALS_INT_VALUE:
            break;
          default:
            return r.getFirst();
        }
      }

      // This suggests that all the failures were because either the target
      // entry doesn't exist or, if a current password was provided, then the
      // current password was wrong.  We can't tell which so we'll assume that
      // the entry doesn't exist.  If there are fallback servers, then we'll
      // throw an exception.  Otherwise return the first error result we got.
      if (fallbackAvailable)
      {
        throw new LDAPException(ResultCode.NO_RESULTS_RETURNED,
             "No success results were returned from the entry-balancing " +
                  "request processor with base DN '" +
                  requestProcessor.getRequestProcessorBaseDN() +
                  "'.  Try again with the fallback servers.");
      }
      else
      {
        return results.get(0).getFirst();
      }
    }


    // If we've gotten here, then we got a mix of success and failure results.
    // If we can extract a target DN from the request, then use that to
    // determine whether we expected one or multiple successes.
    final PasswordModifyExtendedRequest passwordModifyRequest =
         getPasswordModifyRequest(operationContext, request);
    final DN userDN = getTargetUserDN(operationContext, passwordModifyRequest);
    if (userDN != null)
    {
      // If the target user DN is subordinate to the balancing point, then we
      // should have gotten either exactly one success or all failures.  If it's
      // not below the balancing point, then we should have gotten either all
      // successes or all failures.
      if (userDN.isDescendantOf(requestProcessor.getBalancingPointBaseDN(),
           false))
      {
        if (successes.size() == 1)
        {
          // We got the one success we expected, so we'll return it.
          return successes.get(0).getFirst();
        }
        else
        {
          // We got multiple successes, which suggests the entry exists in
          // multiple backend sets.  This is an error.
          final String message = "The password modify operation targeting " +
               "entry '" +  userDN + "' (which is below the balancing point) " +
               "succeeded in multiple backend sets, indicating that the " +
               "target entry exists in multiple sets.";
          return generateEntryBalancingErrorResult(message,
               operationContext.getMessageID(), successes, failures);
        }
      }
      else
      {
        // The entry isn't below the balancing point, so we should have gotten
        // the same result everywhere.  Return an error response indicating that
        // we didn't.
        final String message = "The password modify operation targeting " +
             "entry '" + userDN + "' (which is not below the balancing point " +
             "and therefore should exist in all backend sets) succeeded in " +
             "at least one backend set but also failed in at least one set.  " +
             "This means that the entry is inconsistent across the backend " +
             "sets.";
        return generateEntryBalancingErrorResult(message,
             operationContext.getMessageID(), successes, failures);
      }
    }


    // If we've gotten here, then we know that the entry was targeted by
    // username rather than by DN, and that there were a mix of success and
    // failure results.  If there was a single success result, then return it.
    // If there were multiple success results but also one or more failures,
    // then generate an error result.
    if (successes.size() == 1)
    {
      return successes.get(0).getFirst();
    }
    else
    {
      final String username = getTargetUsername(operationContext,
           passwordModifyRequest);
      final String message = "The password modify operating targeting the " +
           "user with username '" + username + "' succeeded in multiple " +
           "backend sets but also failed in one or more sets.  This means " +
           "that the entry is inconsistent across the backend sets.";
      return generateEntryBalancingErrorResult(message,
           operationContext.getMessageID(), successes, failures);
    }
  }



  /**
   * Generates an error result for use in entry-balancing failures.
   *
   * @param  baseMessage  The base message to include in the result.
   * @param  messageID    The message ID for the result.
   * @param  successes    The list of successful backend set operations.
   * @param  failures     The list of failed backend set operations.
   *
   * @return  The generated entry-balancing error result.
   */
  private static ExtendedResult generateEntryBalancingErrorResult(
               final String baseMessage, final int messageID,
               final List<ObjectPair<ExtendedResult,BackendSet>> successes,
               final List<ObjectPair<ExtendedResult,BackendSet>> failures)
  {
    final StringBuilder message = new StringBuilder();
    message.append(baseMessage);
    message.append("  The operation succeeded in the following backend " +
         "sets:  ");

    final Iterator<ObjectPair<ExtendedResult,BackendSet>> sIterator =
         successes.iterator();
    while (sIterator.hasNext())
    {
      message.append('\'');
      message.append(sIterator.next().getSecond().getBackendSetID());
      message.append('\'');
      if (sIterator.hasNext())
      {
        message.append(", ");
      }
    }

    message.append(".  The operation failed in the following backend " +
         "sets:  ");

    final Iterator<ObjectPair<ExtendedResult,BackendSet>> fIterator =
         failures.iterator();
    while (fIterator.hasNext())
    {
      final ObjectPair<ExtendedResult,BackendSet> p = fIterator.next();
      message.append('\'');
      message.append(p.getSecond().getBackendSetID());
      message.append("' (result code ");
      message.append(p.getFirst().getResultCode().intValue());

      final String diagnosticMessage =
           p.getFirst().getDiagnosticMessage();
      if (diagnosticMessage != null)
      {
        message.append(", diagnosticMessage='");
        message.append(diagnosticMessage);
        message.append('\'');
      }
      message.append(')');

      if (fIterator.hasNext())
      {
        message.append(", ");
      }
    }
    message.append('.');

    return new ExtendedResult(messageID, ResultCode.OTHER, message.toString(),
         null, null, null, null, null);
  }



  /**
   * Indicates whether the provided extended request should be forwarded to one
   * of the servers associated with the provided proxying request processor.
   * Note that this method will not be invoked for proxying request processors
   * associated with an entry-balancing request processor.
   *
   * @param  operationContext  The operation context for the extended operation.
   * @param  request           The extended request to be processed.
   * @param  requestProcessor  The proxying request processor for which to
   *                           make the determination.
   *
   * @return  {@code true} if the extended request should be forwarded to one of
   *          the servers associated with the proxying request processor, or
   *          {@code false} if not.
   *
   * @throws  LDAPException  If the request should not be forwarded to a
   *                         backend server associated with the proxying request
   *                         processor, but the result contained in the
   *                         exception should be used instead.
   */
  @Override()
  public boolean shouldForward(final OperationContext operationContext,
                               final ExtendedRequest request,
                               final ProxyingRequestProcessor requestProcessor)
         throws LDAPException
  {
    // Extract the relevant details from the request.  Since this extended
    // operation handler could be invoked multiple times for the same request
    // (if the Directory Proxy Server is configured to forward multiple portions
    // of the DIT), we'll use operation attachments to avoid decoding things
    // multiple times.
    final PasswordModifyExtendedRequest passwordModifyRequest =
         getPasswordModifyRequest(operationContext, request);


    // Although a password modify request is allowed to not include a new
    // password (which indicates that the server should generate the new
    // password on behalf of the user), we won't allow that here.  The reason is
    // that there are cases in which the request might need to be forwarded to
    // multiple request processors and there's no way to have different servers
    // generate the same new password.  Technically we could allow this for
    // cases in which we know the target entry is below the balancing point, but
    // it's simpler to not allow this at all.
    if (passwordModifyRequest.getRawNewPassword() == null)
    {
      throw new LDAPException(ResultCode.UNWILLING_TO_PERFORM,
           "The password modify proxied extended operation handler cannot be " +
                "used to proxy requests that do not specify an explicit new " +
                "password.");
    }


    // If the request specifies a target entry by DN, then see if it's within
    // the scope of this request processor.
    final DN userDN = getTargetUserDN(operationContext, passwordModifyRequest);
    if (userDN == null)
    {
      // This means that the target user was specified as a username rather than
      // a DN.  In this case, we'll always process the request in this
      // proxying request processor.
      return true;
    }
    else
    {
      // We'll only forward the request if the target user DN is below the
      // request processor base DN.
      return userDN.isDescendantOf(requestProcessor.getRequestProcessorBaseDN(),
           true);
    }
  }



  /**
   * Creates the final extended result to return to the client from the provided
   * list of results obtained from the set of entry-balanced and/or proxying
   * request processors to which the request was forwarded.
   *
   * @param  operationContext   The operation context for the extended
   *                            operation.
   * @param  request            The extended request that was processed.
   * @param  results            The results from all request processors to which
   *                            the request was forwarded.  It may be empty if
   *                            the request was not forwarded to any backend
   *                            servers, in which case this method must
   *                            construct an appropriate result.  It may have
   *                            only a single element if the request was only
   *                            forwarded to one server, and in many cases it
   *                            may be desirable to simply use that result as
   *                            the final result.  It may also have multiple
   *                            elements if the request was forwarded to
   *                            multiple backend servers, in which case this
   *                            method must determine whether to return one of
   *                            them to the client, or to construct a new result
   *                            to return instead.
   *
   * @return  The final extended result to be returned to the client.
   */
  @Override()
  public ExtendedResult createFinalResult(
                             final OperationContext operationContext,
                             final ExtendedRequest request,
                             final List<ExtendedResult> results)
  {
    // If there aren't any results, then that means we didn't process the
    // operation in any request processor.  That should only occur if the
    // request targeted an entry by DN and that DN was outside the base DNs of
    // all proxying or entry-balancing request processors.  In that case, return
    // a NO_SUCH_OBJECT result.
    if (results.isEmpty())
    {
      return new ExtendedResult(operationContext.getMessageID(),
           ResultCode.NO_SUCH_OBJECT,
           "The targeted entry does not exist within any proxied or " +
                "entry-balanced request processor.",
           null, null, null, null, null);
    }


    // Iterate over the results to figure out which (if any) to use.  Categorize
    // them as successes or failures.
    final ArrayList<ExtendedResult> successes =
         new ArrayList<ExtendedResult>(results.size());
    final ArrayList<ExtendedResult> failures =
         new ArrayList<ExtendedResult>(results.size());
    for (final ExtendedResult r : results)
    {
      if (r.getResultCode() == ResultCode.SUCCESS)
      {
        successes.add(r);
      }
      else
      {
        failures.add(r);
      }
    }


    // If there was only a single success, then return it.
    if (successes.size() == 1)
    {
      return successes.get(0);
    }


    // If there were multiple successes, then this is an error.  This should
    // only happen for cases in which the request targeted a user by username
    // and there were multiple entries in different portions of the DIT with
    // the same username.
    if (successes.size() >= 2)
    {
      String username = null;
      try
      {
        final PasswordModifyExtendedRequest passwordModifyRequest =
             getPasswordModifyRequest(operationContext, request);
        username = getTargetUsername(operationContext, passwordModifyRequest);
      }
      catch (final Exception e)
      {
        operationContext.getServerContext().debugCaught(e);
      }

      String message = "The password modify operation succeeded in multiple " +
           "request processors, which indicates that multiple entries " +
           "in different portions of the DIT matched the target user " +
           "identity and had their passwords updated.";
      if (username != null)
      {
        message += "  You will likely want to identify all entries with " +
             "username '" + username + "' that are accessible via " +
             "entry-balancing or proxying request processors and determine " +
             "whether any of them has been updated in error.";
      }

      return new ExtendedResult(operationContext.getMessageID(),
           ResultCode.OTHER, message, null, null, null, null, null);
    }


    // If we've gotten here, then there were only failures.  Iterate through
    // them and return the first failure we find with a result other than
    // NO_SUCH_OBJECT or INVALID_CREDENTIALS.  If there aren't any such results,
    // then return the first failure.
    for (final ExtendedResult r : failures)
    {
      switch (r.getResultCode().intValue())
      {
        case ResultCode.NO_SUCH_OBJECT_INT_VALUE:
        case ResultCode.INVALID_CREDENTIALS_INT_VALUE:
          break;
        default:
          return r;
      }
    }

    return failures.get(0);
  }



  /**
   * Retrieves the name of the attribute that should be used for username
   * lookups.
   *
   * @param  parser  The argument parser that should be used to make the
   *                 determination.
   *
   * @return  The name of the attribute that should be used for username
   *          lookups.
   */
  private static String getUsernameAttribute(final ArgumentParser parser)
  {
    final Argument a = parser.getNamedArgument(ARG_NAME_USERNAME_ATTRIBUTE);
    if ((a != null) && (a instanceof StringArgument))
    {
      return ((StringArgument) a).getValue();
    }

    return DEFAULT_USERNAME_ATTRIBUTE;
  }



  /**
   * Extracts a password modify extended request from the provided information.
   * If the request is cached in the operation state (because it has already
   * been decoded for this operation) then use it.  Otherwise, try to decode it
   * from the provided generic request.
   *
   * @param  operationContext  The operation context for the extended operation.
   * @param  request           The extended request to be processed.
   *
   * @return  The extracted password modify extended request.
   *
   * @throws  LDAPException  If it is not possible to decode the provided
   *                         extended request as a password modify extended
   *                         request.
   */
  private static PasswordModifyExtendedRequest getPasswordModifyRequest(
                      final OperationContext operationContext,
                      final ExtendedRequest request)
          throws LDAPException
  {
    // See if there is a cached version attached to the operation.
    final Object attachment = operationContext.getAttachment(
         ATTACHMENT_NAME_DECODED_REQUEST);
    if ((attachment != null) &&
        (attachment instanceof PasswordModifyExtendedRequest))
    {
      return (PasswordModifyExtendedRequest) attachment;
    }


    // Decode the provided extended request as a password modify request and
    // cache it in the operation state before returning it.
    final PasswordModifyExtendedRequest passwordModifyRequest =
         new PasswordModifyExtendedRequest(request.toLDAPSDKRequest());
    operationContext.setAttachment(ATTACHMENT_NAME_DECODED_REQUEST,
         passwordModifyRequest);
    return passwordModifyRequest;
  }



  /**
   * Extracts the DN of the target user from the provided information.  If it
   * has already been extracted, then we may find a cached version in the
   * operation state.
   *
   * @param  operationContext  The operation context for the extended operation.
   * @param  request           The extended request to be processed.
   *
   * @return  The extracted target user DN, or {@code null} if the user is
   *          identified by a username rather than a DN.
   *
   * @throws  LDAPException  If a problem is encountered while trying to decode
   *                         the target user DN.
   */
  private static DN getTargetUserDN(final OperationContext operationContext,
                                    final PasswordModifyExtendedRequest request)
          throws LDAPException
  {
    // See if there is a cached version attached to the operation, then use it.
    final Object attachment = operationContext.getAttachment(
         ATTACHMENT_NAME_DECODED_USER_DN);
    if ((attachment != null) && (attachment instanceof DN))
    {
      return (DN) attachment;
    }


    // Get the user identity from the request.  If there isn't a user identity,
    // then use the authorization DN for the operation.
    final String userIdentity = request.getUserIdentity();
    if (userIdentity == null)
    {
      final DN userDN = new DN(operationContext.getAuthorizationDN());
      operationContext.setAttachment(ATTACHMENT_NAME_DECODED_USER_DN, userDN);
      return userDN;
    }


    // If the user identity starts with "dn:", then try to decode the rest of
    // the string as a DN.
    final String lowerUserIdentity = StaticUtils.toLowerCase(userIdentity);
    if (lowerUserIdentity.startsWith("dn:"))
    {
      final DN userDN = new DN(userIdentity.substring(3));
      operationContext.setAttachment(ATTACHMENT_NAME_DECODED_USER_DN, userDN);
      return userDN;
    }


    // If the user identity starts with "u:", then the user is identified by
    // username rather than DN.
    if (lowerUserIdentity.startsWith("u:"))
    {
      final String username = userIdentity.substring(2);
      operationContext.setAttachment(ATTACHMENT_NAME_DECODED_USERNAME,
           username);
      return null;
    }


    // Try to decode the entire user identity string as a DN.
    final DN userDN = new DN(userIdentity);
    operationContext.setAttachment(ATTACHMENT_NAME_DECODED_USER_DN, userDN);
    return userDN;
  }



  /**
   * Extracts the username of the target user from the provided information.  If
   * it has already been extracted, then we may find a cached version in the
   * operation state.
   *
   * @param  operationContext  The operation context for the extended operation.
   * @param  request           The extended request to be processed.
   *
   * @return  The extracted target username, or {@code null} if the user is
   *          identified by a DN (or defaults to the user's authorization DN)
   *          rather than a username.
   */
  private static String getTargetUsername(
                             final OperationContext operationContext,
                             final PasswordModifyExtendedRequest request)
  {
    // See if there is a cached version attached to the operation, then use it.
    final Object attachment = operationContext.getAttachment(
         ATTACHMENT_NAME_DECODED_USERNAME);
    if ((attachment != null) && (attachment instanceof String))
    {
      return (String) attachment;
    }


    // Get the user identity from the request.  If there isn't a user identity,
    // then the request doesn't target a user by username.
    final String userIdentity = request.getUserIdentity();
    if (userIdentity == null)
    {
      return null;
    }


    // If the user identity starts with "u:", then the user is identified by
    // username rather than DN.
    final String lowerUserIdentity = StaticUtils.toLowerCase(userIdentity);
    if (lowerUserIdentity.startsWith("u:"))
    {
      final String username = userIdentity.substring(2);
      operationContext.setAttachment(ATTACHMENT_NAME_DECODED_USERNAME,
           username);
      return username;
    }


    // The request doesn't target a user by username.
    return null;
  }



  /**
   * {@inheritDoc}
   */
  @Override()
  public Map<List<String>,String> getExamplesArgumentSets()
  {
    final LinkedHashMap<List<String>,String> examples =
         new LinkedHashMap<List<String>,String>(1);

    examples.put(
         Arrays.asList(
              ARG_NAME_USERNAME_ATTRIBUTE + "=mail"),
         "Allow the password modify extended operation to be proxied to " +
              "backend servers, using the mail attribute to perform username " +
              "lookups.");

    return Collections.unmodifiableMap(examples);
  }
}