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);
}
}
void IIoHandler.OnIoEvent(IoEvent ioEvent, long queueSize)
{
if (!this.IsClosing())
{
AmqpTrace.Provider.AmqpIoEvent(this, (int)ioEvent, queueSize);
this.HandleIoEvent(ioEvent);
}
}
void IIoHandler.OnIoEvent(IoEvent ioEvent, long queueSize)
{
}
/// <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);
}
}
protected virtual void HandleIoEvent(IoEvent ioEvent)
{
}
