From 263d085885df024dca9250cc03c807912b0a7662 Mon Sep 17 00:00:00 2001
From: Matthew Swift <matthew.swift@forgerock.com>
Date: Tue, 24 Apr 2012 22:33:21 +0000
Subject: [PATCH] Reformat to comply with new Checkstyle rules.
---
opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldap/RequestHandlerFactoryAdapter.java | 1601 ++++++++++++++++++++++++++--------------------------------
1 files changed, 712 insertions(+), 889 deletions(-)
diff --git a/opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldap/RequestHandlerFactoryAdapter.java b/opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldap/RequestHandlerFactoryAdapter.java
index 9165989..2f4ee76 100644
--- a/opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldap/RequestHandlerFactoryAdapter.java
+++ b/opendj3/opendj-ldap-sdk/src/main/java/org/forgerock/opendj/ldap/RequestHandlerFactoryAdapter.java
@@ -6,17 +6,16 @@
* (the "License"). You may not use this file except in compliance
* with the License.
*
- * You can obtain a copy of the license at
- * trunk/opendj3/legal-notices/CDDLv1_0.txt
+ * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
* or http://forgerock.org/license/CDDLv1.0.html.
* 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/opendj3/legal-notices/CDDLv1_0.txt. If applicable,
- * add the following below this CDDL HEADER, with the fields enclosed
- * by brackets "[]" replaced with your own identifying information:
+ * file and include the License file at legal-notices/CDDLv1_0.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
@@ -27,8 +26,6 @@
package org.forgerock.opendj.ldap;
-
-
import static org.forgerock.opendj.ldap.CoreMessages.*;
import static org.forgerock.opendj.ldap.ErrorResultException.newErrorResult;
@@ -39,918 +36,744 @@
import java.util.concurrent.atomic.AtomicBoolean;
import org.forgerock.i18n.LocalizableMessage;
-import org.forgerock.opendj.ldap.requests.*;
-import org.forgerock.opendj.ldap.responses.*;
+import org.forgerock.opendj.ldap.requests.AbandonRequest;
+import org.forgerock.opendj.ldap.requests.AddRequest;
+import org.forgerock.opendj.ldap.requests.BindRequest;
+import org.forgerock.opendj.ldap.requests.CancelExtendedRequest;
+import org.forgerock.opendj.ldap.requests.CompareRequest;
+import org.forgerock.opendj.ldap.requests.DeleteRequest;
+import org.forgerock.opendj.ldap.requests.ExtendedRequest;
+import org.forgerock.opendj.ldap.requests.ModifyDNRequest;
+import org.forgerock.opendj.ldap.requests.ModifyRequest;
+import org.forgerock.opendj.ldap.requests.SearchRequest;
+import org.forgerock.opendj.ldap.requests.StartTLSExtendedRequest;
+import org.forgerock.opendj.ldap.requests.UnbindRequest;
+import org.forgerock.opendj.ldap.responses.BindResult;
+import org.forgerock.opendj.ldap.responses.CompareResult;
+import org.forgerock.opendj.ldap.responses.ExtendedResult;
+import org.forgerock.opendj.ldap.responses.Responses;
+import org.forgerock.opendj.ldap.responses.Result;
+import org.forgerock.opendj.ldap.responses.SearchResultEntry;
+import org.forgerock.opendj.ldap.responses.SearchResultReference;
import com.forgerock.opendj.util.Validator;
-
-
/**
* An adapter which converts a {@code RequestHandlerFactory} into a
* {@code ServerConnectionFactory}.
*
* @param <C>
- * The type of client context.
+ * The type of client context.
*/
-final class RequestHandlerFactoryAdapter<C> implements
- ServerConnectionFactory<C, Integer>
-{
- /**
- * Request context implementation.
- */
- private static class RequestContextImpl<S extends Result, H extends ResultHandler<? super S>>
- implements RequestContext, ResultHandler<S>
- {
-
- // Adapter class which invokes cancel result handlers with correct result
- // type.
- private static final class ExtendedResultHandlerHolder<R extends ExtendedResult>
- {
- private final ExtendedRequest<R> request;
- private final ResultHandler<? super R> resultHandler;
-
-
-
- private ExtendedResultHandlerHolder(final ExtendedRequest<R> request,
- final ResultHandler<? super R> resultHandler)
- {
- this.request = request;
- this.resultHandler = resultHandler;
- }
-
-
-
- private void handleSuccess()
- {
- final R cancelResult = request.getResultDecoder()
- .newExtendedErrorResult(ResultCode.SUCCESS, "", "");
- resultHandler.handleResult(cancelResult);
- }
-
-
-
- private void handleTooLate()
- {
- final R cancelResult = request.getResultDecoder()
- .newExtendedErrorResult(ResultCode.TOO_LATE, "", "");
- resultHandler.handleErrorResult(ErrorResultException
- .newErrorResult(cancelResult));
- }
- }
-
-
-
- private static enum RequestState
- {
- // Request active
- PENDING,
-
- // Request active, cancel requested
- CANCEL_REQUESTED,
-
- // Request active, too late to cancel
- TOO_LATE,
-
- // Result sent, not cancelled
- RESULT_SENT,
-
- // Result sent, was cancelled
- CANCELLED;
- }
-
-
-
- private final int messageID;
-
- // Cancellation state guarded by lock.
- private final Object stateLock = new Object();
-
- // These should be notified when a cancel request arrives, at most once.
- private List<CancelRequestListener> cancelRequestListeners = null;
-
- // These should be notified when the result is set.
- private List<ExtendedResultHandlerHolder<?>> cancelResultHandlers = null;
-
- private RequestState state = RequestState.PENDING;
-
- private LocalizableMessage cancelRequestReason = null;
-
- private boolean sendResult = true;
-
- private final boolean isCancelSupported;
-
- private final ServerConnectionImpl<?> clientConnection;
-
- protected final H resultHandler;
-
-
-
- protected RequestContextImpl(
- final ServerConnectionImpl<?> clientConnection, final H resultHandler,
- final int messageID, final boolean isCancelSupported)
- {
- this.clientConnection = clientConnection;
- this.resultHandler = resultHandler;
- this.messageID = messageID;
- this.isCancelSupported = isCancelSupported;
- }
-
-
-
+final class RequestHandlerFactoryAdapter<C> implements ServerConnectionFactory<C, Integer> {
/**
- * {@inheritDoc}
+ * Request context implementation.
*/
- @Override
- public void addCancelRequestListener(final CancelRequestListener listener)
- {
- Validator.ensureNotNull(listener);
+ private static class RequestContextImpl<S extends Result, H extends ResultHandler<? super S>>
+ implements RequestContext, ResultHandler<S> {
- boolean invokeImmediately = false;
- synchronized (stateLock)
- {
- switch (state)
- {
- case PENDING:
- if (cancelRequestListeners == null)
- {
- cancelRequestListeners = new LinkedList<CancelRequestListener>();
- }
- cancelRequestListeners.add(listener);
- break;
- case CANCEL_REQUESTED:
- // Signal immediately outside lock.
- invokeImmediately = true;
- break;
- case TOO_LATE:
- case RESULT_SENT:
- case CANCELLED:
- // No point in registering the callback since the request can never be
- // cancelled now.
- break;
- }
- }
+ // Adapter class which invokes cancel result handlers with correct
+ // result
+ // type.
+ private static final class ExtendedResultHandlerHolder<R extends ExtendedResult> {
+ private final ExtendedRequest<R> request;
+ private final ResultHandler<? super R> resultHandler;
- if (invokeImmediately)
- {
- listener.handleCancelRequest(cancelRequestReason);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void checkIfCancelled(final boolean signalTooLate)
- throws CancelledResultException
- {
- synchronized (stateLock)
- {
- switch (state)
- {
- case PENDING:
- // No cancel request, so no handlers, just switch state.
- if (signalTooLate)
- {
- cancelRequestListeners = null;
- state = RequestState.TOO_LATE;
- }
- break;
- case CANCEL_REQUESTED:
- // Don't change state: let the handler ack the cancellation request.
- throw (CancelledResultException) newErrorResult(ResultCode.CANCELLED,
- cancelRequestReason.toString());
- case TOO_LATE:
- // Already too late. Nothing to do.
- break;
- case RESULT_SENT:
- case CANCELLED:
- // This should not happen - could throw an illegal state exception?
- break;
- }
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int getMessageID()
- {
- return messageID;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleErrorResult(final ErrorResultException error)
- {
- if (clientConnection.removePendingRequest(this))
- {
- if (setResult(error.getResult()))
- {
- // FIXME: we must invoke the result handler even when abandoned so
- // that chained result handlers may clean up, log, etc. We really need
- // to signal that the result must not be sent to the client.
- }
- resultHandler.handleErrorResult(error);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleResult(final S result)
- {
- if (clientConnection.removePendingRequest(this))
- {
- if (setResult(result))
- {
- // FIXME: we must invoke the result handler even when abandoned so
- // that chained result handlers may clean up, log, etc. We really need
- // to signal that the result must not be sent to the client.
- }
- resultHandler.handleResult(result);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void removeCancelRequestListener(final CancelRequestListener listener)
- {
- Validator.ensureNotNull(listener);
-
- synchronized (stateLock)
- {
- if (cancelRequestListeners != null)
- {
- cancelRequestListeners.remove(listener);
- }
- }
- }
-
-
-
- private <R extends ExtendedResult> void cancel(
- final LocalizableMessage reason,
- final ExtendedRequest<R> cancelRequest,
- final ResultHandler<? super R> cancelResultHandler,
- final boolean sendResult)
- {
- Validator.ensureNotNull(reason);
-
- if (!isCancelSupported)
- {
- if (cancelResultHandler != null)
- {
- final Result result = Responses
- .newGenericExtendedResult(ResultCode.CANNOT_CANCEL);
- cancelResultHandler.handleErrorResult(newErrorResult(result));
- }
- return;
- }
-
- List<CancelRequestListener> tmpListeners = null;
- boolean invokeResultHandler = false;
- boolean resultHandlerIsSuccess = false;
-
- synchronized (stateLock)
- {
- switch (state)
- {
- case PENDING:
- // Switch to CANCEL_REQUESTED state.
- cancelRequestReason = reason;
- if (cancelResultHandler != null)
- {
- cancelResultHandlers = new LinkedList<ExtendedResultHandlerHolder<?>>();
- cancelResultHandlers.add(new ExtendedResultHandlerHolder<R>(
- cancelRequest, cancelResultHandler));
- }
- tmpListeners = cancelRequestListeners;
- cancelRequestListeners = null;
- state = RequestState.CANCEL_REQUESTED;
- this.sendResult &= sendResult;
- break;
- case CANCEL_REQUESTED:
- // Cancel already request so listeners already invoked.
- if (cancelResultHandler != null)
- {
- if (cancelResultHandlers == null)
- {
- cancelResultHandlers = new LinkedList<ExtendedResultHandlerHolder<?>>();
+ private ExtendedResultHandlerHolder(final ExtendedRequest<R> request,
+ final ResultHandler<? super R> resultHandler) {
+ this.request = request;
+ this.resultHandler = resultHandler;
}
- cancelResultHandlers.add(new ExtendedResultHandlerHolder<R>(
- cancelRequest, cancelResultHandler));
- }
- break;
- case TOO_LATE:
- case RESULT_SENT:
- // Cannot cancel, so invoke result handler immediately outside of
- // lock.
- if (cancelResultHandler != null)
- {
- invokeResultHandler = true;
- resultHandlerIsSuccess = false;
- }
- break;
- case CANCELLED:
- // Multiple cancellation attempts. Clients should not do this, but the
- // cancel will effectively succeed immediately, so invoke result
- // handler immediately outside of lock.
- if (cancelResultHandler != null)
- {
- invokeResultHandler = true;
- resultHandlerIsSuccess = true;
- }
- break;
- }
- }
- // Invoke listeners outside of lock.
- if (tmpListeners != null)
- {
- for (final CancelRequestListener listener : tmpListeners)
- {
- listener.handleCancelRequest(reason);
- }
- }
+ private void handleSuccess() {
+ final R cancelResult =
+ request.getResultDecoder().newExtendedErrorResult(ResultCode.SUCCESS, "",
+ "");
+ resultHandler.handleResult(cancelResult);
+ }
- if (invokeResultHandler)
- {
- if (resultHandlerIsSuccess)
- {
- final R result = cancelRequest.getResultDecoder()
- .newExtendedErrorResult(ResultCode.SUCCESS, "", "");
- cancelResultHandler.handleResult(result);
+ private void handleTooLate() {
+ final R cancelResult =
+ request.getResultDecoder().newExtendedErrorResult(ResultCode.TOO_LATE, "",
+ "");
+ resultHandler.handleErrorResult(ErrorResultException.newErrorResult(cancelResult));
+ }
}
- else
- {
- final Result result = Responses
- .newGenericExtendedResult(ResultCode.TOO_LATE);
- cancelResultHandler.handleErrorResult(ErrorResultException
- .newErrorResult(result));
+
+ private static enum RequestState {
+ // Request active
+ PENDING,
+
+ // Request active, cancel requested
+ CANCEL_REQUESTED,
+
+ // Request active, too late to cancel
+ TOO_LATE,
+
+ // Result sent, not cancelled
+ RESULT_SENT,
+
+ // Result sent, was cancelled
+ CANCELLED;
}
- }
+
+ private final int messageID;
+
+ // Cancellation state guarded by lock.
+ private final Object stateLock = new Object();
+
+ // These should be notified when a cancel request arrives, at most once.
+ private List<CancelRequestListener> cancelRequestListeners = null;
+
+ // These should be notified when the result is set.
+ private List<ExtendedResultHandlerHolder<?>> cancelResultHandlers = null;
+
+ private RequestState state = RequestState.PENDING;
+
+ private LocalizableMessage cancelRequestReason = null;
+
+ private boolean sendResult = true;
+
+ private final boolean isCancelSupported;
+
+ private final ServerConnectionImpl<?> clientConnection;
+
+ protected final H resultHandler;
+
+ protected RequestContextImpl(final ServerConnectionImpl<?> clientConnection,
+ final H resultHandler, final int messageID, final boolean isCancelSupported) {
+ this.clientConnection = clientConnection;
+ this.resultHandler = resultHandler;
+ this.messageID = messageID;
+ this.isCancelSupported = isCancelSupported;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void addCancelRequestListener(final CancelRequestListener listener) {
+ Validator.ensureNotNull(listener);
+
+ boolean invokeImmediately = false;
+ synchronized (stateLock) {
+ switch (state) {
+ case PENDING:
+ if (cancelRequestListeners == null) {
+ cancelRequestListeners = new LinkedList<CancelRequestListener>();
+ }
+ cancelRequestListeners.add(listener);
+ break;
+ case CANCEL_REQUESTED:
+ // Signal immediately outside lock.
+ invokeImmediately = true;
+ break;
+ case TOO_LATE:
+ case RESULT_SENT:
+ case CANCELLED:
+ // No point in registering the callback since the request
+ // can never be
+ // cancelled now.
+ break;
+ }
+ }
+
+ if (invokeImmediately) {
+ listener.handleCancelRequest(cancelRequestReason);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void checkIfCancelled(final boolean signalTooLate) throws CancelledResultException {
+ synchronized (stateLock) {
+ switch (state) {
+ case PENDING:
+ // No cancel request, so no handlers, just switch state.
+ if (signalTooLate) {
+ cancelRequestListeners = null;
+ state = RequestState.TOO_LATE;
+ }
+ break;
+ case CANCEL_REQUESTED:
+ // Don't change state: let the handler ack the cancellation
+ // request.
+ throw (CancelledResultException) newErrorResult(ResultCode.CANCELLED,
+ cancelRequestReason.toString());
+ case TOO_LATE:
+ // Already too late. Nothing to do.
+ break;
+ case RESULT_SENT:
+ case CANCELLED:
+ // This should not happen - could throw an illegal state
+ // exception?
+ break;
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int getMessageID() {
+ return messageID;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleErrorResult(final ErrorResultException error) {
+ if (clientConnection.removePendingRequest(this)) {
+ if (setResult(error.getResult())) {
+ // FIXME: we must invoke the result handler even when
+ // abandoned so
+ // that chained result handlers may clean up, log, etc. We
+ // really need
+ // to signal that the result must not be sent to the client.
+ }
+ resultHandler.handleErrorResult(error);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleResult(final S result) {
+ if (clientConnection.removePendingRequest(this)) {
+ if (setResult(result)) {
+ // FIXME: we must invoke the result handler even when
+ // abandoned so
+ // that chained result handlers may clean up, log, etc. We
+ // really need
+ // to signal that the result must not be sent to the client.
+ }
+ resultHandler.handleResult(result);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void removeCancelRequestListener(final CancelRequestListener listener) {
+ Validator.ensureNotNull(listener);
+
+ synchronized (stateLock) {
+ if (cancelRequestListeners != null) {
+ cancelRequestListeners.remove(listener);
+ }
+ }
+ }
+
+ private <R extends ExtendedResult> void cancel(final LocalizableMessage reason,
+ final ExtendedRequest<R> cancelRequest,
+ final ResultHandler<? super R> cancelResultHandler, final boolean sendResult) {
+ Validator.ensureNotNull(reason);
+
+ if (!isCancelSupported) {
+ if (cancelResultHandler != null) {
+ final Result result =
+ Responses.newGenericExtendedResult(ResultCode.CANNOT_CANCEL);
+ cancelResultHandler.handleErrorResult(newErrorResult(result));
+ }
+ return;
+ }
+
+ List<CancelRequestListener> tmpListeners = null;
+ boolean invokeResultHandler = false;
+ boolean resultHandlerIsSuccess = false;
+
+ synchronized (stateLock) {
+ switch (state) {
+ case PENDING:
+ // Switch to CANCEL_REQUESTED state.
+ cancelRequestReason = reason;
+ if (cancelResultHandler != null) {
+ cancelResultHandlers = new LinkedList<ExtendedResultHandlerHolder<?>>();
+ cancelResultHandlers.add(new ExtendedResultHandlerHolder<R>(cancelRequest,
+ cancelResultHandler));
+ }
+ tmpListeners = cancelRequestListeners;
+ cancelRequestListeners = null;
+ state = RequestState.CANCEL_REQUESTED;
+ this.sendResult &= sendResult;
+ break;
+ case CANCEL_REQUESTED:
+ // Cancel already request so listeners already invoked.
+ if (cancelResultHandler != null) {
+ if (cancelResultHandlers == null) {
+ cancelResultHandlers = new LinkedList<ExtendedResultHandlerHolder<?>>();
+ }
+ cancelResultHandlers.add(new ExtendedResultHandlerHolder<R>(cancelRequest,
+ cancelResultHandler));
+ }
+ break;
+ case TOO_LATE:
+ case RESULT_SENT:
+ // Cannot cancel, so invoke result handler immediately
+ // outside of
+ // lock.
+ if (cancelResultHandler != null) {
+ invokeResultHandler = true;
+ resultHandlerIsSuccess = false;
+ }
+ break;
+ case CANCELLED:
+ // Multiple cancellation attempts. Clients should not do
+ // this, but the
+ // cancel will effectively succeed immediately, so invoke
+ // result
+ // handler immediately outside of lock.
+ if (cancelResultHandler != null) {
+ invokeResultHandler = true;
+ resultHandlerIsSuccess = true;
+ }
+ break;
+ }
+ }
+
+ // Invoke listeners outside of lock.
+ if (tmpListeners != null) {
+ for (final CancelRequestListener listener : tmpListeners) {
+ listener.handleCancelRequest(reason);
+ }
+ }
+
+ if (invokeResultHandler) {
+ if (resultHandlerIsSuccess) {
+ final R result =
+ cancelRequest.getResultDecoder().newExtendedErrorResult(
+ ResultCode.SUCCESS, "", "");
+ cancelResultHandler.handleResult(result);
+ } else {
+ final Result result = Responses.newGenericExtendedResult(ResultCode.TOO_LATE);
+ cancelResultHandler.handleErrorResult(ErrorResultException
+ .newErrorResult(result));
+ }
+ }
+ }
+
+ /**
+ * Sets the result associated with this request context and updates the
+ * state accordingly.
+ *
+ * @param result
+ * The result.
+ */
+ private boolean setResult(final Result result) {
+ List<ExtendedResultHandlerHolder<?>> tmpHandlers = null;
+ boolean isCancelled = false;
+ boolean maySendResult;
+
+ synchronized (stateLock) {
+ maySendResult = sendResult;
+
+ switch (state) {
+ case PENDING:
+ case TOO_LATE:
+ // Switch to appropriate final state.
+ if (!result.getResultCode().equals(ResultCode.CANCELLED)) {
+ state = RequestState.RESULT_SENT;
+ } else {
+ state = RequestState.CANCELLED;
+ }
+ break;
+ case CANCEL_REQUESTED:
+ // Switch to appropriate final state and invoke any cancel
+ // request
+ // handlers.
+ if (!result.getResultCode().equals(ResultCode.CANCELLED)) {
+ state = RequestState.RESULT_SENT;
+ } else {
+ state = RequestState.CANCELLED;
+ }
+
+ isCancelled = (state == RequestState.CANCELLED);
+ tmpHandlers = cancelResultHandlers;
+ cancelResultHandlers = null;
+ break;
+ case RESULT_SENT:
+ case CANCELLED:
+ // This should not happen - could throw an illegal state
+ // exception?
+ maySendResult = false; // Prevent sending multiple results.
+ break;
+ }
+ }
+
+ // Invoke handlers outside of lock.
+ if (tmpHandlers != null) {
+ for (final ExtendedResultHandlerHolder<?> handler : tmpHandlers) {
+ if (isCancelled) {
+ handler.handleSuccess();
+ } else {
+ handler.handleTooLate();
+ }
+ }
+ }
+
+ return maySendResult;
+ }
}
+ /**
+ * Search request context implementation.
+ */
+ private final static class SearchRequestContextImpl extends
+ RequestContextImpl<Result, SearchResultHandler> implements SearchResultHandler {
+ private SearchRequestContextImpl(final ServerConnectionImpl<?> clientConnection,
+ final SearchResultHandler resultHandler, final int messageID,
+ final boolean isCancelSupported) {
+ super(clientConnection, resultHandler, messageID, isCancelSupported);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean handleEntry(final SearchResultEntry entry) {
+ return resultHandler.handleEntry(entry);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean handleReference(final SearchResultReference reference) {
+ return resultHandler.handleReference(reference);
+ }
+ }
+
+ private static final class ServerConnectionImpl<C> implements ServerConnection<Integer> {
+ private final RequestHandler<RequestContext> requestHandler;
+ private final AtomicBoolean isClosed = new AtomicBoolean();
+ private final ConcurrentHashMap<Integer, RequestContextImpl<?, ?>> pendingRequests =
+ new ConcurrentHashMap<Integer, RequestContextImpl<?, ?>>();
+
+ private ServerConnectionImpl(final RequestHandler<RequestContext> requestHandler) {
+ this.requestHandler = requestHandler;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleAbandon(final Integer messageID, final AbandonRequest request) {
+ final RequestContextImpl<?, ?> abandonedRequest =
+ getPendingRequest(request.getRequestID());
+ if (abandonedRequest != null) {
+ final LocalizableMessage abandonReason =
+ INFO_CANCELED_BY_ABANDON_REQUEST.get(messageID);
+ abandonedRequest.cancel(abandonReason, null, null, false);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleAdd(final Integer messageID, final AddRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super Result> resultHandler) {
+ final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
+ new RequestContextImpl<Result, ResultHandler<? super Result>>(this,
+ resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleAdd(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleBind(final Integer messageID, final int version,
+ final BindRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super BindResult> resultHandler) {
+ final RequestContextImpl<BindResult, ResultHandler<? super BindResult>> requestContext =
+ new RequestContextImpl<BindResult, ResultHandler<? super BindResult>>(this,
+ resultHandler, messageID, false);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleBind(requestContext, version, request,
+ intermediateResponseHandler, requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleCompare(final Integer messageID, final CompareRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super CompareResult> resultHandler) {
+ final RequestContextImpl<CompareResult, ResultHandler<? super CompareResult>> requestContext =
+ new RequestContextImpl<CompareResult, ResultHandler<? super CompareResult>>(
+ this, resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleCompare(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleConnectionClosed(final Integer messageID, final UnbindRequest request) {
+ final LocalizableMessage cancelReason = INFO_CANCELED_BY_CLIENT_DISCONNECT.get();
+ doClose(cancelReason);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleConnectionDisconnected(final ResultCode resultCode, final String message) {
+ final LocalizableMessage cancelReason = INFO_CANCELED_BY_SERVER_DISCONNECT.get();
+ doClose(cancelReason);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleConnectionError(final Throwable error) {
+ final LocalizableMessage cancelReason = INFO_CANCELED_BY_CLIENT_ERROR.get();
+ doClose(cancelReason);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleDelete(final Integer messageID, final DeleteRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super Result> resultHandler) {
+ final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
+ new RequestContextImpl<Result, ResultHandler<? super Result>>(this,
+ resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleDelete(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public <R extends ExtendedResult> void handleExtendedRequest(final Integer messageID,
+ final ExtendedRequest<R> request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super R> resultHandler) {
+ if (request.getOID().equals(CancelExtendedRequest.OID)) {
+ // Decode the request as a cancel request.
+ CancelExtendedRequest cancelRequest;
+ try {
+ cancelRequest =
+ CancelExtendedRequest.DECODER.decodeExtendedRequest(request,
+ new DecodeOptions());
+ } catch (final DecodeException e) {
+ // Couldn't decode a cancel request.
+ resultHandler.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR, e
+ .getLocalizedMessage()));
+ return;
+ }
+
+ // Register the request in the pending requests table. Even
+ // though
+ // this request cannot be cancelled, it is important to do this
+ // in
+ // order to monitor the number of pending operations.
+ final RequestContextImpl<R, ResultHandler<? super R>> requestContext =
+ new RequestContextImpl<R, ResultHandler<? super R>>(this, resultHandler,
+ messageID, false);
+ if (addPendingRequest(requestContext)) {
+ // Find and cancel the request.
+ final RequestContextImpl<?, ?> cancelledRequest =
+ getPendingRequest(cancelRequest.getRequestID());
+ if (cancelledRequest != null) {
+ final LocalizableMessage cancelReason =
+ INFO_CANCELED_BY_CANCEL_REQUEST.get(messageID);
+ cancelledRequest.cancel(cancelReason, request, requestContext, true);
+ } else {
+ // Couldn't find the request. Invoke on context in order
+ // to remove
+ // pending request.
+ requestContext
+ .handleErrorResult(newErrorResult(ResultCode.NO_SUCH_OPERATION));
+ }
+ }
+ } else {
+ final RequestContextImpl<R, ResultHandler<? super R>> requestContext;
+ if (request.getOID().equals(StartTLSExtendedRequest.OID)) {
+ // StartTLS requests cannot be cancelled.
+ requestContext =
+ new RequestContextImpl<R, ResultHandler<? super R>>(this,
+ resultHandler, messageID, false);
+ } else {
+ requestContext =
+ new RequestContextImpl<R, ResultHandler<? super R>>(this,
+ resultHandler, messageID, true);
+ }
+
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleExtendedRequest(requestContext, request,
+ intermediateResponseHandler, requestContext);
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleModify(final Integer messageID, final ModifyRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super Result> resultHandler) {
+ final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
+ new RequestContextImpl<Result, ResultHandler<? super Result>>(this,
+ resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleModify(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleModifyDN(final Integer messageID, final ModifyDNRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final ResultHandler<? super Result> resultHandler) {
+ final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
+ new RequestContextImpl<Result, ResultHandler<? super Result>>(this,
+ resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleModifyDN(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void handleSearch(final Integer messageID, final SearchRequest request,
+ final IntermediateResponseHandler intermediateResponseHandler,
+ final SearchResultHandler resultHandler) {
+ final SearchRequestContextImpl requestContext =
+ new SearchRequestContextImpl(this, resultHandler, messageID, true);
+ if (addPendingRequest(requestContext)) {
+ requestHandler.handleSearch(requestContext, request, intermediateResponseHandler,
+ requestContext);
+ }
+ }
+
+ private boolean addPendingRequest(final RequestContextImpl<?, ?> requestContext) {
+ final Integer messageID = requestContext.getMessageID();
+
+ if (isClosed.get()) {
+ final LocalizableMessage message = INFO_CLIENT_CONNECTION_CLOSING.get();
+ requestContext.handleErrorResult(newErrorResult(ResultCode.UNWILLING_TO_PERFORM,
+ message.toString()));
+ return false;
+ } else if (pendingRequests.putIfAbsent(messageID, requestContext) != null) {
+ final LocalizableMessage message =
+ WARN_CLIENT_DUPLICATE_MESSAGE_ID.get(requestContext.getMessageID());
+ requestContext.handleErrorResult(newErrorResult(ResultCode.PROTOCOL_ERROR, message
+ .toString()));
+ return false;
+ } else if (isClosed.get()) {
+ // A concurrent close may have already removed the pending
+ // request but
+ // it will have only been notified for cancellation.
+ pendingRequests.remove(messageID);
+
+ final LocalizableMessage message = INFO_CLIENT_CONNECTION_CLOSING.get();
+ requestContext.handleErrorResult(newErrorResult(ResultCode.UNWILLING_TO_PERFORM,
+ message.toString()));
+ return false;
+ } else {
+ // If the connection is closed now then we just have to pay the
+ // cost of
+ // invoking the request in the request handler.
+ return true;
+ }
+ }
+
+ private void doClose(final LocalizableMessage cancelReason) {
+ if (!isClosed.getAndSet(true)) {
+ // At this point if any pending requests are added then we may
+ // end up
+ // cancelling them, but this does not matter since
+ // addPendingRequest
+ // will fail the request immediately.
+ final Iterator<RequestContextImpl<?, ?>> iterator =
+ pendingRequests.values().iterator();
+ while (iterator.hasNext()) {
+ final RequestContextImpl<?, ?> pendingRequest = iterator.next();
+ pendingRequest.cancel(cancelReason, null, null, false);
+ iterator.remove();
+ }
+ }
+ }
+
+ /**
+ * Returns the pending request context having the specified message ID.
+ *
+ * @param messageID
+ * The message ID associated with the request context.
+ * @return The pending request context.
+ */
+ private RequestContextImpl<?, ?> getPendingRequest(final Integer messageID) {
+ return pendingRequests.get(messageID);
+ }
+
+ /**
+ * Deregister a request context once it has completed.
+ *
+ * @param requestContext
+ * The request context.
+ * @return {@code true} if the request context was found and removed.
+ */
+ private boolean removePendingRequest(final RequestContextImpl<?, ?> requestContext) {
+ return pendingRequests.remove(requestContext.getMessageID()) != null;
+ }
+
+ }
+
+ private final RequestHandlerFactory<C, RequestContext> factory;
/**
- * Sets the result associated with this request context and updates the
- * state accordingly.
+ * Creates a new server connection factory using the provided request
+ * handler factory.
*
- * @param result
- * The result.
+ * @param factory
+ * The request handler factory to be adapted into a server
+ * connection factory.
*/
- private boolean setResult(final Result result)
- {
- List<ExtendedResultHandlerHolder<?>> tmpHandlers = null;
- boolean isCancelled = false;
- boolean maySendResult;
-
- synchronized (stateLock)
- {
- maySendResult = sendResult;
-
- switch (state)
- {
- case PENDING:
- case TOO_LATE:
- // Switch to appropriate final state.
- if (!result.getResultCode().equals(ResultCode.CANCELLED))
- {
- state = RequestState.RESULT_SENT;
- }
- else
- {
- state = RequestState.CANCELLED;
- }
- break;
- case CANCEL_REQUESTED:
- // Switch to appropriate final state and invoke any cancel request
- // handlers.
- if (!result.getResultCode().equals(ResultCode.CANCELLED))
- {
- state = RequestState.RESULT_SENT;
- }
- else
- {
- state = RequestState.CANCELLED;
- }
-
- isCancelled = (state == RequestState.CANCELLED);
- tmpHandlers = cancelResultHandlers;
- cancelResultHandlers = null;
- break;
- case RESULT_SENT:
- case CANCELLED:
- // This should not happen - could throw an illegal state exception?
- maySendResult = false; // Prevent sending multiple results.
- break;
- }
- }
-
- // Invoke handlers outside of lock.
- if (tmpHandlers != null)
- {
- for (final ExtendedResultHandlerHolder<?> handler : tmpHandlers)
- {
- if (isCancelled)
- {
- handler.handleSuccess();
- }
- else
- {
- handler.handleTooLate();
- }
- }
- }
-
- return maySendResult;
+ RequestHandlerFactoryAdapter(final RequestHandlerFactory<C, RequestContext> factory) {
+ this.factory = factory;
}
- }
-
-
-
- /**
- * Search request context implementation.
- */
- private final static class SearchRequestContextImpl extends
- RequestContextImpl<Result, SearchResultHandler> implements
- SearchResultHandler
- {
-
- private SearchRequestContextImpl(
- final ServerConnectionImpl<?> clientConnection,
- final SearchResultHandler resultHandler, final int messageID,
- final boolean isCancelSupported)
- {
- super(clientConnection, resultHandler, messageID, isCancelSupported);
- }
-
-
/**
* {@inheritDoc}
*/
@Override
- public boolean handleEntry(final SearchResultEntry entry)
- {
- return resultHandler.handleEntry(entry);
+ public ServerConnection<Integer> handleAccept(final C clientContext)
+ throws ErrorResultException {
+ final RequestHandler<RequestContext> requestHandler = factory.handleAccept(clientContext);
+ return new ServerConnectionImpl<C>(requestHandler);
}
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean handleReference(final SearchResultReference reference)
- {
- return resultHandler.handleReference(reference);
- }
- }
-
-
-
- private static final class ServerConnectionImpl<C> implements
- ServerConnection<Integer>
- {
- private final RequestHandler<RequestContext> requestHandler;
- private final AtomicBoolean isClosed = new AtomicBoolean();
- private final ConcurrentHashMap<Integer, RequestContextImpl<?, ?>> pendingRequests =
- new ConcurrentHashMap<Integer, RequestContextImpl<?, ?>>();
-
-
-
- private ServerConnectionImpl(
- final RequestHandler<RequestContext> requestHandler)
- {
- this.requestHandler = requestHandler;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleAbandon(final Integer messageID,
- final AbandonRequest request)
- {
- final RequestContextImpl<?, ?> abandonedRequest = getPendingRequest(request
- .getRequestID());
- if (abandonedRequest != null)
- {
- final LocalizableMessage abandonReason = INFO_CANCELED_BY_ABANDON_REQUEST
- .get(messageID);
- abandonedRequest.cancel(abandonReason, null, null, false);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleAdd(final Integer messageID, final AddRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super Result> resultHandler)
- {
- final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
- new RequestContextImpl<Result, ResultHandler<? super Result>>(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleAdd(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleBind(final Integer messageID, final int version,
- final BindRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super BindResult> resultHandler)
- {
- final RequestContextImpl<BindResult, ResultHandler<? super BindResult>> requestContext =
- new RequestContextImpl<BindResult, ResultHandler<? super BindResult>>(
- this, resultHandler, messageID, false);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleBind(requestContext, version, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleCompare(final Integer messageID,
- final CompareRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super CompareResult> resultHandler)
- {
- final RequestContextImpl<CompareResult, ResultHandler<? super CompareResult>> requestContext =
- new RequestContextImpl<CompareResult, ResultHandler<? super CompareResult>>(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleCompare(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleConnectionClosed(final Integer messageID,
- final UnbindRequest request)
- {
- final LocalizableMessage cancelReason = INFO_CANCELED_BY_CLIENT_DISCONNECT
- .get();
- doClose(cancelReason);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleConnectionDisconnected(final ResultCode resultCode,
- final String message)
- {
- final LocalizableMessage cancelReason = INFO_CANCELED_BY_SERVER_DISCONNECT
- .get();
- doClose(cancelReason);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleConnectionError(final Throwable error)
- {
- final LocalizableMessage cancelReason = INFO_CANCELED_BY_CLIENT_ERROR
- .get();
- doClose(cancelReason);
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleDelete(final Integer messageID,
- final DeleteRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super Result> resultHandler)
- {
- final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
- new RequestContextImpl<Result, ResultHandler<? super Result>>(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleDelete(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public <R extends ExtendedResult> void handleExtendedRequest(
- final Integer messageID, final ExtendedRequest<R> request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super R> resultHandler)
- {
- if (request.getOID().equals(CancelExtendedRequest.OID))
- {
- // Decode the request as a cancel request.
- CancelExtendedRequest cancelRequest;
- try
- {
- cancelRequest = CancelExtendedRequest.DECODER.decodeExtendedRequest(
- request, new DecodeOptions());
- }
- catch (final DecodeException e)
- {
- // Couldn't decode a cancel request.
- resultHandler.handleErrorResult(newErrorResult(
- ResultCode.PROTOCOL_ERROR, e.getLocalizedMessage()));
- return;
- }
-
- // Register the request in the pending requests table. Even though
- // this request cannot be cancelled, it is important to do this in
- // order to monitor the number of pending operations.
- final RequestContextImpl<R, ResultHandler<? super R>> requestContext =
- new RequestContextImpl<R, ResultHandler<? super R>>(
- this, resultHandler, messageID, false);
- if (addPendingRequest(requestContext))
- {
- // Find and cancel the request.
- final RequestContextImpl<?, ?> cancelledRequest = getPendingRequest(cancelRequest
- .getRequestID());
- if (cancelledRequest != null)
- {
- final LocalizableMessage cancelReason = INFO_CANCELED_BY_CANCEL_REQUEST
- .get(messageID);
- cancelledRequest
- .cancel(cancelReason, request, requestContext, true);
- }
- else
- {
- // Couldn't find the request. Invoke on context in order to remove
- // pending request.
- requestContext
- .handleErrorResult(newErrorResult(ResultCode.NO_SUCH_OPERATION));
- }
- }
- }
- else
- {
- final RequestContextImpl<R, ResultHandler<? super R>> requestContext;
- if (request.getOID().equals(StartTLSExtendedRequest.OID))
- {
- // StartTLS requests cannot be cancelled.
- requestContext = new RequestContextImpl<R, ResultHandler<? super R>>(
- this, resultHandler, messageID, false);
- }
- else
- {
- requestContext = new RequestContextImpl<R, ResultHandler<? super R>>(
- this, resultHandler, messageID, true);
- }
-
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleExtendedRequest(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleModify(final Integer messageID,
- final ModifyRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super Result> resultHandler)
- {
- final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
- new RequestContextImpl<Result, ResultHandler<? super Result>>(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleModify(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleModifyDN(final Integer messageID,
- final ModifyDNRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final ResultHandler<? super Result> resultHandler)
- {
- final RequestContextImpl<Result, ResultHandler<? super Result>> requestContext =
- new RequestContextImpl<Result, ResultHandler<? super Result>>(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleModifyDN(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public void handleSearch(final Integer messageID,
- final SearchRequest request,
- final IntermediateResponseHandler intermediateResponseHandler,
- final SearchResultHandler resultHandler)
- {
- final SearchRequestContextImpl requestContext = new SearchRequestContextImpl(
- this, resultHandler, messageID, true);
- if (addPendingRequest(requestContext))
- {
- requestHandler.handleSearch(requestContext, request,
- intermediateResponseHandler, requestContext);
- }
- }
-
-
-
- private boolean addPendingRequest(
- final RequestContextImpl<?, ?> requestContext)
- {
- final Integer messageID = requestContext.getMessageID();
-
- if (isClosed.get())
- {
- final LocalizableMessage message = INFO_CLIENT_CONNECTION_CLOSING.get();
- requestContext.handleErrorResult(newErrorResult(
- ResultCode.UNWILLING_TO_PERFORM, message.toString()));
- return false;
- }
- else if (pendingRequests.putIfAbsent(messageID, requestContext) != null)
- {
- final LocalizableMessage message = WARN_CLIENT_DUPLICATE_MESSAGE_ID
- .get(requestContext.getMessageID());
- requestContext.handleErrorResult(newErrorResult(
- ResultCode.PROTOCOL_ERROR, message.toString()));
- return false;
- }
- else if (isClosed.get())
- {
- // A concurrent close may have already removed the pending request but
- // it will have only been notified for cancellation.
- pendingRequests.remove(messageID);
-
- final LocalizableMessage message = INFO_CLIENT_CONNECTION_CLOSING.get();
- requestContext.handleErrorResult(newErrorResult(
- ResultCode.UNWILLING_TO_PERFORM, message.toString()));
- return false;
- }
- else
- {
- // If the connection is closed now then we just have to pay the cost of
- // invoking the request in the request handler.
- return true;
- }
- }
-
-
-
- private void doClose(final LocalizableMessage cancelReason)
- {
- if (!isClosed.getAndSet(true))
- {
- // At this point if any pending requests are added then we may end up
- // cancelling them, but this does not matter since addPendingRequest
- // will fail the request immediately.
- final Iterator<RequestContextImpl<?, ?>> iterator = pendingRequests
- .values().iterator();
- while (iterator.hasNext())
- {
- final RequestContextImpl<?, ?> pendingRequest = iterator.next();
- pendingRequest.cancel(cancelReason, null, null, false);
- iterator.remove();
- }
- }
- }
-
-
-
- /**
- * Returns the pending request context having the specified message ID.
- *
- * @param messageID
- * The message ID associated with the request context.
- * @return The pending request context.
- */
- private RequestContextImpl<?, ?> getPendingRequest(final Integer messageID)
- {
- return pendingRequests.get(messageID);
- }
-
-
-
- /**
- * Deregister a request context once it has completed.
- *
- * @param requestContext
- * The request context.
- * @return {@code true} if the request context was found and removed.
- */
- private boolean removePendingRequest(
- final RequestContextImpl<?, ?> requestContext)
- {
- return pendingRequests.remove(requestContext.getMessageID()) != null;
- }
-
- }
-
-
-
- private final RequestHandlerFactory<C, RequestContext> factory;
-
-
-
- /**
- * Creates a new server connection factory using the provided request handler
- * factory.
- *
- * @param factory
- * The request handler factory to be adapted into a server connection
- * factory.
- */
- RequestHandlerFactoryAdapter(
- final RequestHandlerFactory<C, RequestContext> factory)
- {
- this.factory = factory;
- }
-
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public ServerConnection<Integer> handleAccept(final C clientContext)
- throws ErrorResultException
- {
- final RequestHandler<RequestContext> requestHandler = factory
- .handleAccept(clientContext);
- return new ServerConnectionImpl<C>(requestHandler);
- }
-
}
--
Gitblit v1.10.0