internal void AfterReply(ref MessageRpc rpc) { if (rpc.Operation.IsTerminating && rpc.Channel.HasSession) { IOThreadTimer timer = new IOThreadTimer(new Action<object>(TerminatingOperationBehavior.AbortChannel), rpc.Channel.Binder.Channel, false); timer.Set(rpc.Channel.CloseTimeout); } }
private bool AddTimer(IPeerNeighbor neighbor) { bool flag = false; lock (this.ThisLock) { if ((this.state == State.Opened) && (neighbor.State == PeerNeighborState.Connecting)) { IOThreadTimer timer = new IOThreadTimer(new Action<object>(this.OnConnectTimeout), neighbor, true); timer.Set(this.config.ConnectTimeout); this.timerTable.Add(neighbor, timer); flag = true; } } return flag; }
private List<InstancePersistenceEvent> StartWaiting(WaitForEventsAsyncResult result, IOThreadTimer timeoutTimer, TimeSpan timeout) { lock (this.ThisLock) { if (this.waitResult != null) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.WaitAlreadyInProgress)); } if (!this.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if ((this.boundOwnerEvents != null) && (this.boundOwnerEvents.Count > 0)) { List<InstancePersistenceEvent> list = this.Store.SelectSignaledEvents(this.boundOwnerEvents, this.Owner); if (list != null) { return list; } } this.waitResult = result; if (timeoutTimer != null) { timeoutTimer.Set(timeout); } return null; } }
void WriteStreamedMessage(TimeSpan timeout) { this.outputStream = GetWrappedOutputStream(); // Since HTTP streams don't support timeouts, we can't just use TimeoutStream here. // Rather, we need to run a timer to bound the overall operation if (onStreamSendTimeout == null) { onStreamSendTimeout = new Action<object>(OnStreamSendTimeout); } IOThreadTimer sendTimer = new IOThreadTimer(onStreamSendTimeout, this, true); sendTimer.Set(timeout); try { MtomMessageEncoder mtomMessageEncoder = messageEncoder as MtomMessageEncoder; if (mtomMessageEncoder == null) { messageEncoder.WriteMessage(this.message, this.outputStream); } else { mtomMessageEncoder.WriteMessage(this.message, this.outputStream, this.mtomBoundary); } } finally { sendTimer.Cancel(); } }
void SetTimer(IOThreadTimer timer, TimeSpan ts) { Fx.Assert(timer != null && ts >= TimeSpan.Zero, String.Empty); // It is ok to dirty read the state, the consistency will be ensured by persis/unload itself. if (this.instance.state == State.Suspended) { // Unload/Persist immediately when suspended timer.Set(TimeSpan.Zero); } else { timer.Set(ts); } }
bool EnqueueRetry() { bool result = false; int delay = this.GetRetryDelay(); if (this.timeoutHelper.RemainingTime().TotalMilliseconds > delay) { this.sqlCommand.Dispose(); IOThreadTimer iott = new IOThreadTimer(StartCommandCallback, new SqlCommandAsyncResult(CloneSqlCommand(this.sqlCommand), this.connectionString, this.eventTraceActivity, this.dependentTransaction, this.timeoutHelper.RemainingTime(), this.retryCount, this.maximumRetries, this.PrepareAsyncCompletion(onRetryCommandCallback), this), false); iott.Set(delay); if (TD.QueuingSqlRetryIsEnabled()) { TD.QueuingSqlRetry(this.eventTraceActivity, delay.ToString(CultureInfo.InvariantCulture)); } result = true; } return result; }
// Add a timer for the specified neighbor to the timer table. The timer is only added // if Connector is open and the neighbor is in Connecting state. bool AddTimer(IPeerNeighbor neighbor) { bool added = false; lock (ThisLock) { if (state == State.Opened && neighbor.State == PeerNeighborState.Connecting) { IOThreadTimer timer = new IOThreadTimer(new Action<object>(OnConnectTimeout), neighbor, true); timer.Set(this.config.ConnectTimeout); this.timerTable.Add(neighbor, timer); added = true; } } return added; }
public virtual void Open() { ThrowIfOpened("Open"); if (this.refreshInterval <= TimeSpan.Zero) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("RefreshInterval", SR.GetString(SR.RefreshIntervalMustBeGreaterThanZero, this.refreshInterval)); if (this.CleanupInterval <= TimeSpan.Zero) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("CleanupInterval", SR.GetString(SR.CleanupIntervalMustBeGreaterThanZero, this.cleanupInterval)); //check that we are good to open timer = new IOThreadTimer(new Action<object>(CleanupActivity), null, false); timer.Set(CleanupInterval); opened = true; }
private void WriteStreamedMessage(TimeSpan timeout) { this.outputStream = this.supportsConcurrentIO ? ((Stream) new BufferedOutputAsyncStream(this.outputStream, 0x4000, 4)) : ((Stream) new BufferedStream(this.outputStream, 0x8000)); if (onStreamSendTimeout == null) { onStreamSendTimeout = new Action<object>(HttpOutput.OnStreamSendTimeout); } IOThreadTimer timer = new IOThreadTimer(onStreamSendTimeout, this, true); timer.Set(timeout); try { MtomMessageEncoder messageEncoder = this.messageEncoder as MtomMessageEncoder; if (messageEncoder == null) { this.messageEncoder.WriteMessage(this.message, this.outputStream); } else { messageEncoder.WriteMessage(this.message, this.outputStream, this.mtomBoundary); } } finally { timer.Cancel(); } }