private void Print(ConcurrentQueue <IoEvent> queue, IoEvent ioe) { StringBuilder sb = new StringBuilder(); sb.Append("Adding event ") .Append(ioe.EventType) .Append(" to session ") .Append(ioe.Session.Id); Boolean first = true; sb.Append("\nQueue : ["); foreach (IoEvent elem in queue) { if (first) { first = false; } else { sb.Append(", "); } sb.Append(((IoEvent)elem).EventType).Append(", "); } sb.Append("]\n"); log.Debug(sb.ToString()); }
private void PushEvent(IoEvent e, Boolean flushNow) { _eventQueue.Enqueue(e); if (flushNow) { FlushEvents(); } }
void IIoHandler.OnIoEvent(IoEvent ioEvent, long queueSize) { if (!this.IsClosing()) { AmqpTrace.Provider.AmqpIoEvent(this, (int)ioEvent, queueSize); this.HandleIoEvent(ioEvent); } }
internal void OnIoEvent(IoEvent ioEvent) { IEnumerator <AmqpLink> it = this.linksByLocalHandle.GetSafeEnumerator(); while (it.MoveNext()) { it.Current.OnIoEvent(ioEvent); } }
protected override void HandleIoEvent(IoEvent ioEvent) { IEnumerator <AmqpSession> it = this.sessionsByLocalHandle.GetSafeEnumerator(); while (it.MoveNext()) { it.Current.OnIoEvent(ioEvent); } }
private Int32 EstimateSize(IoEvent ioe) { Int32 size = _sizeEstimator.EstimateSize(ioe); if (size < 0) { throw new InvalidOperationException(_sizeEstimator.GetType().Name + " returned " + "a negative value (" + size + "): " + ioe); } return(size); }
internal virtual void OnIoEvent(IoEvent ioEvent) { EventHandler temp = this.PropertyReceived; if (temp != null) { AmqpTrace.Provider.AmqpIoEvent(this, (int)ioEvent, (long)this.linkCredit); Fields properties = new Fields(); properties.Add(AmqpConstants.IoEvent, (int)ioEvent); temp(properties, EventArgs.Empty); } }
/// <inheritdoc/> public void Polled(Object source, IoEvent ioe) { Int32 eventSize = EstimateSize(ioe); Int32 currentCounter = Interlocked.Add(ref _counter, -eventSize); if (log.IsDebugEnabled) { log.Debug(Thread.CurrentThread.Name + " state: " + _counter + " / " + _threshold); } if (currentCounter < _threshold) { Unblock(); } }
/// <inheritdoc/> public void Execute(IoEvent ioe) { Boolean offeredEvent = _queueHandler.Accept(this, ioe); if (offeredEvent) { Execute(() => { _queueHandler.Polled(this, ioe); ioe.Fire(); }); _queueHandler.Offered(this, ioe); } }
/// <inheritdoc/> public override void FilterWrite(INextFilter nextFilter, IoSession session, IWriteRequest writeRequest) { IoEvent ioe = new IoEvent(IoEventType.Write, session, writeRequest); if (_queueHandler.Accept(this, ioe)) { nextFilter.FilterWrite(session, writeRequest); IWriteFuture writeFuture = writeRequest.Future; if (writeFuture == null) { return; } // We can track the write request only when it has a future. _queueHandler.Offered(this, ioe); writeFuture.Complete += (s, e) => _queueHandler.Polled(this, ioe); } }
/// <inheritdoc/> public void Execute(IoEvent ioe) { IoSession session = ioe.Session; SessionTasksQueue sessionTasksQueue = GetSessionTasksQueue(session); Boolean exec; // propose the new event to the event queue handler. If we // use a throttle queue handler, the message may be rejected // if the maximum size has been reached. Boolean offerEvent = _queueHandler.Accept(this, ioe); if (offerEvent) { lock (sessionTasksQueue.syncRoot) { sessionTasksQueue.tasksQueue.Enqueue(ioe); if (sessionTasksQueue.processingCompleted) { sessionTasksQueue.processingCompleted = false; exec = true; } else { exec = false; } if (log.IsDebugEnabled) { Print(sessionTasksQueue.tasksQueue, ioe); } } if (exec) { Execute(() => { RunTasks(sessionTasksQueue); }); } _queueHandler.Offered(this, ioe); } }
protected virtual void HandleIoEvent(IoEvent ioEvent) { }
void IIoHandler.OnIoEvent(IoEvent ioEvent, long queueSize) { }
public Int32 EstimateSize(IoEvent ioe) { return(EstimateSize((Object)ioe) + EstimateSize(ioe.Parameter)); }
/// <summary> /// Called when an IoEvent occurrs. /// </summary> /// <param name="source">The object that sends the event.</param> /// <param name="ioEvent">The event.</param> /// <param name="queueSize">The size that the source maintains for such events.</param> public virtual void AmqpIoEvent(AmqpObject source, IoEvent ioEvent, long queueSize) { }
public void Offered(Object source, IoEvent ioe) { // NOOP }
public void Polled(Object source, IoEvent ioe) { // NOOP }
internal void OnIoEvent(IoEvent ioEvent) { IEnumerator<AmqpLink> it = this.linksByLocalHandle.GetSafeEnumerator(); while (it.MoveNext()) { it.Current.OnIoEvent(ioEvent); } }
/// <inheritdoc/> public Boolean Accept(Object source, IoEvent ioe) { return(true); }
private void PushEvent(IoEvent e) { PushEvent(e, _flushEnabled); }
private void FireEvent(IoEvent e) { LoopbackSession session = (LoopbackSession)Session; Object data = e.Parameter; switch (e.EventType) { case IoEventType.MessageReceived: if (sessionOpened && (!session.ReadSuspended) && Monitor.TryEnter(session.Lock)) { try { if (session.ReadSuspended) { session.ReceivedMessageQueue.Enqueue(data); } else { base.FireMessageReceived(data); } } finally { Monitor.Exit(session.Lock); } } else { session.ReceivedMessageQueue.Enqueue(data); } break; case IoEventType.Write: base.FireFilterWrite((IWriteRequest)data); break; case IoEventType.MessageSent: base.FireMessageSent((IWriteRequest)data); break; case IoEventType.ExceptionCaught: base.FireExceptionCaught((Exception)data); break; case IoEventType.SessionCreated: Monitor.Enter(session.Lock); try { base.FireSessionCreated(); } finally { Monitor.Exit(session.Lock); } break; case IoEventType.SessionOpened: base.FireSessionOpened(); sessionOpened = true; break; case IoEventType.SessionIdle: base.FireSessionIdle((IdleStatus)data); break; case IoEventType.SessionClosed: FlushPendingDataQueues(session); base.FireSessionClosed(); break; case IoEventType.Close: base.FireFilterClose(); break; default: break; } }
protected override void HandleIoEvent(IoEvent ioEvent) { IEnumerator<AmqpSession> it = this.sessionsByLocalHandle.GetSafeEnumerator(); while (it.MoveNext()) { it.Current.OnIoEvent(ioEvent); } }