From f2160f4bd1c8ac67e5a86a6710d431e8932877f9 Mon Sep 17 00:00:00 2001
From: matthew_swift <matthew_swift@localhost>
Date: Fri, 28 May 2010 11:47:51 +0000
Subject: [PATCH] Synchronize SDK on java.net with internal repository.
---
sdk/src/org/opends/sdk/AuthenticatedConnectionFactory.java | 412 ++++++++++++++++++++++++++++++++++++----------------------
1 files changed, 258 insertions(+), 154 deletions(-)
diff --git a/sdk/src/org/opends/sdk/AuthenticatedConnectionFactory.java b/sdk/src/org/opends/sdk/AuthenticatedConnectionFactory.java
index df3a43b..a0030c0 100644
--- a/sdk/src/org/opends/sdk/AuthenticatedConnectionFactory.java
+++ b/sdk/src/org/opends/sdk/AuthenticatedConnectionFactory.java
@@ -32,10 +32,7 @@
import java.util.Collection;
import org.opends.sdk.requests.*;
-import org.opends.sdk.responses.BindResult;
-import org.opends.sdk.responses.CompareResult;
-import org.opends.sdk.responses.Result;
-import org.opends.sdk.responses.SearchResultEntry;
+import org.opends.sdk.responses.*;
import org.opends.sdk.schema.Schema;
import com.sun.opends.sdk.util.FutureResultTransformer;
@@ -44,70 +41,26 @@
/**
- * An authenticated connection factory can be used to create
- * pre-authenticated connections to a Directory Server.
+ * An authenticated connection factory can be used to create pre-authenticated
+ * connections to a Directory Server.
* <p>
- * The connections returned by an authenticated connection factory
- * support all operations with the exception of Bind requests. Attempts
- * to perform a Bind will result in an {@code
- * UnsupportedOperationException}.
+ * The connections returned by an authenticated connection factory support all
+ * operations with the exception of Bind requests. Attempts to perform a Bind
+ * will result in an {@code UnsupportedOperationException}.
* <p>
- * If the Bind request fails for some reason (e.g. invalid credentials),
- * then the connection attempt will fail and an {@code
- * ErrorResultException} will be thrown.
+ * If the Bind request fails for some reason (e.g. invalid credentials), then
+ * the connection attempt will fail and an {@code ErrorResultException} will be
+ * thrown.
*/
-final class AuthenticatedConnectionFactory extends
- AbstractConnectionFactory
+final class AuthenticatedConnectionFactory extends AbstractConnectionFactory
{
- private final BindRequest request;
-
- private final ConnectionFactory parentFactory;
-
-
-
/**
- * Creates a new authenticated connection factory which will obtain
- * connections using the provided connection factory and immediately
- * perform the provided Bind request.
- *
- * @param factory
- * The connection factory to use for connecting to the
- * Directory Server.
- * @param request
- * The Bind request to use for authentication.
+ * An authenticated asynchronous connection supports all operations except
+ * Bind operations.
*/
- AuthenticatedConnectionFactory(ConnectionFactory factory,
- BindRequest request) throws NullPointerException
- {
- this.parentFactory = factory;
-
- // FIXME: should do a defensive copy.
- this.request = request;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- public FutureResult<AsynchronousConnection> getAsynchronousConnection(
- ResultHandler<AsynchronousConnection> handler)
- {
- FutureResultImpl future = new FutureResultImpl(request, handler);
- future.futureConnectionResult.setFutureResult(parentFactory
- .getAsynchronousConnection(future.futureConnectionResult));
- return future.futureBindResult;
- }
-
-
-
- /**
- * An authenticated asynchronous connection supports all operations
- * except Bind operations.
- */
- public static final class AuthenticatedAsynchronousConnection
- implements AsynchronousConnection
+ public static final class AuthenticatedAsynchronousConnection implements
+ AsynchronousConnection
{
private final AsynchronousConnection connection;
@@ -115,24 +68,24 @@
private AuthenticatedAsynchronousConnection(
- AsynchronousConnection connection)
+ final AsynchronousConnection connection)
{
this.connection = connection;
}
- public void abandon(AbandonRequest request)
+ public FutureResult<Void> abandon(final AbandonRequest request)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
- connection.abandon(request);
+ return connection.abandon(request);
}
- public FutureResult<Result> add(AddRequest request,
- ResultHandler<Result> handler)
+ public FutureResult<Result> add(final AddRequest request,
+ final ResultHandler<Result> handler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
@@ -141,8 +94,20 @@
+ public FutureResult<Result> add(final AddRequest request,
+ final ResultHandler<Result> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection
+ .add(request, resultHandler, intermediateResponseHandler);
+ }
+
+
+
public void addConnectionEventListener(
- ConnectionEventListener listener) throws IllegalStateException,
+ final ConnectionEventListener listener) throws IllegalStateException,
NullPointerException
{
connection.addConnectionEventListener(listener);
@@ -151,12 +116,11 @@
/**
- * Bind operations are not supported by pre-authenticated
- * connections. This method will always throw {@code
- * UnsupportedOperationException}.
+ * Bind operations are not supported by pre-authenticated connections. This
+ * method will always throw {@code UnsupportedOperationException}.
*/
- public FutureResult<BindResult> bind(BindRequest request,
- ResultHandler<? super BindResult> handler)
+ public FutureResult<BindResult> bind(final BindRequest request,
+ final ResultHandler<? super BindResult> handler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
@@ -165,6 +129,18 @@
+ public FutureResult<BindResult> bind(final BindRequest request,
+ final ResultHandler<? super BindResult> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.bind(request, resultHandler,
+ intermediateResponseHandler);
+ }
+
+
+
public void close()
{
connection.close();
@@ -172,7 +148,7 @@
- public void close(UnbindRequest request, String reason)
+ public void close(final UnbindRequest request, final String reason)
throws NullPointerException
{
connection.close(request, reason);
@@ -180,8 +156,8 @@
- public FutureResult<CompareResult> compare(CompareRequest request,
- ResultHandler<? super CompareResult> handler)
+ public FutureResult<CompareResult> compare(final CompareRequest request,
+ final ResultHandler<? super CompareResult> handler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
@@ -190,8 +166,20 @@
- public FutureResult<Result> delete(DeleteRequest request,
- ResultHandler<Result> handler)
+ public FutureResult<CompareResult> compare(final CompareRequest request,
+ final ResultHandler<? super CompareResult> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.compare(request, resultHandler,
+ intermediateResponseHandler);
+ }
+
+
+
+ public FutureResult<Result> delete(final DeleteRequest request,
+ final ResultHandler<Result> handler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
@@ -200,8 +188,20 @@
- public <R extends Result> FutureResult<R> extendedRequest(
- ExtendedRequest<R> request, ResultHandler<? super R> handler)
+ public FutureResult<Result> delete(final DeleteRequest request,
+ final ResultHandler<Result> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.delete(request, resultHandler,
+ intermediateResponseHandler);
+ }
+
+
+
+ public <R extends ExtendedResult> FutureResult<R> extendedRequest(
+ final ExtendedRequest<R> request, final ResultHandler<? super R> handler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
@@ -210,42 +210,15 @@
- public FutureResult<Result> modify(ModifyRequest request,
- ResultHandler<Result> handler)
+ public <R extends ExtendedResult> FutureResult<R> extendedRequest(
+ final ExtendedRequest<R> request,
+ final ResultHandler<? super R> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
- return connection.modify(request, handler);
- }
-
-
-
- public FutureResult<Result> modifyDN(ModifyDNRequest request,
- ResultHandler<Result> handler)
- throws UnsupportedOperationException, IllegalStateException,
- NullPointerException
- {
- return connection.modifyDN(request, handler);
- }
-
-
-
- public void removeConnectionEventListener(
- ConnectionEventListener listener) throws NullPointerException
- {
- connection.removeConnectionEventListener(listener);
- }
-
-
-
- public FutureResult<Result> search(SearchRequest request,
- ResultHandler<Result> resultHandler,
- SearchResultHandler searchResulthandler)
- throws UnsupportedOperationException, IllegalStateException,
- NullPointerException
- {
- return connection.search(request, resultHandler,
- searchResulthandler);
+ return connection.extendedRequest(request, resultHandler,
+ intermediateResponseHandler);
}
@@ -253,9 +226,9 @@
/**
* {@inheritDoc}
*/
- public boolean isValid()
+ public Connection getSynchronousConnection()
{
- return connection.isValid();
+ return new SynchronousConnection(this);
}
@@ -273,8 +246,76 @@
/**
* {@inheritDoc}
*/
+ public boolean isValid()
+ {
+ return connection.isValid();
+ }
+
+
+
+ public FutureResult<Result> modify(final ModifyRequest request,
+ final ResultHandler<Result> handler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.modify(request, handler);
+ }
+
+
+
+ public FutureResult<Result> modify(final ModifyRequest request,
+ final ResultHandler<Result> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.modify(request, resultHandler,
+ intermediateResponseHandler);
+ }
+
+
+
+ public FutureResult<Result> modifyDN(final ModifyDNRequest request,
+ final ResultHandler<Result> handler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.modifyDN(request, handler);
+ }
+
+
+
+ public FutureResult<Result> modifyDN(final ModifyDNRequest request,
+ final ResultHandler<Result> resultHandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.modifyDN(request, resultHandler,
+ intermediateResponseHandler);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public FutureResult<SearchResultEntry> readEntry(final DN name,
+ final Collection<String> attributeDescriptions,
+ final ResultHandler<? super SearchResultEntry> resultHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.readEntry(name, attributeDescriptions, resultHandler);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
public FutureResult<RootDSE> readRootDSE(
- ResultHandler<RootDSE> handler)
+ final ResultHandler<RootDSE> handler)
throws UnsupportedOperationException, IllegalStateException
{
return connection.readRootDSE(handler);
@@ -285,14 +326,55 @@
/**
* {@inheritDoc}
*/
- public FutureResult<SearchResultEntry> readEntry(DN name,
- Collection<String> attributeDescriptions,
- ResultHandler<? super SearchResultEntry> resultHandler)
+ public FutureResult<Schema> readSchema(final DN name,
+ final ResultHandler<Schema> handler)
+ throws UnsupportedOperationException, IllegalStateException
+ {
+ return connection.readSchema(name, handler);
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public FutureResult<Schema> readSchemaForEntry(final DN name,
+ final ResultHandler<Schema> handler)
+ throws UnsupportedOperationException, IllegalStateException
+ {
+ return connection.readSchemaForEntry(name, handler);
+ }
+
+
+
+ public void removeConnectionEventListener(
+ final ConnectionEventListener listener) throws NullPointerException
+ {
+ connection.removeConnectionEventListener(listener);
+ }
+
+
+
+ public FutureResult<Result> search(final SearchRequest request,
+ final ResultHandler<Result> resultHandler,
+ final SearchResultHandler searchResulthandler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
- return connection.readEntry(name, attributeDescriptions,
- resultHandler);
+ return connection.search(request, resultHandler, searchResulthandler);
+ }
+
+
+
+ public FutureResult<Result> search(final SearchRequest request,
+ final ResultHandler<Result> resultHandler,
+ final SearchResultHandler searchResulthandler,
+ final IntermediateResponseHandler intermediateResponseHandler)
+ throws UnsupportedOperationException, IllegalStateException,
+ NullPointerException
+ {
+ return connection.search(request, resultHandler, searchResulthandler,
+ intermediateResponseHandler);
}
@@ -301,38 +383,14 @@
* {@inheritDoc}
*/
public FutureResult<SearchResultEntry> searchSingleEntry(
- SearchRequest request,
- ResultHandler<? super SearchResultEntry> resultHandler)
+ final SearchRequest request,
+ final ResultHandler<? super SearchResultEntry> resultHandler)
throws UnsupportedOperationException, IllegalStateException,
NullPointerException
{
return connection.searchSingleEntry(request, resultHandler);
}
-
-
- /**
- * {@inheritDoc}
- */
- public FutureResult<Schema> readSchemaForEntry(DN name,
- ResultHandler<Schema> handler)
- throws UnsupportedOperationException, IllegalStateException
- {
- return connection.readSchemaForEntry(name, handler);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- public FutureResult<Schema> readSchema(DN name,
- ResultHandler<Schema> handler)
- throws UnsupportedOperationException, IllegalStateException
- {
- return connection.readSchema(name, handler);
- }
-
}
@@ -349,16 +407,17 @@
- private FutureResultImpl(BindRequest request,
- ResultHandler<? super AsynchronousConnection> handler)
+ private FutureResultImpl(final BindRequest request,
+ final ResultHandler<? super AsynchronousConnection> handler)
{
this.bindRequest = request;
this.futureBindResult = new FutureResultTransformer<BindResult, AsynchronousConnection>(
handler)
{
+ @Override
protected ErrorResultException transformErrorResult(
- ErrorResultException errorResult)
+ final ErrorResultException errorResult)
{
// Ensure that the connection is closed.
try
@@ -366,7 +425,7 @@
connection.close();
connection = null;
}
- catch (Exception e)
+ catch (final Exception e)
{
// Ignore.
}
@@ -375,8 +434,9 @@
- protected AsynchronousConnection transformResult(
- BindResult result) throws ErrorResultException
+ @Override
+ protected AsynchronousConnection transformResult(final BindResult result)
+ throws ErrorResultException
{
return new AuthenticatedAsynchronousConnection(connection);
}
@@ -386,9 +446,10 @@
futureBindResult)
{
+ @Override
protected FutureResult<? extends BindResult> chainResult(
- AsynchronousConnection innerResult,
- ResultHandler<? super BindResult> handler)
+ final AsynchronousConnection innerResult,
+ final ResultHandler<? super BindResult> handler)
throws ErrorResultException
{
connection = innerResult;
@@ -400,4 +461,47 @@
}
+
+
+ private final BindRequest request;
+
+ private final ConnectionFactory parentFactory;
+
+
+
+ /**
+ * Creates a new authenticated connection factory which will obtain
+ * connections using the provided connection factory and immediately perform
+ * the provided Bind request.
+ *
+ * @param factory
+ * The connection factory to use for connecting to the Directory
+ * Server.
+ * @param request
+ * The Bind request to use for authentication.
+ */
+ AuthenticatedConnectionFactory(final ConnectionFactory factory,
+ final BindRequest request)
+ {
+ this.parentFactory = factory;
+
+ // FIXME: should do a defensive copy.
+ this.request = request;
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public FutureResult<AsynchronousConnection> getAsynchronousConnection(
+ final ResultHandler<AsynchronousConnection> handler)
+ {
+ final FutureResultImpl future = new FutureResultImpl(request, handler);
+ future.futureConnectionResult.setFutureResult(parentFactory
+ .getAsynchronousConnection(future.futureConnectionResult));
+ return future.futureBindResult;
+ }
+
}
--
Gitblit v1.10.0