IAsyncResult BeginReceiveMessages(int messageCount, TimeSpan batchWaitTimeout, TimeSpan timeout, AsyncCallback callback, object state) { this.ThrowIfClosed(); List <AmqpMessage> messages = new List <AmqpMessage>(); lock (this.SyncRoot) { if (this.messageQueue != null && this.messageQueue.Count > 0) { for (int i = 0; i < messageCount && this.messageQueue.Count > 0; i++) { messages.Add(this.messageQueue.Dequeue()); } } } if (!messages.Any() && timeout > TimeSpan.Zero) { ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, messageCount, batchWaitTimeout, timeout, callback, state); bool completeWaiter = true; lock (this.SyncRoot) { if (this.messageQueue == null) { // closed, so return null message immediately } else if (this.messageQueue.Count > 0) { for (int i = 0; i < messageCount && this.messageQueue.Count > 0; i++) { messages.Add(this.messageQueue.Dequeue()); } } else { LinkedListNode <ReceiveAsyncResult> node = this.waiterList.AddLast(waiter); waiter.Initialize(node); completeWaiter = false; // If no auto-flow, trigger a flow to get messages. int creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit(); if (creditToIssue > 0) { // Before the credit is issued, waiters could be completed already. In this case, we will queue the incoming // messages and wait for the next receive calls. this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary); } } } if (completeWaiter) { waiter.Signal(messages, true); } return(waiter); } return(new CompletedAsyncResult <IEnumerable <AmqpMessage> >(messages, callback, state)); }
public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state) { ReceiveAsyncResult <TChannel> result = new ReceiveAsyncResult <TChannel>(this, timeout, callback, state); result.Begin(); return(result); }
public static bool End(IAsyncResult result, out IEnumerable <AmqpMessage> messages) { ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result); messages = thisPtr.messages; return(thisPtr.completed == 1); }
void OnReceiveMessage(AmqpMessage message) { if (this.messageListener != null) { this.messageListener(message); } else { ReceiveAsyncResult waiter = null; lock (this.syncRoot) { if (this.waiterList != null && this.waiterList.Count > 0) { waiter = this.waiterList.First.Value; this.waiterList.RemoveFirst(); waiter.OnRemoved(); } else if (this.messageQueue != null) { this.messageQueue.Enqueue(message); } } if (waiter != null) { waiter.Signal(message, false); } } this.minTimeout = TimeSpan.Zero; }
void OnReceiveMessage(AmqpMessage message) { if (this.messageListener != null) { this.messageListener(message); } else { ReceiveAsyncResult waiter = null; int creditToIssue = 0; bool releaseMessage = false; lock (this.SyncRoot) { if (this.waiterList != null && this.waiterList.Count > 0) { waiter = this.waiterList.First.Value; this.waiterList.RemoveFirst(); waiter.OnRemoved(); creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit(); } else if (!this.Settings.AutoSendFlow && this.Settings.SettleType != SettleMode.SettleOnSend) { releaseMessage = true; } else if (this.messageQueue != null) { this.messageQueue.Enqueue(message); AmqpTrace.Provider.AmqpCacheMessage( this, message.DeliveryId.Value, this.messageQueue.Count, this.messageQueue.IsPrefetchingBySize, this.TotalCacheSizeInBytes ?? 0, this.Settings == null ? 0 : this.Settings.TotalLinkCredit, this.LinkCredit); } } if (releaseMessage) { this.ReleaseMessage(message); message.Dispose(); } if (creditToIssue > 0) { this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary); } if (waiter != null) { // Schedule the completion on another thread so we don't block the I/O thread ActionItem.Schedule( o => { var state = (Tuple <ReceiveAsyncResult, IEnumerable <AmqpMessage> >)o; state.Item1.Signal(state.Item2, false); }, new Tuple <ReceiveAsyncResult, IEnumerable <AmqpMessage> >(waiter, new AmqpMessage[] { message })); } } }
public AmqpMessage EndReceiveMessage(IAsyncResult result) { if (result is ReceiveAsyncResult) { return(ReceiveAsyncResult.End(result)); } else { return(CompletedAsyncResult <AmqpMessage> .End(result)); } }
public bool EndReceiveMessages(IAsyncResult result, out IEnumerable <AmqpMessage> messages) { if (result is ReceiveAsyncResult) { return(ReceiveAsyncResult.End(result, out messages)); } messages = CompletedAsyncResult <IEnumerable <AmqpMessage> > .End(result); return(true); }
void OnReceiveComplete(IAsyncResult result) { HttpListenerContext context = ReceiveAsyncResult.End(result); _bufferPool.Return(((ReceiveAsyncResult)result).buffer); if (!_enqueueOnReceive) { this.Enqueue(); } SendReply(context); }
public bool EndReceiveMessage(IAsyncResult result, out AmqpMessage message) { if (result is ReceiveAsyncResult) { IEnumerable <AmqpMessage> messages; bool retValue = ReceiveAsyncResult.End(result, out messages); message = messages.FirstOrDefault(); return(retValue); } message = CompletedAsyncResult <IEnumerable <AmqpMessage> > .End(result).FirstOrDefault(); return(true); }
static void OnTimer(object state) { ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)state; lock (thisPtr.parent.SyncRoot) { if (thisPtr.parent.waiterList == null || thisPtr.node == null) { return; } thisPtr.parent.waiterList.Remove(thisPtr.node); thisPtr.node = null; } thisPtr.CompleteInternal(false, thisPtr.MessageCount > 0 ? 1 : 2, null); // 1: signaled, 2: timeout }
public IAsyncResult BeginReceiveMessage(TimeSpan timeout, AsyncCallback callback, object state) { this.ThrowIfNotOpen(); if (timeout < this.minTimeout) { timeout = this.minTimeout; } AmqpMessage message = null; lock (this.syncRoot) { if (this.messageQueue.Count > 0) { message = this.messageQueue.Dequeue(); } } if (message == null && timeout > TimeSpan.Zero) { ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, timeout, callback, state); lock (this.syncRoot) { if (this.messageQueue.Count > 0) { message = this.messageQueue.Dequeue(); } else { LinkedListNode <ReceiveAsyncResult> node = this.waiterList.AddLast(waiter); waiter.Initialize(node); } } if (message != null) { waiter.Signal(message, true); } return(waiter); } else { return(new CompletedAsyncResult <AmqpMessage>(message, callback, state)); } }
static void OnTimer(object state) { ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)state; lock (thisPtr.parent.SyncRoot) { if (thisPtr.parent.waiterList == null || thisPtr.node == null) { return; } thisPtr.parent.waiterList.Remove(thisPtr.node); thisPtr.node = null; } thisPtr.CompleteInternal(null, false, 2, null); }
public IAsyncResult BeginReceiveMessage(TimeSpan timeout, AsyncCallback callback, object state) { this.ThrowIfNotOpen(); if (timeout < this.minTimeout) { timeout = this.minTimeout; } AmqpMessage message = null; lock (this.syncRoot) { if (this.messageQueue.Count > 0) { message = this.messageQueue.Dequeue(); } } if (message == null && timeout > TimeSpan.Zero) { ReceiveAsyncResult waiter = new ReceiveAsyncResult(this, timeout, callback, state); lock (this.syncRoot) { if (this.messageQueue.Count > 0) { message = this.messageQueue.Dequeue(); } else { LinkedListNode<ReceiveAsyncResult> node = this.waiterList.AddLast(waiter); waiter.Initialize(node); } } if (message != null) { waiter.Signal(message, true); } return waiter; } else { return new CompletedAsyncResult<AmqpMessage>(message, callback, state); } }
static void OnReadComplete(IAsyncResult result) { if (result.CompletedSynchronously) { return; } ReceiveAsyncResult thisPtr = result.AsyncState as ReceiveAsyncResult; Exception completionException = null; try { thisPtr.HandleReadComplete(result); } catch (Exception ex) { completionException = ex; } thisPtr.Complete(false, completionException); }
static void OnReceiveComplete(object state) { ReceiveAsyncResult thisPtr = ((ReceiveAsyncResult)state); Exception completionException = null; try { thisPtr.SetReturnValue(thisPtr.Source.EndReceive()); } #pragma warning suppress 56500 // Microsoft, transferring exception to another thread catch (Exception e) { if (Fx.IsFatal(e)) { throw; } completionException = e; } thisPtr.CompleteWithUnlock(false, completionException); }
static void OnReadData(IAsyncResult result) { if (result.CompletedSynchronously) { return; } ReceiveAsyncResult thisPtr = (ReceiveAsyncResult)result.AsyncState; Exception completionException = null; try { thisPtr.CompleteReadData(result); } catch (Exception e) { completionException = e; } thisPtr.Complete(false, completionException); }
public static Message End(IAsyncResult result) { ReceiveAsyncResult <TInputChannel> thisPtr = AsyncResult.End <ReceiveAsyncResult <TInputChannel> >(result); return(thisPtr.Message); }
public static HttpListenerContext End(IAsyncResult result) { ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result); return(thisPtr.context); }
public IMessage EndReceive(IAsyncResult asyncResult) { ReceiveAsyncResult result = (ReceiveAsyncResult)asyncResult; return(result.Message); }
public static Message End(IAsyncResult result) { ReceiveAsyncResult thisPtr = AsyncResult.End <ReceiveAsyncResult>(result); return(thisPtr.message); }
public static Message End(IAsyncResult result) { ReceiveAsyncResult asyncResult = AsyncResult.End <ReceiveAsyncResult>(result); return(asyncResult.Message); }
public virtual Message EndReceive(IAsyncResult result) { return(ReceiveAsyncResult.End(result)); }
public Message EndReceive(IAsyncResult result) { return(ReceiveAsyncResult <TChannel> .End(result)); }
void OnReceiveMessage(AmqpMessage message) { if (this.messageListener != null) { this.messageListener(message); } else { ReceiveAsyncResult waiter = null; int creditToIssue = 0; bool releaseMessage = false; lock (this.SyncRoot) { if (this.waiterList != null && this.waiterList.Count > 0) { var firstWaiter = this.waiterList.First.Value; if (this.messageQueue.IsPrefetchingBySize) { if (this.messageQueue.UpdateCreditToIssue(message)) { this.SetTotalLinkCredit(this.messageQueue.BoundedTotalLinkCredit, true); } } firstWaiter.Add(message); if (firstWaiter.RequestedMessageCount == 1 || firstWaiter.MessageCount >= firstWaiter.RequestedMessageCount) { this.waiterList.RemoveFirst(); firstWaiter.OnRemoved(); creditToIssue = this.Settings.AutoSendFlow ? 0 : this.GetOnDemandReceiveCredit(); waiter = firstWaiter; } } else if (!this.Settings.AutoSendFlow && this.Settings.SettleType != SettleMode.SettleOnSend) { releaseMessage = true; } else if (this.messageQueue != null) { this.messageQueue.Enqueue(message); AmqpTrace.Provider.AmqpCacheMessage( this, message.DeliveryId.Value, this.messageQueue.Count, this.messageQueue.IsPrefetchingBySize, this.TotalCacheSizeInBytes ?? 0, this.Settings == null ? 0 : this.Settings.TotalLinkCredit, this.LinkCredit); } } if (releaseMessage) { this.ReleaseMessage(message); message.Dispose(); } if (creditToIssue > 0) { this.IssueCredit((uint)creditToIssue, false, AmqpConstants.NullBinary); } if (waiter != null) { // Schedule the completion on another thread so we don't block the I/O thread ActionItem.Schedule(o => { var w = (ReceiveAsyncResult)o; w.Signal(false); }, waiter); } } }