public static void OnEndSend(IPeerNeighbor neighbor, FloodAsyncResult fresult) { if (neighbor.State < PeerNeighborState.Disconnecting) { UtilityExtension utility = neighbor.Utility; if (utility != null) { utility.OnEndSend(fresult); } } }
public static void OnEndSend(IPeerNeighbor neighbor, FloodAsyncResult fresult) { if (neighbor.State >= PeerNeighborState.Disconnecting) { return; } UtilityExtension instance = neighbor.Utility; if (instance == null) { return; } instance.OnEndSend(fresult); }
protected IAsyncResult BeginSendHelper(IPeerNeighbor neighbor, TimeSpan timeout, Message message, FloodAsyncResult fresult) { IAsyncResult result = null; IAsyncResult result2; bool flag = false; try { UtilityExtension.OnMessageSent(neighbor); result = neighbor.BeginSend(message, timeout, Fx.ThunkCallback(new AsyncCallback(fresult.OnSendComplete)), message); fresult.AddResult(result, neighbor); if (result.CompletedSynchronously) { neighbor.EndSend(result); UtilityExtension.OnEndSend(neighbor, fresult); } result2 = result; } catch (Exception exception) { if (Fx.IsFatal(exception)) { flag = true; throw; } if (PeerFlooderBase <TFloodContract, TLinkContract> .CloseNeighborIfKnownException(this.neighborManager, exception, neighbor) != null) { fresult.MarkEnd(false); throw; } System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); result2 = null; } finally { if (((result == null) || result.CompletedSynchronously) && !flag) { message.Close(); } } return(result2); }
protected IAsyncResult BeginSendHelper(IPeerNeighbor neighbor, TimeSpan timeout, Message message, FloodAsyncResult fresult) { IAsyncResult result = null; bool fatal = false; try { UtilityExtension.OnMessageSent(neighbor); result = neighbor.BeginSend(message, timeout, Fx.ThunkCallback(new AsyncCallback(fresult.OnSendComplete)), message); fresult.AddResult(result, neighbor); if (result.CompletedSynchronously) { neighbor.EndSend(result); UtilityExtension.OnEndSend(neighbor, fresult); } return(result); } catch (Exception e) { if (Fx.IsFatal(e)) { fatal = true; throw; } if (null != CloseNeighborIfKnownException(neighborManager, e, neighbor)) { fresult.MarkEnd(false); throw; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); return(null); } finally { if ((result == null || result.CompletedSynchronously) && !fatal) { message.Close(); } } }
//this is the callback routine for async completion on channel BeginSend() operations. //if we are done, simply return. This can happen if user called sync EndX. //if the flooder is still processing BeginSend(), then we probably cant complete. In this case, add the result to pending and return //main thread will flush the pending completions in MarkEnd(). //otherwise, call EndX on the result and remove it from results. //if this is the last invoke, signal user using base.Complete AND isCompleted=true internal void OnSendComplete(IAsyncResult result) { bool callComplete = false; IPeerNeighbor neighbor = null; bool fatal = false; if (isCompleted) { return; } Message message = (Message)result.AsyncState; //wait until flooder had a chance to call all outgoing channels and give us Async results. lock (ThisLock) { if (isCompleted) { return; } if (!this.results.TryGetValue(result, out neighbor)) { if (!doneAdding) { this.pending.Add(result); } else { throw Fx.AssertAndThrow("IAsyncResult is un-accounted for."); } return; } this.results.Remove(result); try { //try doing this only if the async result is marked !CompletedSynchronously. if (!result.CompletedSynchronously) { neighbor.EndSend(result); offNode = true; UtilityExtension.OnEndSend(neighbor, this); } } catch (Exception e) { if (Fx.IsFatal(e)) { fatal = true; throw; } Exception temp = PeerFlooder.CloseNeighborIfKnownException(pnm, e, neighbor); //we want to return the very first exception to the user. if (temp != null && this.doneAdding && !this.shouldCallComplete) { throw; } if (this.exception == null) { this.exception = temp; } DiagnosticUtility.TraceHandledException(e, TraceEventType.Information); } finally { if (message != null && !result.CompletedSynchronously && !fatal) { message.Close(); } } //dont want to call Complete from the lock. //we just decide if this thread should call complete and call outside the lock. if (this.results.Count == 0 && this.doneAdding && this.shouldCallComplete) { this.isCompleted = true; callComplete = true; } } //if we are done with callbacks and beginx calls, if (callComplete && this.shouldCallComplete) { CompleteOp(false); } }
internal void OnSendComplete(IAsyncResult result) { bool flag = false; IPeerNeighbor neighbor = null; bool flag2 = false; if (!this.isCompleted) { Message asyncState = (Message)result.AsyncState; lock (this.ThisLock) { if (this.isCompleted) { return; } if (!this.results.TryGetValue(result, out neighbor)) { if (this.doneAdding) { throw Fx.AssertAndThrow("IAsyncResult is un-accounted for."); } this.pending.Add(result); return; } this.results.Remove(result); try { if (!result.CompletedSynchronously) { neighbor.EndSend(result); this.offNode = true; UtilityExtension.OnEndSend(neighbor, this); } } catch (Exception exception) { if (Fx.IsFatal(exception)) { flag2 = true; throw; } Exception exception2 = PeerFlooderBase <Message, UtilityInfo> .CloseNeighborIfKnownException(this.pnm, exception, neighbor); if (((exception2 != null) && this.doneAdding) && !this.shouldCallComplete) { throw; } if (this.exception == null) { this.exception = exception2; } DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } finally { if (((asyncState != null) && !result.CompletedSynchronously) && !flag2) { asyncState.Close(); } } if (((this.results.Count == 0) && this.doneAdding) && this.shouldCallComplete) { this.isCompleted = true; flag = true; } } if (flag && this.shouldCallComplete) { this.CompleteOp(false); } } }