Exemplo n.º 1
0
        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");
        }
Exemplo n.º 2
0
        public void ClearConsumers()
        {
            callbacks.Clear();
            sharedQueue.Close(); // Dequeue will stop blocking and throw an EndOfStreamException

            Console.WriteLine("Waiting for ClearConsumers lock");
            lock (sharedQueueLock)
            {
                Console.WriteLine("Got ClearConsumers lock");
                sharedQueue = new SharedQueue();
            }
            //Console.WriteLine("Cleared ClearConsumers lock");
        }
Exemplo n.º 3
0
 public EasyNetQConsumer(IModel model, SharedQueue queue)
     : base(model)
 {
     this.queue = queue;
 }
Exemplo n.º 4
0
 ///<summary>Creates a fresh QueueingBasicConsumer,
 ///initialising the Model and Queue properties to the given
 ///values.</summary>
 public QueueingBasicConsumer(IModel model, SharedQueue queue)
     : base(model)
 {
     m_queue = queue;
 }
 public static void EnqueueAfter(int delayMs, SharedQueue q, object v)
 {
     DelayedEnqueuer de = new DelayedEnqueuer(q, delayMs, v);
     new Thread(new ThreadStart(de.EnqueueValue)).Start();
 }
        public void TestTimeoutShort()
        {
            SharedQueue q = new SharedQueue();
            q.Enqueue(123);

            ResetTimer();
            object v;
            bool r = q.Dequeue(TimingInterval, out v);
            Assert.Greater(SafetyMargin, ElapsedMs());
            Assert.IsTrue(r);
            Assert.AreEqual(123, v);
        }
        public void TestTimeoutLong()
        {
            SharedQueue q = new SharedQueue();

            ResetTimer();
            object v;
            bool r = q.Dequeue(TimingInterval, out v);
            Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
            Assert.IsTrue(!r);
            Assert.AreEqual(null, v);
        }
 public void TestEnumerator()
 {
     SharedQueue q = new SharedQueue();
     VolatileInt c1 = new VolatileInt();
     VolatileInt c2 = new VolatileInt();
     Thread t1 = new Thread(delegate() {
             foreach (int v in q) c1.v+=v;
         });
     Thread t2 = new Thread(delegate() {
             foreach (int v in q) c2.v+=v;
         });
     t1.Start();
     t2.Start();
     q.Enqueue(1);
     q.Enqueue(2);
     q.Enqueue(3);
     q.Close();
     t1.Join();
     t2.Join();
     Assert.AreEqual(6, c1.v + c2.v);
 }
 public void TestDequeueNoWait3()
 {
     SharedQueue q = new SharedQueue();
     Assert.AreEqual(null, q.DequeueNoWait(null));
 }
Exemplo n.º 10
0
 ///<summary>Construct an enumerator for the given
 ///SharedQueue.</summary>
 public SharedQueueEnumerator(SharedQueue <T> queue)
 {
     m_queue   = queue;
     m_current = default(T);
 }
 public QueueingAutoAckConsumer(IModel model, SharedQueue<BasicDeliverEventArgs> queue)
     : base(model, queue)
 {
 }
 ///<summary>Construct an enumerator for the given
 ///SharedQueue.</summary>
 public SharedQueueEnumerator(SharedQueue <T> queue)
 {
     _queue   = queue;
     _current = default;
 }
 public static void EnqueueAfter(int delayMs, SharedQueue queue, object v)
 {
     var enqueuer = new DelayedEnqueuer(queue, delayMs, v);
     new Thread(enqueuer.EnqueueValue).Start();
 }
 public void TestEnumerator()
 {
     var queue = new SharedQueue();
     var c1 = new VolatileInt();
     var c2 = new VolatileInt();
     var thread1 = new Thread(() => { foreach (int v in queue) c1.v += v; });
     var thread2 = new Thread(() => { foreach (int v in queue) c2.v += v; });
     thread1.Start();
     thread2.Start();
     queue.Enqueue(1);
     queue.Enqueue(2);
     queue.Enqueue(3);
     queue.Close();
     thread1.Join();
     thread2.Join();
     Assert.AreEqual(6, c1.v + c2.v);
 }
 /// <summary>
 /// Creates a fresh <see cref="QueueingBasicConsumer"/>,
 ///  initialising the <see cref="DefaultBasicConsumer.Model"/>
 ///  and <see cref="Queue"/> properties to the given values.
 /// </summary>
 public QueueingBasicConsumer(IModel model, SharedQueue<BasicDeliverEventArgs> queue)
     : base(model)
 {
     Queue = queue;
 }
 public void TestDequeueNoWait1()
 {
     var queue = new SharedQueue();
     queue.Enqueue(1);
     Assert.AreEqual(1, queue.DequeueNoWait(0));
     Assert.AreEqual(0, queue.DequeueNoWait(0));
 }
Exemplo n.º 17
0
 public RabbitMqBasicConsumer(IModel model, SharedQueue<BasicGetResult> queue)
     : base(model)
 {
     this.queue = queue;
 }
        public void TestDoublePoll()
        {
            SharedQueue q = new SharedQueue();
            EnqueueAfter(TimingInterval * 2, q, 123);

            ResetTimer();
            object v;
            bool r;

            r = q.Dequeue(TimingInterval, out 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);
        }
Exemplo n.º 19
0
        public void Restart()
        {
            isStarted = true;

            //CLose connections and channels
            if (subscriberChannel != null)
            {

                try
                {
                    subscriberChannel.Close();
                }
                catch
                {
                }
            }

            if (workChannel != null)
            {
                try
                {
                    workChannel.Close();
                }
                catch
                {
                }
            }

            if (conn != null)
            {
                try
                {
                    conn.Close();
                }
                catch
                {
                }

                try
                {
                    conn.Dispose();
                }
                catch
                {
                }
            }

            //TODO: CreateConnection() can always throw BrokerUnreachableException so keep that in mind when calling
            conn = connectionFactory.CreateConnection();

            //Create shared queue
            SharedQueue<BasicDeliverEventArgs> queue = new SharedQueue<BasicDeliverEventArgs>();

            //Create work channel and declare exchanges and queues
            workChannel = conn.CreateModel();

            /* Work this into subscriber dispose and restart
            //Cancel consumers on server
            if(workCTag != null)
            {
                try
                {
                    workChannel.BasicCancel(workCTag);
                }
                catch { }
            }

            if (subscriberCTag != null)
            {
                try
                {
                    workChannel.BasicCancel(subscriberCTag);
                }
                catch { }
            }
             */

            //Redeclare exchanges and queues
            AmqpUtils.DeclareExchangeAndQueues(workChannel, exchangeInfo, exchangeDeclareSync, subscriberId);

            //Listen on work queue
            workConsumer = new QueueingBasicConsumer(workChannel, queue);
            string workQueueName = AmqpUtils.GetWorkQueueName(exchangeInfo);
            workChannel.BasicConsume(workQueueName, false, workConsumer);

            //Listen on subscriber queue
            subscriberChannel = conn.CreateModel();
            subscriberConsumer = new QueueingBasicConsumer(subscriberChannel, queue);
            string subscriberWorkQueueName = AmqpUtils.GetSubscriberQueueName(exchangeInfo, subscriberId);
            subscriberChannel.BasicConsume(subscriberWorkQueueName, false, subscriberConsumer);
        }
        public void TestTimeoutInfinite()
        {
            SharedQueue q = new SharedQueue();
            EnqueueAfter(TimingInterval, q, 123);

            ResetTimer();
            object v;
            bool r = q.Dequeue(Timeout.Infinite, out v);
            Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
            Assert.IsTrue(r);
            Assert.AreEqual(123, v);
        }
Exemplo n.º 21
0
        private bool TryGetRequest(SharedQueue<BasicDeliverEventArgs> queue, out HttpRequestPacket request, out IBasicProperties properties)
        {
            object obj;
            BasicDeliverEventArgs evt;
            request = null;
            properties = null;

            obj = queue.DequeueNoWait(null);
            if (obj != null)
            {
                 evt = (BasicDeliverEventArgs)obj;
            }
            else
            {
                return false;
            }

            //Get message properties
            properties = evt.BasicProperties;

            //Deserialize message
            bool wasDeserialized = true;

            try
            {
                request = HttpRequestPacket.Deserialize(evt.Body);

                //Add/Update Content-Length Header
                request.Headers["Content-Length"] = new string[] { (request.Content == null ? 0 : request.Content.Length).ToString() };

                //Add/Update Subscriber-Id header
                request.Headers[Common.Shared.SUBSCRIBER_ID_HEADER] = new string[] { this.subscriberId };

            }
            catch
            {

                wasDeserialized = false;
            }

            //Ack or reject message
            if (evt.ConsumerTag == workConsumer.ConsumerTag)
            {
                if (wasDeserialized)
                {
                    workConsumer.Model.BasicAck(evt.DeliveryTag, false);
                    return true;
                }
                else
                {
                    workConsumer.Model.BasicReject(evt.DeliveryTag, false);
                    return false;
                }
            }
            else if (evt.ConsumerTag == subscriberConsumer.ConsumerTag)
            {
                if (wasDeserialized)
                {
                    subscriberConsumer.Model.BasicAck(evt.DeliveryTag, false);
                    return true;
                }
                else
                {
                    subscriberConsumer.Model.BasicReject(evt.DeliveryTag, false);
                    return false;
                }
            }
            else
            {
                throw new InvalidOperationException("Message was dequeued by an unexpected/unknown consumer");
            }
        }
        public void TestTimeoutNegative()
        {
            SharedQueue q = new SharedQueue();

            ResetTimer();
            object v;
            bool r = q.Dequeue(-10000, out v);
            Assert.Greater(SafetyMargin, ElapsedMs());
            Assert.IsTrue(!r);
            Assert.AreEqual(null, v);
        }
Exemplo n.º 23
0
        //Will block until a request is received from either queue
        public MessageContext Dequeue()
        {
            if (disposed) throw new ObjectDisposedException("Subscriber has been disposed");
            if(workConsumer == null || subscriberConsumer == null) throw new InvalidOperationException("Start the subscriber prior to calling Dequeue");

            HttpRequestPacket request;
            IBasicProperties properties;

            SharedQueue<BasicDeliverEventArgs> queue1 = null, queue2 = null;

            while (true)
            {
                if (disposed) throw new ObjectDisposedException("Subscriber has been disposed");
                if (lastProcessedQueue == subscriberConsumer.Queue)
                {
                    queue1 = workConsumer.Queue;
                    queue2 = subscriberConsumer.Queue;
                }
                else
                {
                    queue1 = subscriberConsumer.Queue;
                    queue2 = workConsumer.Queue;
                }

                try
                {
                    if (TryGetRequest(queue1, out request, out properties))
                    {
                        lastProcessedQueue = queue1;
                        break;
                    }

                    if (TryGetRequest(queue2, out request, out properties))
                    {
                        lastProcessedQueue = queue2;
                        break;
                    }
                }
                catch (Exception e)
                {
                    if (!(e is System.IO.EndOfStreamException))
                    {
                        //TODO: Log exception: Don't know what else to expect here

                    }

                    //TODO: IS this the best place to place reconnection logic? In a catch block??

                    //Loop until a connection is made
                    bool successfulRestart = false;
                    while (true)
                    {
                        try
                        {
                            Restart();
                            successfulRestart = true;
                        }
                        catch { }

                        if (disposed) throw new ObjectDisposedException("Subscriber has been disposed");

                        if (successfulRestart) break;
                        Thread.Sleep(1);
                    }

                    //Check for next message
                    continue;
                }

                Thread.Sleep(1); //Nothing was found in both queues so take a 1ms nap

            }

            return new MessageContext { Request = request, ReplyToQueue = properties == null ? null : properties.ReplyTo, CorrelationId = properties.CorrelationId };
        }
 public DelayedEnqueuer(SharedQueue q, int delayMs, object v)
 {
     m_q = q;
     m_delayMs = delayMs;
     m_v = v;
 }
 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 TestBgLong()
        {
            SharedQueue q = new SharedQueue();
            EnqueueAfter(TimingInterval * 2, q, 123);

            ResetTimer();
            object v;
            bool r = q.Dequeue(TimingInterval, out v);
            Assert.Greater(TimingInterval + SafetyMargin, ElapsedMs());
            Assert.IsTrue(!r);
            Assert.AreEqual(null, v);
        }
 public void TestCloseWhenWaiting()
 {
     SharedQueue q = new SharedQueue();
     DelayedEnqueuer de = new DelayedEnqueuer(q, 0, null);
     Thread t =
     new Thread(new ThreadStart(de.BackgroundEofExpectingDequeue));
     t.Start();
     Thread.Sleep(SafetyMargin);
     q.Close();
     t.Join();
 }
Exemplo n.º 28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SharedQueueDecorator"/> class.
 /// </summary>
 /// <param name="sharedQueue">The shared queue.</param>
 internal SharedQueueDecorator(SharedQueue<BasicDeliverEventArgs> sharedQueue)
 {
     _sharedQueue = sharedQueue;
 }
 public void TestDelayedEnqueue()
 {
     SharedQueue 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());
 }
Exemplo n.º 30
0
        public void ClearConsumers()
        {
            sharedQueue.Close(); // Dequeue will stop blocking and throw an EndOfStreamException

            lock (sharedQueueLock)
            {
                logger.DebugWrite("Clearing consumer subscriptions");
                sharedQueue = new SharedQueue();
                subscriptions.Clear();
            }
        }
 public void TestDequeueNoWait2()
 {
     SharedQueue q = new SharedQueue();
     q.Enqueue(1);
     Assert.AreEqual(1, q.Dequeue());
     Assert.AreEqual(0, q.DequeueNoWait(0));
 }
Exemplo n.º 32
0
 public LocalQueueingBasicConsumer(IModel model, SharedQueue queue)
     : base(model)
 {
     this.m_queue = queue;
 }
Exemplo n.º 33
0
 ///<summary>Construct an enumerator for the given
 ///SharedQueue.</summary>
 public SharedQueueEnumerator(SharedQueue queue)
 {
     m_queue = queue;
 }