/*
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. 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
|
*
|
*
|
* Copyright 2008 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.extensions;
|
|
|
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.LinkedList;
|
import java.util.Set;
|
import java.util.concurrent.LinkedBlockingQueue;
|
import java.util.concurrent.TimeUnit;
|
|
import org.opends.server.types.DirectoryException;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.Entry;
|
import org.opends.server.types.LDAPURL;
|
import org.opends.server.types.MemberList;
|
import org.opends.server.types.MembershipException;
|
import org.opends.server.types.SearchFilter;
|
import org.opends.server.types.SearchScope;
|
|
|
|
/**
|
* This class defines a mechanism that may be used to iterate over the
|
* members of a dynamic group, optionally using an additional set of
|
* criteria to further filter the results.
|
*/
|
public class DynamicGroupMemberList
|
extends MemberList
|
{
|
// Indicates whether the search thread has completed its processing.
|
private boolean searchesCompleted;
|
|
// The base DN to use when filtering the set of group members.
|
private final DN baseDN;
|
|
// The DN of the entry containing the group definition.
|
private final DN groupDN;
|
|
// The queue into which results will be placed while they are waiting to be
|
// returned. The types of objects that may be placed in this queue are Entry
|
// objects to return or MembershipException objects to throw.
|
private final LinkedBlockingQueue<Object> resultQueue;
|
|
// The search filter to use when filtering the set of group members.
|
private final SearchFilter filter;
|
|
// The search scope to use when filtering the set of group members.
|
private final SearchScope scope;
|
|
// The set of LDAP URLs that define the membership criteria.
|
private final Set<LDAPURL> memberURLs;
|
|
|
|
/**
|
* Creates a new dynamic group member list with the provided information.
|
*
|
* @param groupDN The DN of the entry containing the group definition.
|
* @param memberURLs The set of LDAP URLs that define the membership
|
* criteria for the associated group.
|
*
|
* @throws DirectoryException If a problem occurs while creating the member
|
* list.
|
*/
|
public DynamicGroupMemberList(DN groupDN, Set<LDAPURL> memberURLs)
|
throws DirectoryException
|
{
|
this(groupDN, memberURLs, null, null, null);
|
}
|
|
|
|
/**
|
* Creates a new dynamic group member list with the provided information.
|
*
|
* @param groupDN The DN of the entry containing the group definition.
|
* @param memberURLs The set of LDAP URLs that define the membership
|
* criteria for the associated group.
|
* @param baseDN The base DN that should be enforced for all entries to
|
* return.
|
* @param scope The scope that should be enforced for all entries to
|
* return.
|
* @param filter The filter that should be enforced for all entries to
|
* return.
|
*
|
* @throws DirectoryException If a problem occurs while creating the member
|
* list.
|
*/
|
public DynamicGroupMemberList(DN groupDN, Set<LDAPURL> memberURLs,
|
DN baseDN, SearchScope scope,
|
SearchFilter filter)
|
throws DirectoryException
|
{
|
this.groupDN = groupDN;
|
this.memberURLs = memberURLs;
|
this.baseDN = baseDN;
|
this.filter = filter;
|
|
if (scope == null)
|
{
|
this.scope = SearchScope.WHOLE_SUBTREE;
|
}
|
else
|
{
|
this.scope = scope;
|
}
|
|
searchesCompleted = false;
|
resultQueue = new LinkedBlockingQueue<Object>(10);
|
|
|
// We're going to have to perform one or more internal searches in order to
|
// get the results. We need to be careful about the way that we construct
|
// them in order to avoid the possibility of getting duplicate results, so
|
// searches with overlapping bases will need to be combined.
|
LinkedHashMap<DN,LinkedList<LDAPURL>> baseDNs =
|
new LinkedHashMap<DN,LinkedList<LDAPURL>>();
|
for (LDAPURL memberURL : memberURLs)
|
{
|
// First, determine the base DN for the search. It needs to be evaluated
|
// as relative to both the overall base DN specified in the set of
|
// criteria, as well as any other existing base DNs in the same hierarchy.
|
DN urlBaseDN = memberURL.getBaseDN();
|
if (baseDN != null)
|
{
|
if (baseDN.isDescendantOf(urlBaseDN))
|
{
|
// The base DN requested by the user is below the base DN for this
|
// URL, so we'll use the base DN requested by the user.
|
urlBaseDN = baseDN;
|
}
|
else if (! urlBaseDN.isDescendantOf(baseDN))
|
{
|
// The base DN from the URL is outside the base requested by the user,
|
// so we can skip this URL altogether.
|
continue;
|
}
|
}
|
|
// If this is the first URL, then we can just add it with the base DN.
|
// Otherwise, we need to see if it needs to be merged with other URLs in
|
// the same hierarchy.
|
if (baseDNs.isEmpty())
|
{
|
LinkedList<LDAPURL> urlList = new LinkedList<LDAPURL>();
|
urlList.add(memberURL);
|
baseDNs.put(urlBaseDN, urlList);
|
}
|
else
|
{
|
// See if the specified base DN is already in the map. If so, then
|
// just add the new URL to the existing list.
|
LinkedList<LDAPURL> urlList = baseDNs.get(urlBaseDN);
|
if (urlList == null)
|
{
|
// There's no existing list for the same base DN, but there might be
|
// DNs in an overlapping hierarchy. If so, then use the base DN that
|
// is closest to the naming context. If not, then add a new list with
|
// the current base DN.
|
boolean found = false;
|
Iterator<DN> iterator = baseDNs.keySet().iterator();
|
while (iterator.hasNext())
|
{
|
DN existingBaseDN = iterator.next();
|
if (urlBaseDN.isDescendantOf(existingBaseDN))
|
{
|
// The base DN for the current URL is below an existing base DN,
|
// so we can just add this URL to the existing list and be done.
|
urlList = baseDNs.get(existingBaseDN);
|
urlList.add(memberURL);
|
found = true;
|
break;
|
}
|
else if (existingBaseDN.isDescendantOf(urlBaseDN))
|
{
|
// The base DN for the current URL is above the existing base DN,
|
// so we should use the base DN for the current URL instead of the
|
// existing one.
|
urlList = baseDNs.get(existingBaseDN);
|
urlList.add(memberURL);
|
iterator.remove();
|
baseDNs.put(urlBaseDN, urlList);
|
found = true;
|
break;
|
}
|
}
|
|
if (! found)
|
{
|
urlList = new LinkedList<LDAPURL>();
|
urlList.add(memberURL);
|
baseDNs.put(urlBaseDN, urlList);
|
}
|
}
|
else
|
{
|
// There was already a list with the same base DN, so just add the
|
// URL.
|
urlList.add(memberURL);
|
}
|
}
|
}
|
|
|
// At this point, we should know what base DN(s) we need to use, so we can
|
// create the filter to use with that base DN. There are some special-case
|
// optimizations that we can do here, but in general the filter will look
|
// like "(&(filter)(|(urlFilters)))".
|
LinkedHashMap<DN,SearchFilter> searchMap =
|
new LinkedHashMap<DN,SearchFilter>();
|
for (DN urlBaseDN : baseDNs.keySet())
|
{
|
LinkedList<LDAPURL> urlList = baseDNs.get(urlBaseDN);
|
LinkedHashSet<SearchFilter> urlFilters =
|
new LinkedHashSet<SearchFilter>();
|
for (LDAPURL url : urlList)
|
{
|
urlFilters.add(url.getFilter());
|
}
|
|
SearchFilter combinedFilter;
|
if (filter == null)
|
{
|
if (urlFilters.size() == 1)
|
{
|
combinedFilter = urlFilters.iterator().next();
|
}
|
else
|
{
|
combinedFilter = SearchFilter.createORFilter(urlFilters);
|
}
|
}
|
else
|
{
|
if (urlFilters.size() == 1)
|
{
|
SearchFilter urlFilter = urlFilters.iterator().next();
|
if (urlFilter.equals(filter))
|
{
|
combinedFilter = filter;
|
}
|
else
|
{
|
LinkedHashSet<SearchFilter> filterSet =
|
new LinkedHashSet<SearchFilter>();
|
filterSet.add(filter);
|
filterSet.add(urlFilter);
|
combinedFilter = SearchFilter.createANDFilter(filterSet);
|
}
|
}
|
else
|
{
|
if (urlFilters.contains(filter))
|
{
|
combinedFilter = filter;
|
}
|
else
|
{
|
LinkedHashSet<SearchFilter> filterSet =
|
new LinkedHashSet<SearchFilter>();
|
filterSet.add(filter);
|
filterSet.add(SearchFilter.createORFilter(urlFilters));
|
combinedFilter = SearchFilter.createANDFilter(filterSet);
|
}
|
}
|
}
|
|
searchMap.put(urlBaseDN, combinedFilter);
|
}
|
|
|
// At this point, we should have all the information we need to perform the
|
// searches. Create arrays of the elements for each.
|
DN[] baseDNArray = new DN[baseDNs.size()];
|
SearchFilter[] filterArray = new SearchFilter[baseDNArray.length];
|
LDAPURL[][] urlArray = new LDAPURL[baseDNArray.length][];
|
Iterator<DN> iterator = baseDNs.keySet().iterator();
|
for (int i=0; i < baseDNArray.length; i++)
|
{
|
baseDNArray[i] = iterator.next();
|
filterArray[i] = searchMap.get(baseDNArray[i]);
|
|
LinkedList<LDAPURL> urlList = baseDNs.get(baseDNArray[i]);
|
urlArray[i] = new LDAPURL[urlList.size()];
|
int j=0;
|
for (LDAPURL url : urlList)
|
{
|
urlArray[i][j++] = url;
|
}
|
}
|
|
|
DynamicGroupSearchThread searchThread =
|
new DynamicGroupSearchThread(this, baseDNArray, filterArray, urlArray);
|
searchThread.start();
|
}
|
|
|
|
/**
|
* Retrieves the DN of the dynamic group with which this dynamic group member
|
* list is associated.
|
*
|
* @return The DN of the dynamic group with which this dynamic group member
|
* list is associated.
|
*/
|
public final DN getDynamicGroupDN()
|
{
|
return groupDN;
|
}
|
|
|
|
/**
|
* Indicates that all of the searches needed to iterate across the member list
|
* have completed and there will not be any more results provided.
|
*/
|
final void setSearchesCompleted()
|
{
|
searchesCompleted = true;
|
}
|
|
|
|
/**
|
* Adds the provided entry to the set of results that should be returned for
|
* this member list.
|
*
|
* @param entry The entry to add to the set of results that should be
|
* returned for this member list.
|
*
|
* @return {@code true} if the entry was added to the result set, or
|
* {@code false} if it was not (either because a timeout expired or
|
* the attempt was interrupted). If this method returns
|
* {@code false}, then the search thread should terminate
|
* immediately.
|
*/
|
final boolean addResult(Entry entry)
|
{
|
try
|
{
|
return resultQueue.offer(entry, 10, TimeUnit.SECONDS);
|
}
|
catch (InterruptedException ie)
|
{
|
return false;
|
}
|
}
|
|
|
|
/**
|
* Adds the provided membership exception so that it will be thrown along with
|
* the set of results for this member list.
|
*
|
* @param membershipException The membership exception to be thrown.
|
*
|
* @return {@code true} if the exception was added to the result set, or
|
* {@code false} if it was not (either because a timeout expired or
|
* the attempt was interrupted). If this method returns
|
* {@code false}, then the search thread should terminate
|
* immediately.
|
*/
|
final boolean addResult(MembershipException membershipException)
|
{
|
try
|
{
|
return resultQueue.offer(membershipException, 10, TimeUnit.SECONDS);
|
}
|
catch (InterruptedException ie)
|
{
|
return false;
|
}
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override()
|
public boolean hasMoreMembers()
|
{
|
while (! searchesCompleted)
|
{
|
if (resultQueue.peek() != null)
|
{
|
return true;
|
}
|
|
try
|
{
|
Thread.sleep(0, 1000);
|
} catch (Exception e) {}
|
}
|
|
return (resultQueue.peek() != null);
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override()
|
public Entry nextMemberEntry()
|
throws MembershipException
|
{
|
if (! hasMoreMembers())
|
{
|
return null;
|
}
|
|
Object result = resultQueue.poll();
|
if (result == null)
|
{
|
close();
|
return null;
|
}
|
else if (result instanceof Entry)
|
{
|
return (Entry) result;
|
}
|
else if (result instanceof MembershipException)
|
{
|
MembershipException me = (MembershipException) result;
|
if (! me.continueIterating())
|
{
|
close();
|
}
|
|
throw me;
|
}
|
|
// We should never get here.
|
close();
|
return null;
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override()
|
public void close()
|
{
|
searchesCompleted = true;
|
resultQueue.clear();
|
}
|
}
|
