public void CloseBehviour()
{
var queue = new SharedQueue();
queue.Enqueue("Hello World");
//queue.Close();
var item = queue.Dequeue().ToString();
Console.Out.WriteLine("item = {0}", item);
ThreadPool.QueueUserWorkItem(state =>
{
// expect the queue to block here
Console.WriteLine("Dequeue in thread");
try
{
var item2 = queue.Dequeue().ToString();
}
catch (Exception e)
{
Console.WriteLine("Exception in thread\n{0}", e.ToString());
}
});
Thread.Sleep(100);
Console.WriteLine("Closing queue");
queue.Close();
Console.WriteLine("Done");
}
public void WillReceiveOnly(params uint[] values)
{
foreach (var value in values)
{
object received;
Assert.IsTrue(output.Dequeue(500, out received), "Couldn't wait for {0}", value);
Assert.AreEqual(value, Value(received));
}
WillNotReceiveAnything();
}
public void TestRecoverAfterCancel_()
{
UTF8Encoding enc = new UTF8Encoding();
Channel.BasicPublish("", Queue, null, enc.GetBytes("message"));
EventingBasicConsumer Consumer = new EventingBasicConsumer(Channel);
SharedQueue <BasicDeliverEventArgs> EventQueue = new SharedQueue <BasicDeliverEventArgs>();
Consumer.Received += (_, e) => EventQueue.Enqueue(e);
string CTag = Channel.BasicConsume(Queue, false, Consumer);
BasicDeliverEventArgs Event = EventQueue.Dequeue();
Channel.BasicCancel(CTag);
Channel.BasicRecover(true);
EventingBasicConsumer Consumer2 = new EventingBasicConsumer(Channel);
SharedQueue <BasicDeliverEventArgs> EventQueue2 = new SharedQueue <BasicDeliverEventArgs>();
Consumer2.Received += (_, e) => EventQueue2.Enqueue(e);
Channel.BasicConsume(Queue, false, Consumer2);
BasicDeliverEventArgs Event2 = EventQueue2.Dequeue();
CollectionAssert.AreEqual(Event.Body.ToArray(), Event2.Body.ToArray());
Assert.IsFalse(Event.Redelivered);
Assert.IsTrue(Event2.Redelivered);
}
public void TestDequeueNoWait2()
{
var q = new SharedQueue();
q.Enqueue(1);
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(0, q.DequeueNoWait(0));
}
public void TestCloseWhenFull()
{
var q = new SharedQueue();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Close();
var de = new DelayedEnqueuer(q, 0, 4);
ExpectEof(de.EnqueueValue);
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.DequeueNoWait(0));
bool r = q.Dequeue(TimeSpan.FromMilliseconds(1), out object v);
Assert.IsTrue(r);
Assert.AreEqual(3, v);
ExpectEof(de.Dequeue);
}
public void TestCloseWhenFull()
{
SharedQueue q = new SharedQueue();
object v;
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Close();
DelayedEnqueuer de = new DelayedEnqueuer(q, 0, 4);
ExpectEof(new Thunk(de.EnqueueValue));
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.DequeueNoWait(0));
bool r = q.Dequeue(1, out v);
Assert.IsTrue(r);
Assert.AreEqual(3, v);
ExpectEof(new Thunk(de.Dequeue));
}
public void TestTimeoutLong()
{
var q = new SharedQueue();
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestTimeoutNegative()
{
var q = new SharedQueue();
ResetTimer();
bool r = q.Dequeue(TimeSpan.FromMilliseconds(-10000), out object v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestDelayedEnqueue()
{
var q = new SharedQueue();
ResetTimer();
EnqueueAfter(TimingInterval, q, 1);
Assert.AreEqual(0, q.DequeueNoWait(0));
Assert.Greater(TimingInterval - SafetyMargin, ElapsedMs());
Assert.AreEqual(1, q.Dequeue());
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
}
public void TestTimeoutNegative()
{
var q = new SharedQueue();
ResetTimer();
object v;
bool r = q.Dequeue(-10000, out v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestDoublePoll()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval * 2, q, 123);
ResetTimer();
bool r;
r = q.Dequeue(TimingInterval, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.Greater(TimingInterval + SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
r = q.Dequeue(TimingInterval * 2, out v);
Assert.Less(TimingInterval * 2 - SafetyMargin, ElapsedMs());
Assert.Greater(TimingInterval * 2 + SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
public void TestBgLong()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval * 2, q, 123);
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Greater(TimingInterval + SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
bool IEnumerator.MoveNext()
{
try
{
m_current = m_queue.Dequeue();
return(true);
}
catch (EndOfStreamException)
{
m_current = default(T);
return(false);
}
}
public void TestTimeoutShort()
{
var q = new SharedQueue();
q.Enqueue(123);
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
public void TestDoubleBg()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval, q, 123);
EnqueueAfter(TimingInterval_2X, q, 234);
ResetTimer();
bool r;
r = q.Dequeue(TimingInterval_2X, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.Greater(TimingInterval + SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
r = q.Dequeue(TimingInterval_2X, out v);
Assert.Less(TimingInterval_2X - SafetyMargin, ElapsedMs());
Assert.Greater(TimingInterval_2X + SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(234, v);
}
public void TestTimeoutInfinite()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval, q, 123);
ResetTimer();
bool r = q.Dequeue(Timeout.InfiniteTimeSpan, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
public void TestBgShort()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval, q, 123);
ResetTimer();
object v;
bool r = q.Dequeue(TimingInterval * 2, out v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
/// <summary>
/// Получить очередное сообщение.
/// </summary>
public Message Dequeue()
{
var queueEntry = _queue.Dequeue();
return(new Message
{
DeliveryTag = queueEntry.DeliveryTag,
ConsumerId = queueEntry.ConsumerTag,
Exchange = queueEntry.Exchange,
RoutingKey = queueEntry.RoutingKey,
Properties = _messageConverter.ConvertFrom(queueEntry.BasicProperties),
Body = queueEntry.Body
});
}
public void Process()
{
while (true)
{
if (!m_queue.IsEmpty())
{
var vitals = m_queue.Dequeue();
m_vitalsManager.AlertUsers(vitals);
PatientAlert alert = m_validator.ValidateVitalsRange(vitals);
m_alertManager.AlertUsers(alert);
m_vitalsRepository.WriteVitals(vitals);
}
}
}
public QueueingConsumerFactory(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
while (true)
{
if (disposed)
{
break;
}
try
{
BasicDeliverEventArgs deliverEventArgs;
lock (sharedQueueLock)
{
deliverEventArgs = (BasicDeliverEventArgs)sharedQueue.Dequeue();
}
if (deliverEventArgs != null)
{
HandleMessageDelivery(deliverEventArgs);
}
}
catch (EndOfStreamException)
{
// do nothing here, EOS fired when queue is closed
// Looks like the connection has gone away, so wait a little while
// before continuing to poll the queue
Thread.Sleep(10);
}
}
});
subscriptionCallbackThread.Start();
}
/// <summary>
/// Dequeues this instance.
/// </summary>
/// <returns></returns>
public object Dequeue()
{
return(_sharedQueue.Dequeue());
}
public void Dequeue()
{
m_q.Dequeue();
}
/// <summary>
/// Dequeues events from shared memory
/// </summary>
internal void Listener()
{
WspEvent wspEvent;
DateTime nextPushSubscriptions = DateTime.UtcNow.AddMinutes(subscriptionRefreshIncrement);
ReturnCode rc;
try
{
Thread.CurrentThread.Priority = ThreadPriority.Highest;
byte[] buffer = null;
while (StopListening == false)
{
try
{
buffer = eventQueue.Dequeue(Timeout);
if (buffer != null)
{
try
{
wspEvent = new WspEvent(buffer);
}
catch (Exception e)
{
EventLog.WriteEntry("WspEventRouter", "Event has invalid format: " + e.ToString(), EventLogEntryType.Error);
continue;
}
List <WspEventObservable> observables;
if (WspEventObservable.eventObservables.TryGetValue(wspEvent.EventType, out observables) == true)
{
for (int i = 0; i < observables.Count; i++)
{
observables[i].queue.Enqueue(wspEvent, wspEvent.SerializedEvent.Length);
}
}
}
if (DateTime.UtcNow > nextPushSubscriptions)
{
try
{
foreach (Guid subId in subscriptions.Keys)
{
foreach (string expression in subscriptions[subId].Keys)
{
WspEvent subEvent = new WspEvent(Subscription.SubscriptionEvent, null, subscriptions[subId][expression].Serialize());
publishMgr.Publish(subEvent.SerializedEvent, out rc);
}
}
nextPushSubscriptions = DateTime.UtcNow.AddMinutes(subscriptionRefreshIncrement);
}
catch
{
// intentionally left blank
// it will retry next time
}
}
}
catch (PubSubException e)
{
EventLog.WriteEntry("WspEventRouter", "Exception occurred processing event from shared queue: " + e.ToString(), EventLogEntryType.Error);
continue;
}
catch (Exception e)
{
EventLog.WriteEntry("WspEventRouter", "Exception occurred processing event from shared queue: " + e.ToString(), EventLogEntryType.Error);
continue;
}
}
}
catch (ThreadAbortException)
{
// Another thread has signalled that this worker
// thread must terminate. Typically, this occurs when
// the main service thread receives a service stop
// command.
}
catch (AccessViolationException)
{
// This can occur after the thread has been stopped and the runtime is doing GC.
// Just let the thread quit to end listening.
}
catch (SharedQueueException e)
{
throw new PubSubException(e.Message, e.InnerException);
}
}
static void Consume(object obj)
{
Console.WriteLine($"Thread #{Thread.CurrentThread.ManagedThreadId} consumes the {sharedQueue.Dequeue()}");
}
