/*
|
* 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 2010 Sun Microsystems, Inc.
|
*/
|
|
package org.opends.sdk;
|
|
|
|
import java.io.IOException;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import org.opends.sdk.controls.Control;
|
import org.opends.sdk.controls.ControlDecoder;
|
import org.opends.sdk.requests.*;
|
import org.opends.sdk.responses.*;
|
|
import com.sun.grizzly.TransportFactory;
|
import com.sun.grizzly.nio.transport.TCPNIOTransport;
|
import com.sun.opends.sdk.controls.AccountUsabilityRequestControl;
|
import com.sun.opends.sdk.controls.AccountUsabilityResponseControl;
|
import com.sun.opends.sdk.ldap.GrizzlyLDAPListenerOptions;
|
|
|
|
/**
|
* A simple ldap server that manages 1000 entries and used for running
|
* testcases. //FIXME: make it MT-safe.
|
*/
|
public class LDAPServer implements ServerConnection<Integer>,
|
ServerConnectionFactory<LDAPClientContext, Integer>
|
{
|
// Creates an abandonable request from the ordinary requests.
|
private static class AbandonableRequest implements Request
|
{
|
// the request.
|
private final Request request;
|
|
// whether is has been cancelled.
|
private final AtomicBoolean isCanceled;
|
|
|
|
// Ctor.
|
AbandonableRequest(final Request request)
|
{
|
this.request = request;
|
this.isCanceled = new AtomicBoolean(false);
|
}
|
|
|
|
public Request addControl(final Control cntrl)
|
throws UnsupportedOperationException, NullPointerException
|
{
|
return request.addControl(cntrl);
|
}
|
|
|
|
public <C extends Control> C getControl(final ControlDecoder<C> decoder,
|
final DecodeOptions options) throws DecodeException,
|
NullPointerException
|
{
|
return request.getControl(decoder, options);
|
}
|
|
|
|
public List<Control> getControls()
|
{
|
return request.getControls();
|
}
|
|
|
|
void cancel()
|
{
|
isCanceled.set(true);
|
}
|
|
|
|
boolean isCanceled()
|
{
|
return isCanceled.get();
|
}
|
}
|
|
|
|
// The singleton instance.
|
private static final LDAPServer instance = new LDAPServer();
|
|
|
|
/**
|
* Returns the singleton instance.
|
*
|
* @return Singleton instance.
|
*/
|
public static LDAPServer getInstance()
|
{
|
return instance;
|
}
|
|
|
|
// The mapping between entry DNs and the corresponding entries.
|
private final ConcurrentHashMap<DN, Entry> entryMap = new ConcurrentHashMap<DN, Entry>();
|
|
// The grizzly transport.
|
private final TCPNIOTransport transport = TransportFactory.getInstance()
|
.createTCPTransport();
|
|
// The LDAP listener.
|
private LDAPListener listener = null;
|
|
// whether the server is running.
|
private volatile boolean isRunning;
|
|
// The mapping between the message id and the requests the server is currently
|
// handling.
|
private final ConcurrentHashMap<Integer, AbandonableRequest> requestsInProgress = new ConcurrentHashMap<Integer, AbandonableRequest>();
|
|
// The Set used for locking dns.
|
private final HashSet<DN> lockedDNs = new HashSet<DN>();
|
|
|
|
private LDAPServer()
|
{
|
// Add the root dse first.
|
entryMap.put(DN.rootDN(),
|
Entries.unmodifiableEntry(new LinkedHashMapEntry()));
|
for (int i = 0; i < 1000; i++)
|
{
|
final String dn = String.format("uid=user.%d,ou=people,o=test", i);
|
final String cn = String.format("cn: user.%d", i);
|
final String sn = String.format("sn: %d", i);
|
final String uid = String.format("uid: user.%d", i);
|
|
final DN d = DN.valueOf(dn);
|
final Entry e = new LinkedHashMapEntry("dn: " + dn,
|
"objectclass: person", "objectclass: inetorgperson",
|
"objectclass: top", cn, sn, uid);
|
entryMap.put(d, Entries.unmodifiableEntry(e));
|
}
|
}
|
|
|
|
/**
|
* Abandons the request sent by the client.
|
*
|
* @param context
|
* @param request
|
* @throws UnsupportedOperationException
|
*/
|
public void abandon(final Integer context, final AbandonRequest request)
|
throws UnsupportedOperationException
|
{
|
// Check if we have any concurrent operation with this message id.
|
final AbandonableRequest req = requestsInProgress.get(context);
|
if (req == null)
|
{
|
// Nothing to do here.
|
return;
|
}
|
// Cancel the request
|
req.cancel();
|
// No response is needed.
|
}
|
|
|
|
/**
|
* @param context
|
* @return
|
*/
|
public ServerConnection<Integer> accept(final LDAPClientContext context)
|
{
|
return this;
|
}
|
|
|
|
/**
|
* Adds the request sent by the client.
|
*
|
* @param context
|
* @param request
|
* @param handler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void add(final Integer context, final AddRequest request,
|
final ResultHandler<Result> handler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
Result result = null;
|
final AbandonableRequest abReq = new AbandonableRequest(request);
|
requestsInProgress.put(context, abReq);
|
// Get the DN.
|
final DN dn = request.getName();
|
if (entryMap.containsKey(dn))
|
{
|
// duplicate entry.
|
result = Responses.newResult(ResultCode.ENTRY_ALREADY_EXISTS);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
handler.handleErrorResult(ere);
|
// doesn't matter if it was canceled.
|
requestsInProgress.remove(context);
|
return;
|
}
|
|
// Create an entry out of this request.
|
final SearchResultEntry entry = Responses.newSearchResultEntry(dn);
|
for (final Control control : request.getControls())
|
{
|
entry.addControl(control);
|
}
|
|
for (final Attribute attr : request.getAllAttributes())
|
{
|
entry.addAttribute(attr);
|
}
|
|
if (abReq.isCanceled())
|
{
|
result = Responses.newResult(ResultCode.CANCELLED);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
handler.handleErrorResult(ere);
|
requestsInProgress.remove(context);
|
return;
|
}
|
// Add this to the map.
|
entryMap.put(dn, entry);
|
requestsInProgress.remove(context);
|
result = Responses.newResult(ResultCode.SUCCESS);
|
handler.handleResult(result);
|
}
|
|
|
|
/**
|
* @param context
|
* @param version
|
* @param request
|
* @param resultHandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void bind(final Integer context, final int version,
|
final BindRequest request,
|
final ResultHandler<? super BindResult> resultHandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
// TODO: all bind types.
|
final AbandonableRequest abReq = new AbandonableRequest(request);
|
requestsInProgress.put(context, abReq);
|
resultHandler.handleResult(Responses.newBindResult(ResultCode.SUCCESS));
|
requestsInProgress.remove(context);
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
*/
|
public void closed(final Integer context, final UnbindRequest request)
|
{
|
|
}
|
|
|
|
/**
|
* @param error
|
*/
|
public void closed(final Throwable error)
|
{
|
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param resultHandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void compare(final Integer context, final CompareRequest request,
|
final ResultHandler<? super CompareResult> resultHandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
CompareResult result = null;
|
final AbandonableRequest abReq = new AbandonableRequest(request);
|
requestsInProgress.put(context, abReq);
|
// Get the DN.
|
final DN dn = request.getName();
|
if (!entryMap.containsKey(dn))
|
{
|
// entry not found.
|
result = Responses.newCompareResult(ResultCode.NO_SUCH_ATTRIBUTE);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
resultHandler.handleErrorResult(ere);
|
// doesn't matter if it was canceled.
|
requestsInProgress.remove(context);
|
return;
|
}
|
|
// Get the entry.
|
final Entry entry = entryMap.get(dn);
|
final AttributeDescription attrDesc = request.getAttributeDescription();
|
for (final Attribute attr : entry.getAllAttributes(attrDesc))
|
{
|
final Iterator<ByteString> it = attr.iterator();
|
while (it.hasNext())
|
{
|
final ByteString s = it.next();
|
if (abReq.isCanceled())
|
{
|
final Result r = Responses.newResult(ResultCode.CANCELLED);
|
final ErrorResultException ere = ErrorResultException.wrap(r);
|
resultHandler.handleErrorResult(ere);
|
requestsInProgress.remove(context);
|
return;
|
}
|
if (s.equals(request.getAssertionValue()))
|
{
|
result = Responses.newCompareResult(ResultCode.COMPARE_TRUE);
|
resultHandler.handleResult(result);
|
}
|
}
|
}
|
result = Responses.newCompareResult(ResultCode.COMPARE_FALSE);
|
resultHandler.handleResult(result);
|
requestsInProgress.remove(context);
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param handler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void delete(final Integer context, final DeleteRequest request,
|
final ResultHandler<Result> handler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
Result result = null;
|
final AbandonableRequest abReq = new AbandonableRequest(request);
|
requestsInProgress.put(context, abReq);
|
// Get the DN.
|
final DN dn = request.getName();
|
if (!entryMap.containsKey(dn))
|
{
|
// entry is not found.
|
result = Responses.newResult(ResultCode.NO_SUCH_OBJECT);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
handler.handleErrorResult(ere);
|
// doesn't matter if it was canceled.
|
requestsInProgress.remove(context);
|
return;
|
}
|
|
if (abReq.isCanceled())
|
{
|
result = Responses.newResult(ResultCode.CANCELLED);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
handler.handleErrorResult(ere);
|
requestsInProgress.remove(context);
|
return;
|
}
|
// Remove this from the map.
|
entryMap.remove(dn);
|
requestsInProgress.remove(context);
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param resultHandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public <R extends ExtendedResult> void extendedRequest(final Integer context,
|
final ExtendedRequest<R> request, final ResultHandler<R> resultHandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
// TODO:
|
}
|
|
|
|
/**
|
* Returns whether the server is running or not.
|
*
|
* @return Whether the server is running.
|
*/
|
public boolean isRunning()
|
{
|
return isRunning;
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param resultHandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void modify(final Integer context, final ModifyRequest request,
|
final ResultHandler<Result> resultHandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
// TODO:
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param resultHandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void modifyDN(final Integer context, final ModifyDNRequest request,
|
final ResultHandler<Result> resultHandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
// TODO
|
}
|
|
|
|
/**
|
* @param context
|
* @param request
|
* @param resultHandler
|
* @param searchResulthandler
|
* @param intermediateResponseHandler
|
* @throws UnsupportedOperationException
|
*/
|
public void search(final Integer context, final SearchRequest request,
|
final ResultHandler<Result> resultHandler,
|
final SearchResultHandler searchResulthandler,
|
final IntermediateResponseHandler intermediateResponseHandler)
|
throws UnsupportedOperationException
|
{
|
Result result = null;
|
final AbandonableRequest abReq = new AbandonableRequest(request);
|
requestsInProgress.put(context, abReq);
|
// Get the DN.
|
final DN dn = request.getName();
|
if (!entryMap.containsKey(dn))
|
{
|
// Entry not found.
|
result = Responses.newResult(ResultCode.NO_SUCH_OBJECT);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
resultHandler.handleErrorResult(ere);
|
// Should searchResultHandler handle anything?
|
|
// doesn't matter if it was canceled.
|
requestsInProgress.remove(context);
|
return;
|
}
|
|
if (abReq.isCanceled())
|
{
|
result = Responses.newResult(ResultCode.CANCELLED);
|
final ErrorResultException ere = ErrorResultException.wrap(result);
|
resultHandler.handleErrorResult(ere);
|
requestsInProgress.remove(context);
|
return;
|
}
|
|
final SearchResultEntry e = Responses.newSearchResultEntry(
|
new LinkedHashMapEntry(entryMap.get(dn)));
|
// Check we have had any controls in the request.
|
for (final Control control : request.getControls())
|
{
|
if (control.getOID().equals(AccountUsabilityRequestControl.OID))
|
{
|
e.addControl(AccountUsabilityResponseControl.newControl(false, false,
|
false, 10, false, 0));
|
}
|
}
|
searchResulthandler.handleEntry(e);
|
result = Responses.newResult(ResultCode.SUCCESS);
|
resultHandler.handleResult(result);
|
requestsInProgress.remove(context);
|
}
|
|
|
|
/**
|
* Starts the server.
|
*
|
* @param port
|
* @exception IOException
|
*/
|
public synchronized void start(final int port) throws IOException
|
{
|
if (isRunning)
|
{
|
return;
|
}
|
transport.setSelectorRunnersCount(2);
|
listener = new LDAPListener(port, new LDAPServer(),
|
new GrizzlyLDAPListenerOptions().setTCPNIOTransport(transport)
|
.setBacklog(4096));
|
transport.start();
|
isRunning = true;
|
}
|
|
|
|
/**
|
* Stops the server.
|
*/
|
public synchronized void stop()
|
{
|
if (!isRunning)
|
{
|
return;
|
}
|
try
|
{
|
listener.close();
|
}
|
catch (final IOException e)
|
{
|
e.printStackTrace();
|
}
|
try
|
{
|
transport.stop();
|
}
|
catch (final IOException e)
|
{
|
e.printStackTrace();
|
}
|
TransportFactory.getInstance().close();
|
isRunning = false;
|
}
|
}
|
