OPENDJ-2655 Move CompactDN class as inner class of StaticGroup and optimize...

Nicolas Capponi

16.01.2016 9a20087a7c428eabc2c9abb9c27f01f623dbe042

 opendj-server-legacy/src/main/java/org/opends/server/extensions/StaticGroup.java

@@ -16,7 +16,12 @@
 */
package org.opends.server.extensions;

import static com.forgerock.opendj.util.StaticUtils.getBytes;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
@@ -30,7 +35,6 @@
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.DN.CompactDn;
import org.forgerock.opendj.ldap.ModificationType;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.opendj.ldap.SearchScope;
@@ -38,6 +42,7 @@
import org.forgerock.opendj.server.config.server.GroupImplementationCfg;
import org.forgerock.opendj.server.config.server.StaticGroupImplementationCfg;
import org.forgerock.util.Reject;
import org.forgerock.util.annotations.VisibleForTesting;
import org.opends.server.api.Group;
import org.opends.server.core.DirectoryServer;
import org.opends.server.core.ModifyOperation;
@@ -88,7 +93,7 @@
  private DN groupEntryDN;

  /** The set of the DNs of the members for this group. */
  private LinkedHashSet<CompactDn> memberDNs;
  private HashSet<CompactDn> memberDNs;

  /** The list of nested group DNs for this group. */
  private LinkedList<DN> nestedGroups = new LinkedList<>();
@@ -202,7 +207,7 @@
      {
        try
        {
          someMemberDNs.add(DN.valueOf(v.toString()).compact());
          someMemberDNs.add(new CompactDn(DN.valueOf(v.toString())));
        }
        catch (LocalizedIllegalArgumentException e)
        {
@@ -333,8 +338,8 @@
      newNestedGroups.add(nestedGroupDN);
      nestedGroups = newNestedGroups;
      //Add it to the member DN list.
      LinkedHashSet<CompactDn> newMemberDNs = new LinkedHashSet<>(memberDNs);
      newMemberDNs.add(toCompactDn(nestedGroupDN));
      HashSet<CompactDn> newMemberDNs = new HashSet<>(memberDNs);
      newMemberDNs.add(new CompactDn(nestedGroupDN));
      memberDNs = newMemberDNs;
    }
    finally
@@ -372,7 +377,7 @@
      nestedGroups = newNestedGroups;
      //Remove it from the member DN list.
      LinkedHashSet<CompactDn> newMemberDNs = new LinkedHashSet<>(memberDNs);
      newMemberDNs.remove(toCompactDn(nestedGroupDN));
      newMemberDNs.remove(new CompactDn(nestedGroupDN));
      memberDNs = newMemberDNs;
    }
    finally
@@ -385,7 +390,7 @@
  public boolean isMember(DN userDN, Set<DN> examinedGroups) throws DirectoryException
  {
    reloadIfNeeded();
    CompactDn compactUserDN = toCompactDn(userDN);
    CompactDn compactUserDN = new CompactDn(userDN);
    lock.readLock().lock();
    try
    {
@@ -440,8 +445,8 @@
        // Check if the group itself has been removed
        if (thisGroup == null)
        {
          throw new DirectoryException(ResultCode.NO_SUCH_ATTRIBUTE,
                  ERR_STATICGROUP_GROUP_INSTANCE_INVALID.get(groupEntryDN));
          throw new DirectoryException(ResultCode.NO_SUCH_ATTRIBUTE, ERR_STATICGROUP_GROUP_INSTANCE_INVALID
              .get(groupEntryDN));
        }
        else if (thisGroup != this)
        {
@@ -451,7 +456,7 @@
          {
            try
            {
              newMemberDNs.add(toCompactDn(memberList.nextMemberDN()));
              newMemberDNs.add(new CompactDn(memberList.nextMemberDN()));
            }
            catch (MembershipException ex)
            {
@@ -463,7 +468,7 @@
        nestedGroups.clear();
        for (CompactDn compactDn : memberDNs)
        {
          DN dn = fromCompactDn(compactDn);
          DN dn = compactDn.toDn(serverContext);
          Group<?> group = DirectoryServer.getGroupManager().getGroupInstance(dn);
          if (group != null)
          {
@@ -486,7 +491,7 @@
    lock.readLock().lock();
    try
    {
      return new SimpleStaticGroupMemberList(groupEntryDN, memberDNs);
      return new SimpleStaticGroupMemberList(serverContext, groupEntryDN, memberDNs);
    }
    finally
    {
@@ -503,9 +508,9 @@
    {
      if (baseDN == null && filter == null)
      {
        return new SimpleStaticGroupMemberList(groupEntryDN, memberDNs);
        return new SimpleStaticGroupMemberList(serverContext, groupEntryDN, memberDNs);
      }
      return new FilteredStaticGroupMemberList(groupEntryDN, memberDNs, baseDN, scope, filter);
      return new FilteredStaticGroupMemberList(serverContext, groupEntryDN, memberDNs, baseDN, scope, filter);
    }
    finally
    {
@@ -541,7 +546,7 @@
              for (ByteString v : attribute)
              {
                DN member = DN.valueOf(v);
                memberDNs.add(toCompactDn(member));
                memberDNs.add(new CompactDn(member));
                if (DirectoryServer.getGroupManager().getGroupInstance(member) != null)
                {
                  nestedGroups.add(member);
@@ -559,7 +564,7 @@
                for (ByteString v : attribute)
                {
                  DN member = DN.valueOf(v);
                  memberDNs.remove(toCompactDn(member));
                  memberDNs.remove(new CompactDn(member));
                  nestedGroups.remove(member);
                }
              }
@@ -570,7 +575,7 @@
              for (ByteString v : attribute)
              {
                DN member = DN.valueOf(v);
                memberDNs.add(toCompactDn(member));
                memberDNs.add(new CompactDn(member));
                if (DirectoryServer.getGroupManager().getGroupInstance(member) != null)
                {
                  nestedGroups.add(member);
@@ -595,7 +600,7 @@
    try
    {
      DN userDN = userEntry.getName();
      CompactDn compactUserDN = toCompactDn(userDN);
      CompactDn compactUserDN = new CompactDn(userDN);

      if (memberDNs.contains(compactUserDN))
      {
@@ -626,7 +631,7 @@
  {
    Reject.ifNull(userDN);

    CompactDn compactUserDN = toCompactDn(userDN);
    CompactDn compactUserDN = new CompactDn(userDN);
    lock.writeLock().lock();
    try
    {
@@ -680,26 +685,99 @@
  }

  /**
   * Convert the provided DN to a compact DN.
   *
   * @param dn
   *            The DN
   * @return the compact representation of the DN
   * A compact representation of a DN, suitable for equality and comparisons, and providing a natural hierarchical
   * ordering.
   * <p>
   * The memory consumption compared to a regular DN object is minimal.
   */
  private CompactDn toCompactDn(DN dn)
  static final class CompactDn implements Comparable<CompactDn>
  {
    return dn.compact();
  }
    /** Original string corresponding to the DN. */
    private final byte[] originalValue;

  /**
   * Convert the provided compact DN to a DN.
   *
   * @param compactDn
   *            Compact representation of a DN
   * @return the regular DN
   */
  static DN fromCompactDn(CompactDn compactDn)
  {
    return compactDn.toDn();
    /**
     * Normalized byte string, suitable for equality and comparisons, and providing a natural
     * hierarchical ordering, but not usable as a valid DN.
     */
    private final byte[] normalizedValue;

    @VisibleForTesting
    CompactDn(DN dn)
    {
      this.originalValue = getBytes(dn.toString());
      this.normalizedValue = dn.toNormalizedByteString().toByteArray();
    }

    @Override
    public int compareTo(final CompactDn other)
    {
      final int length1 = normalizedValue.length;
      final int length2 = other.normalizedValue.length;
      int count = Math.min(length1, length2);
      int i = 0;
      int j = 0;
      while (count-- != 0)
      {
        final int firstByte = 0xFF & normalizedValue[i++];
        final int secondByte = 0xFF & other.normalizedValue[j++];
        if (firstByte != secondByte)
        {
          return firstByte - secondByte;
        }
      }
      return length1 - length2;
    }

    /**
     * Returns the DN corresponding to this compact representation.
     *
     * @param serverContext
     *          The server context.
     *
     * @return the DN
     */
    public DN toDn(ServerContext serverContext)
    {
      return DN.valueOf(toString(), serverContext.getSchemaNG());
    }

    @Override
    public int hashCode()
    {
      return Arrays.hashCode(normalizedValue);
    }

    @Override
    public boolean equals(Object obj)
    {
      if (this == obj)
      {
        return true;
      }
      else if (obj instanceof CompactDn)
      {
        final CompactDn other = (CompactDn) obj;
        return Arrays.equals(normalizedValue, other.normalizedValue);
      }
      else
      {
        return false;
      }
    }

    @Override
    public String toString()
    {
      final int length = originalValue.length;
      if (length == 0) {
          return "";
      }
      try {
          return new String(originalValue, 0, length, "UTF-8");
      } catch (final UnsupportedEncodingException e) {
          // TODO: I18N
          throw new RuntimeException("Unable to decode bytes as UTF-8 string", e);
      }
    }
  }
}
}