...
- The Ice run time reads the incoming request using a thread from its server thread pool (or object adapter thread pool if one is configured, or client thread pool for requests over bidir connections).
- If a dispatcher is configured, the Ice run time gives the request to the dispatcher to allow the dispatcher to execute this request in a different thread.
- The Ice run time locates the target servant (this may call
locate on a servant locator). - Assuming the target servant is a dispatch interceptor, it calls
ice_dispatch on the next servant (which could be another dispatch interceptor); eventually a dispatch interceptor calls ice_dispatch on the real servant. - The real servant unmarshals the input parameters, executes the operation and then:
- marshals the return and out parameters,
- throws an exception,
- or does not complete synchronously (if it's implemented using AMD).
- The dispatch interceptor(s) now have the opportunity to execute code "on the way out", after completion of the dispatch by the real servant (with AMD, only the synchronous part of this dispatch has completed).
- For a synchronous dispatch through a servant locator, the Ice run time calls
finished on the servant locator. - For a synchronous dispatch, the Ice run time sends the reply to the client: the return and out parameters previously marshaled by the real servant, or an exception caught and marshaled by the Ice run time.
...
Note that Request, for performance reasons, is not thread-safe. This means that you must not concurrently dispatch from different threads using the same Request object. (Concurrent dispatch for different requests does not cause any problems.). We also recommend that you do not change thread in your dispatch interceptor as this would defeat the dispatcher mechanism.
| Localtab Group |
|---|
| Localtab |
|---|
| | Code Block |
|---|
| namespace Ice
{
class DispatchInterceptor : public virtual Object
{
public:
virtual bool dispatch(Request&) = 0;
};
} |
The dispatch return value is a bool that indicates whether dispatch was executed synchronously (true) or asynchronously with AMD (false). You must return the value returned by the servant ice_dispatch function, or throw an exception. |
| Localtab |
|---|
| | Code Block |
|---|
| namespace Ice
{
class DispatchInterceptor : public virtual Object
{
public:
virtual bool dispatch(Request&) = 0;
};
typedef IceInternal::Handle<DispatchInterceptor> DispatchInterceptorPtr;
}
|
The dispatch return value is a bool that indicates whether dispatch was executed synchronously (true) or asynchronously with AMD (false). You must return the value returned by the servant ice_dispatch function, or throw an exception. |
| Localtab |
|---|
| | Code Block |
|---|
| namespace Ice
{
public abstract class DispatchInterceptor : Ice.ObjectImpl
{
public abstract System.Threading.Tasks.Task<Ice.OutputStream> dispatch(Request request);
}
} |
The dispatch return value is a Task instance if the request was dispatched asynchronously with AMD, or null if the request was dispatched synchronously. You must return the same value as returned by the servant ice_dispatch method, or a continuation created from the returned Task, or throw an exception. You can check for the completion of the Task and retry a dispatch if for example the task completed with an exception. It is fine to abandon a returned Task to retry a dispatch. | Info |
|---|
If the servant implementation uses the async keyword for the dispatch of a request, ice_dispatch always returns a Task object even if the dispatch completed synchronously with a response or exception. |
|
| Localtab |
|---|
| | Code Block |
|---|
| package com.zeroc.Ice;
import java.util.concurrent.CompletionStage;
public abstract class DispatchInterceptor implements com.zeroc.Ice.Object
{
public abstract CompletionStage<OutputStream> dispatch(Request request) throws UserException;
...
} |
The dispatch return value is a CompletionStage<OutputStream> if the request was dispatched asynchronously with AMD, or null if the request was dispatched synchronously. You must return the value returned by the servant ice_dispatch method, or a dependent ContinuationStage, or throw an exception. You can check for the completion of the CompletionStage and retry a dispatch if for example the request completed with an exception. It is fine to abandon a returned CompletionStage to retry a dispatch. |
| Localtab |
|---|
| | Code Block |
|---|
| package Ice;
public abstract class DispatchInterceptor extends ObjectImpl
{
public abstract boolean dispatch(Request request) throws Ice.UserException;
} |
The dispatch return value is a boolean that indicates whether dispatch was executed synchronously (true) or asynchronously with AMD (false). You must return the value returned by the servant ice_dispatch function or throw an exception. |
| Localtab |
|---|
| | Code Block |
|---|
| @protocol ICEDispatchInterceptor <ICEObject>
-(void) dispatch:(id<ICERequest>)request;
@end |
The Objective-C mapping does not support asynchronous dispatch (AMD), therefore the return type of the dispatch method is void. |
|
...