public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) { Debug.Assert(_outAsync == outAsync); if (_retryQueue.cancel(this)) { if (_instance.traceLevels().retry >= 1) { _instance.initializationData().logger.trace(_instance.traceLevels().retryCat, string.Format("operation retry canceled\n{0}", ex)); } if (_outAsync.exception(ex)) { _outAsync.invokeExceptionAsync(); } } }
private bool sentAsync(OutgoingAsyncBase outAsync) { lock (this) { if (!_sendAsyncRequests.Remove(outAsync)) { return(false); // The request timed-out. } } Ice.AsyncCallback cb = outAsync.sent(); if (cb != null) { outAsync.invokeSent(cb); } return(true); }
private bool sentAsync(OutgoingAsyncBase outAsync) { lock (this) { if (!_sendAsyncRequests.Remove(outAsync)) { return(false); // The request timed-out. } if (!outAsync.sent()) { return(true); } } outAsync.invokeSent(); return(true); }
public bool handleException(Ice.Exception ex, OutgoingAsyncBase og) { // // If this is a synchronous call, we can notify the task from this thread to avoid // the thread context switch. We know there aren't any continuations setup with the // task. // if (og.isSynchronous()) { handleInvokeException(ex, og); return(false); } else { return(true); } }
public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) { Debug.Assert(_outAsync == outAsync); if (_retryQueue.cancel(this)) { if (_instance.traceLevels().retry >= 1) { string s = "operation retry canceled\n" + ex; _instance.initializationData().logger.trace(_instance.traceLevels().retryCat, s); } Ice.AsyncCallback cb = _outAsync.completed(ex); if (cb != null) { _outAsync.invokeCompletedAsync(cb); } } }
public bool handleResponse(bool userThread, bool ok, OutgoingAsyncBase og) { // // If this is a synchronous call, we can notify the task from this thread to avoid the // thread context switch. We know there aren't any continuations setup with the // task. // if (userThread || og.isSynchronous()) { handleInvokeResponse(ok, og); return(false); } else { return(true); } }
public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) { lock (this) { int requestId; if (_sendAsyncRequests.TryGetValue(outAsync, out requestId)) { if (requestId > 0) { _asyncRequests.Remove(requestId); } _sendAsyncRequests.Remove(outAsync); Ice.AsyncCallback cb = outAsync.completed(ex); if (cb != null) { outAsync.invokeCompletedAsync(cb); } _adapter.decDirectCount(); // invokeAll won't be called, decrease the direct count. return; } if (outAsync is OutgoingAsync) { OutgoingAsync o = (OutgoingAsync)outAsync; Debug.Assert(o != null); foreach (KeyValuePair <int, OutgoingAsyncBase> e in _asyncRequests) { if (e.Value == o) { _asyncRequests.Remove(e.Key); Ice.AsyncCallback cb = outAsync.completed(ex); if (cb != null) { outAsync.invokeCompletedAsync(cb); } return; } } } } }
public void AsyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) { lock (this) { if (_sendAsyncRequests.TryGetValue(outAsync, out int requestId)) { if (requestId > 0) { _asyncRequests.Remove(requestId); } _sendAsyncRequests.Remove(outAsync); if (outAsync.Exception(ex)) { outAsync.InvokeExceptionAsync(); } _adapter.DecDirectCount(); // invokeAll won't be called, decrease the direct count. return; } if (outAsync is OutgoingAsync o) { Debug.Assert(o != null); foreach (KeyValuePair <int, OutgoingAsyncBase> e in _asyncRequests) { if (e.Value == o) { _asyncRequests.Remove(e.Key); if (outAsync.Exception(ex)) { outAsync.InvokeExceptionAsync(); } return; } } } } }
public int invokeAsyncRequest(OutgoingAsyncBase outAsync, int batchRequestNum, bool synchronous) { // // Increase the direct count to prevent the thread pool from being destroyed before // invokeAll is called. This will also throw if the object adapter has been deactivated. // _adapter.incDirectCount(); int requestId = 0; try { lock (this) { outAsync.cancelable(this); // This will throw if the request is canceled if (_response) { requestId = ++_requestId; _asyncRequests.Add(requestId, outAsync); } _sendAsyncRequests.Add(outAsync, requestId); } } catch (Exception) { _adapter.decDirectCount(); throw; } outAsync.attachCollocatedObserver(_adapter, requestId); if (!synchronous || !_response || _reference.getInvocationTimeout() > 0) { // Don't invoke from the user thread if async or invocation timeout is set _adapter.getThreadPool().dispatch( () => { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); } else if (_dispatcher) { _adapter.getThreadPool().dispatchFromThisThread( () => { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); } else // Optimization: directly call invokeAll if there's no dispatcher. { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } } return(OutgoingAsyncBase.AsyncStatusQueued); }
public override void handleInvokeResponse(bool ok, OutgoingAsyncBase og) { SetResult(((OutgoingAsyncT <T>)og).getResult(ok)); }
public abstract void handleInvokeResponse(bool ok, OutgoingAsyncBase og);
public void handleInvokeException(Ice.Exception ex, OutgoingAsyncBase og) { SetException(ex); }
public virtual void handleInvokeSent(bool sentSynchronously, bool done, bool alreadySent, OutgoingAsyncBase og) { if (progress_ != null && !alreadySent) { progress_.Report(sentSynchronously); } if (done) { SetResult(default(T)); } }
public bool invokeAsyncRequest(OutgoingAsyncBase outAsync, int batchRequestNum, bool synchronous, out Ice.AsyncCallback sentCallback) { // // Increase the direct count to prevent the thread pool from being destroyed before // invokeAll is called. This will also throw if the object adapter has been deactivated. // _adapter.incDirectCount(); int requestId = 0; try { lock (this) { outAsync.cancelable(this); // This will throw if the request is canceled if (_response) { requestId = ++_requestId; _asyncRequests.Add(requestId, outAsync); } _sendAsyncRequests.Add(outAsync, requestId); } } catch (System.Exception ex) { _adapter.decDirectCount(); throw ex; } outAsync.attachCollocatedObserver(_adapter, requestId); if (synchronous) { // // Treat this collocated call as if it is a synchronous invocation. // if (_reference.getInvocationTimeout() > 0 || !_response) { // Don't invoke from the user thread, invocation timeouts wouldn't work otherwise. _adapter.getThreadPool().dispatch(() => { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); } else if (_dispatcher) { _adapter.getThreadPool().dispatchFromThisThread(() => { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); } else // Optimization: directly call invokeAll if there's no dispatcher. { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } } sentCallback = null; } else { _adapter.getThreadPool().dispatch(() => { if (sentAsync(outAsync)) { invokeAll(outAsync.getOs(), requestId, batchRequestNum); } }, null); sentCallback = null; } return(false); }
public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex) { _connection.asyncRequestCanceled(outAsync, ex); }
internal void canceled() { Debug.Assert(outAsync != null); // Only requests can timeout. outAsync = null; }
internal OutgoingMessage(IceInternal.OutgoingAsyncBase outAsync, OutputStream stream, bool compress, int requestId) { this.outAsync = outAsync; this.stream = stream; this.compress = compress; this.requestId = requestId; }