コード例 #1
0
ファイル: SustainedTest.cs プロジェクト: drzo/opensim4opencog
 public void MessageOrderTest(AcknowledgeMode consumerMode)
 {
 	
 	// Consumer
 	SetUpEndPoint(1, false, true, TEST_ROUTING_KEY, consumerMode, false, ExchangeNameDefaults.DIRECT,
                       true, false, null);
 	
 	
 	Console.WriteLine("Starting producer thread");
 	Thread prodThread = new Thread(new ThreadStart(SendMessages));
 	prodThread.Start();
 	
 	Thread.Sleep(2000);
 	Console.WriteLine("Starting consuming");
 	for (int i = 0; i < MESSAGE_COUNT; i++)
 	{
 		if ((i % 10) == 0)
 		{
 			Console.WriteLine("Consuming message "+i);
 		}
 		ConsumeNMessages(1, "Msg"+i, testConsumer[1]);
 	}
 	prodThread.Join();
 	CloseEndPoint(0);
 	CloseEndPoint(1);
 }
コード例 #2
0
        private void TestDurableSubscription(AcknowledgeMode ackMode)
        {
            // Create a topic with one producer and two consumers.
            SetUpEndPoint(0, true, false, TEST_ROUTING_KEY + testId, ackMode, false, ExchangeNameDefaults.TOPIC, true, false, null);
            SetUpEndPoint(1, false, true, TEST_ROUTING_KEY + testId, ackMode, false, ExchangeNameDefaults.TOPIC, true, false, null);
            SetUpEndPoint(2, false, true, TEST_ROUTING_KEY + testId, ackMode, false, ExchangeNameDefaults.TOPIC, true,
                          true, "TestSubscription" + testId);

            Thread.Sleep(500);

            // Send messages and receive on both consumers.
            testProducer[0].Send(testChannel[0].CreateTextMessage("A"));

            ConsumeNMessagesOnly(1, "A", testConsumer[1]);
            ConsumeNMessagesOnly(1, "A", testConsumer[2]);

            // Detach one consumer.
            CloseEndPoint(2);

            // Send message and receive on one consumer.
            testProducer[0].Send(testChannel[0].CreateTextMessage("B"));

            ConsumeNMessagesOnly(1, "B", testConsumer[1]);

            // Re-attach consumer, check that it gets the messages that it missed.
            SetUpEndPoint(2, false, true, TEST_ROUTING_KEY + testId, ackMode, false, ExchangeNameDefaults.TOPIC, true,
                          true, "TestSubscription" + testId);

            ConsumeNMessagesOnly(1, "B", testConsumer[2]);
			
            // Clean up any open consumers at the end of the test.
            CloseEndPoint(2);
            CloseEndPoint(1);
            CloseEndPoint(0);
        }
コード例 #3
0
ファイル: AMQConnection.cs プロジェクト: drzo/opensim4opencog
 public CreateChannelFailoverSupport(AMQConnection connection, bool transacted, AcknowledgeMode acknowledgeMode, int prefetchHigh, int prefetchLow)
 {
     _connection = connection;
     _transacted = transacted;
     _acknowledgeMode = acknowledgeMode;
     _prefetchHigh = prefetchHigh;
     _prefetchLow = prefetchLow;
 }
コード例 #4
0
ファイル: AmqChannel.cs プロジェクト: drzo/opensim4opencog
        private String ConsumeFromQueue(String queueName, bool noLocal, bool exclusive, AcknowledgeMode acknowledgeMode, String tag, bool browse)
        {
            FieldTable args = new FieldTable();   
            if(browse)
            {
               args["x-filter-no-consume"] = true;
            }
            args["x-filter-auto-close"] = false;
            AMQFrame basicConsume = BasicConsumeBody.CreateAMQFrame(_channelId, 0,
                                                                    queueName, tag, noLocal,
                                                                    acknowledgeMode == AcknowledgeMode.NoAcknowledge,
                                                                    exclusive, true, args);

            _replayFrames.Add(basicConsume);

            _connection.ProtocolWriter.Write(basicConsume);
            return tag;
        }
コード例 #5
0
 public CreateChannelFailoverSupport(AMQConnection connection, bool transacted, AcknowledgeMode acknowledgeMode, int prefetchHigh, int prefetchLow)
 {
     _connection      = connection;
     _transacted      = transacted;
     _acknowledgeMode = acknowledgeMode;
     _prefetchHigh    = prefetchHigh;
     _prefetchLow     = prefetchLow;
 }
コード例 #6
0
 public static bool IsAutoAck(this AcknowledgeMode mode)
 {
     return(mode == AcknowledgeMode.NONE);
 }
コード例 #7
0
 /// <summary> Sets up the nth test end-point. </summary>
 ///
 /// <param name="n">The index of the test end-point to set up.</param>
 /// <param name="producer"><tt>true</tt> to set up a producer on the end-point.</param>
 /// <param name="consumer"><tt>true</tt> to set up a consumer on the end-point.</param>
 /// <param name="routingKey">The routing key for the producer to send on.</param>
 /// <param name="ackMode">The ack mode for the end-points channel.</param>
 /// <param name="transacted"><tt>true</tt> to use transactions on the end-points channel.</param>
 /// <param name="exchangeName">The exchange to produce or consume on.</param>
 /// <param name="declareBind"><tt>true</tt> if the consumers queue should be declared and bound, <tt>false</tt> if it has already been.</param>
 /// <param name="durable"><tt>true</tt> to declare the consumers queue as durable.</param>
 /// <param name="subscriptionName">If durable is true, the fixed unique queue name to use.</param>
 public void SetUpEndPoint(int n, bool producer, bool consumer, string routingKey, AcknowledgeMode ackMode, bool transacted,
                           string exchangeName, bool declareBind, bool durable, string subscriptionName)
 {
    SetUpEndPoint(n, producer, consumer, routingKey, ackMode, transacted, exchangeName, declareBind, durable, subscriptionName, true, false);
 }
コード例 #8
0
        /// <summary> Sets up the nth test end-point. </summary>
        ///
        /// <param name="n">The index of the test end-point to set up.</param>
        /// <param name="producer"><tt>true</tt> to set up a producer on the end-point.</param>
        /// <param name="consumer"><tt>true</tt> to set up a consumer on the end-point.</param>
        /// <param name="routingKey">The routing key for the producer to send on.</param>
        /// <param name="ackMode">The ack mode for the end-points channel.</param>
        /// <param name="transacted"><tt>true</tt> to use transactions on the end-points channel.</param>
        /// <param name="exchangeName">The exchange to produce or consume on.</param>
        /// <param name="declareBind"><tt>true</tt> if the consumers queue should be declared and bound, <tt>false</tt> if it has already been.</param>
        /// <param name="durable"><tt>true</tt> to declare the consumers queue as durable.</param>
        /// <param name="subscriptionName">If durable is true, the fixed unique queue name to use.</param>
        /// <param name="exclusive"><tt>true</tt> declare queue as exclusive.</param>
        /// <param name="browse"><tt>true</tt> only browse, don''t consume.</param>
        public void SetUpEndPoint(int n, bool producer, bool consumer, string routingKey, AcknowledgeMode ackMode, bool transacted,
                                  string exchangeName, bool declareBind, bool durable, string subscriptionName, bool exclusive, bool browse)
        {
            // Allow client id to be fixed, or undefined.
            {
                // Use unique id for end point.
                connectionInfo = QpidConnectionInfo.FromUrl(connectionUri);

                connectionInfo.ClientName = "test" + n;
            }

            testConnection[n] = new AMQConnection(connectionInfo);
            testConnection[n].Start();
            testChannel[n] = testConnection[n].CreateChannel(transacted, ackMode);

            if (producer)
            {
                testProducer[n] = testChannel[n].CreatePublisherBuilder()
                                  .WithExchangeName(exchangeName)
                                  .WithRoutingKey(routingKey)
                                  .Create();
            }

            if (consumer)
            {
                string queueName;

                // Use the subscription name as the queue name if the subscription is durable, otherwise use a generated name.
                if (durable)
                {
                    // The durable queue is declared without auto-delete, and passively, in case it has already been declared.
                    queueName = subscriptionName;

                    if (declareBind)
                    {
                        testChannel[n].DeclareQueue(queueName, durable, exclusive, false);
                        testChannel[n].Bind(queueName, exchangeName, routingKey);
                    }
                }
                else
                {
                    queueName = testChannel[n].GenerateUniqueName();

                    if (declareBind)
                    {
                        if (durable)
                        {
                            testQueue[n] = queueName;
                        }
                        testChannel[n].DeclareQueue(queueName, durable, true, true);
                        testChannel[n].Bind(queueName, exchangeName, routingKey);
                    }
                }

                testConsumer[n] = testChannel[n].CreateConsumerBuilder(queueName).WithBrowse(browse).Create();
            }
        }
コード例 #9
0
ファイル: AMQConnection.cs プロジェクト: drzo/opensim4opencog
 public IChannel CreateChannel(bool transacted, AcknowledgeMode acknowledgeMode, int prefetchHigh, int prefetchLow)
 {
     CheckNotClosed();
     if (ChannelLimitReached())
     {
         throw new ChannelLimitReachedException(_maximumChannelCount);
     }
     else
     {
         CreateChannelFailoverSupport operation =
             new CreateChannelFailoverSupport(this, transacted, acknowledgeMode, prefetchHigh, prefetchLow);
         return (IChannel)operation.execute(this);
     }
 }
コード例 #10
0
 public AcknowledgeModeAttribute(AcknowledgeMode mode)
 {
     this.mode = mode;
 }
コード例 #11
0
 /// <summary>Determine if the acknowledge mode is transaction allowed.</summary>
 /// <param name="mode">The mode.</param>
 /// <returns>True if transaction allowed, else false.</returns>
 public static bool TransactionAllowed(this AcknowledgeMode mode)
 {
     return(mode == AcknowledgeMode.Auto || mode == AcknowledgeMode.Manual);
 }
コード例 #12
0
 public IChannel CreateChannel(bool transacted, AcknowledgeMode acknowledgeMode, int prefetch)
 {
     return(CreateChannel(transacted, acknowledgeMode, prefetch, prefetch));
 }
コード例 #13
0
 public IChannel CreateChannel(bool transacted, AcknowledgeMode acknowledgeMode)
 {
     return(CreateChannel(transacted, acknowledgeMode, AmqChannel.DEFAULT_PREFETCH_HIGH_MARK));
 }
コード例 #14
0
ファイル: AMQConnection.cs プロジェクト: drzo/opensim4opencog
 public IChannel CreateChannel(bool transacted, AcknowledgeMode acknowledgeMode)
 {
     return CreateChannel(transacted, acknowledgeMode, AmqChannel.DEFAULT_PREFETCH_HIGH_MARK);
 }
コード例 #15
0
 public static RabbitMQQueueOptionsBuilder Subscribe(this RabbitMQQueueOptionsBuilder builder, AcknowledgeMode acknowledgeMode, Func <RabbitMQDelivery, Task> handler)
 => builder.Subscribe(acknowledgeMode, ExceptionModeAttribute.DefaultMode, handler);
コード例 #16
0
ファイル: AMQConnection.cs プロジェクト: drzo/opensim4opencog
 public IChannel CreateChannel(bool transacted, AcknowledgeMode acknowledgeMode, int prefetch)
 {
    return CreateChannel(transacted, acknowledgeMode, prefetch, prefetch);
 }
コード例 #17
0
        public static RabbitMQQueueOptionsBuilder Subscribe(this RabbitMQQueueOptionsBuilder builder, AcknowledgeMode acknowledgeMode, ExceptionMode exceptionMode, Func <RabbitMQDelivery, Task> handler)
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            builder.OnDeclaredActions.Add((services) => Task.Run(() =>
            {
                var(contextAccessor, channel, queue) = services.GetContext();

                var startup = services.GetService <LifecycleController>();

                startup.On(
                    LifecycleState.SubscribeQueues,
                    () => channel.Subscribe(new QueueConsumerSubscriber(queue.Name, acknowledgeMode, exceptionMode, new LambdaMessageHandler(handler), contextAccessor))
                    );
            }));

            return(builder);
        }
コード例 #18
0
 /// <summary> Sets up the nth test end-point. </summary>
 ///
 /// <param name="n">The index of the test end-point to set up.</param>
 /// <param name="producer"><tt>true</tt> to set up a producer on the end-point.</param>
 /// <param name="consumer"><tt>true</tt> to set up a consumer on the end-point.</param>
 /// <param name="routingKey">The routing key for the producer to send on.</param>
 /// <param name="ackMode">The ack mode for the end-points channel.</param>
 /// <param name="transacted"><tt>true</tt> to use transactions on the end-points channel.</param>
 /// <param name="exchangeName">The exchange to produce or consume on.</param>
 /// <param name="declareBind"><tt>true</tt> if the consumers queue should be declared and bound, <tt>false</tt> if it has already been.</param>
 /// <param name="durable"><tt>true</tt> to declare the consumers queue as durable.</param>
 /// <param name="subscriptionName">If durable is true, the fixed unique queue name to use.</param>
 public void SetUpEndPoint(int n, bool producer, bool consumer, string routingKey, AcknowledgeMode ackMode, bool transacted,
                           string exchangeName, bool declareBind, bool durable, string subscriptionName)
 {
     SetUpEndPoint(n, producer, consumer, routingKey, ackMode, transacted, exchangeName, declareBind, durable, subscriptionName, true, false);
 }
コード例 #19
0
 public static RabbitMQChannelOptionsBuilder AddRequestReply(this RabbitMQChannelOptionsBuilder builder, AcknowledgeMode acknowledgeMode)
 => builder.AddRequestReply(acknowledgeMode, ExceptionModeAttribute.DefaultMode);
コード例 #20
0
 public static bool IsTransactionAllowed(this AcknowledgeMode mode)
 {
     return(mode == AcknowledgeMode.AUTO || mode == AcknowledgeMode.MANUAL);
 }
コード例 #21
0
        public static RabbitMQChannelOptionsBuilder AddRequestReply(this RabbitMQChannelOptionsBuilder builder, AcknowledgeMode acknowledgeMode, ExceptionMode exceptionMode)
        {
            RequestReplyController controller = null;

            builder
            .DeclareQueue(queueBuilder => queueBuilder
                          .OnDeclare(queue => Task.Run(() => controller = new RequestReplyController(queue.Name)))
                          .Subscribe(acknowledgeMode, exceptionMode, delivery => controller.OnDelivery(delivery))
                          )
            .Map <RequestReplyModel>(model => {
                var context = controller.Request(model.SourceContent);

                model.Context = context;

                return(context.RequestContent);
            });

            return(builder);
        }
コード例 #22
0
        /// <summary> Sets up the nth test end-point. </summary>
        ///
        /// <param name="n">The index of the test end-point to set up.</param>
        /// <param name="producer"><tt>true</tt> to set up a producer on the end-point.</param>
        /// <param name="consumer"><tt>true</tt> to set up a consumer on the end-point.</param>
        /// <param name="routingKey">The routing key for the producer to send on.</param>
        /// <param name="ackMode">The ack mode for the end-points channel.</param>
        /// <param name="transacted"><tt>true</tt> to use transactions on the end-points channel.</param>
        /// <param name="exchangeName">The exchange to produce or consume on.</param>
        /// <param name="declareBind"><tt>true</tt> if the consumers queue should be declared and bound, <tt>false</tt> if it has already been.</param>
        /// <param name="durable"><tt>true</tt> to declare the consumers queue as durable.</param>
        /// <param name="subscriptionName">If durable is true, the fixed unique queue name to use.</param>
        /// <param name="exclusive"><tt>true</tt> declare queue as exclusive.</param>
        /// <param name="browse"><tt>true</tt> only browse, don''t consume.</param>
        public void SetUpEndPoint(int n, bool producer, bool consumer, string routingKey, AcknowledgeMode ackMode, bool transacted,
                                  string exchangeName, bool declareBind, bool durable, string subscriptionName, bool exclusive, bool browse)
        {
            // Allow client id to be fixed, or undefined.
            {
                // Use unique id for end point.
                connectionInfo = QpidConnectionInfo.FromUrl(connectionUri);

                connectionInfo.ClientName = "test" + n;
            }

            testConnection[n] = new AMQConnection(connectionInfo);            
            testConnection[n].Start();
            testChannel[n] = testConnection[n].CreateChannel(transacted, ackMode);
            
            if (producer)
            {
                testProducer[n] = testChannel[n].CreatePublisherBuilder()
                    .WithExchangeName(exchangeName)
                    .WithRoutingKey(routingKey)
                    .Create();
            }

            if (consumer)
            {
                string queueName;

                // Use the subscription name as the queue name if the subscription is durable, otherwise use a generated name.
                if (durable)
                {
                    // The durable queue is declared without auto-delete, and passively, in case it has already been declared.
                    queueName = subscriptionName;
                    
                    if (declareBind)
                    {
                        testChannel[n].DeclareQueue(queueName, durable, exclusive, false);
                        testChannel[n].Bind(queueName, exchangeName, routingKey);
                    }
                }
                else
                {
                    queueName = testChannel[n].GenerateUniqueName();

                    if (declareBind)
                    {
                    	if (durable) 
                    	{
                    		testQueue[n] = queueName;
                    	}
                        testChannel[n].DeclareQueue(queueName, durable, true, true);
                        testChannel[n].Bind(queueName, exchangeName, routingKey);
                    }
                }

                testConsumer[n] = testChannel[n].CreateConsumerBuilder(queueName).WithBrowse(browse).Create();
            }
        }
コード例 #23
0
ファイル: AmqChannel.cs プロジェクト: drzo/opensim4opencog
        /// <summary>
        /// Initializes a new instance of the <see cref="AmqChannel"/> class.
        /// </summary>
        /// <param name="con">The connection.</param>
        /// <param name="channelId">The channel id.</param>
        /// <param name="transacted">if set to <c>true</c> [transacted].</param>
        /// <param name="acknowledgeMode">The acknowledge mode.</param>
        /// <param name="defaultPrefetchHigh">Default prefetch high value</param>
        /// <param name="defaultPrefetchLow">Default prefetch low value</param>
        internal AmqChannel(AMQConnection con, ushort channelId, bool transacted, AcknowledgeMode acknowledgeMode, 
                            int defaultPrefetchHigh, int defaultPrefetchLow)
            : this()
        {
            _sessionNumber = Interlocked.Increment(ref _nextSessionNumber);
            _connection = con;
            _transacted = transacted;
            
            if ( transacted )
            {
                _acknowledgeMode = AcknowledgeMode.SessionTransacted;
            } 
            else
            {
                _acknowledgeMode = acknowledgeMode;
            }

            _channelId = channelId;
            _defaultPrefetchHighMark = defaultPrefetchHigh;
            _defaultPrefetchLowMark = defaultPrefetchLow;

            if ( _acknowledgeMode == AcknowledgeMode.NoAcknowledge )
            {
                _queue = new FlowControlQueue(_defaultPrefetchLowMark, _defaultPrefetchHighMark,
                                              new ThresholdMethod(OnPrefetchLowMark),
                                              new ThresholdMethod(OnPrefetchHighMark));
            } 
            else
            {
                // low and upper are the same
                _queue = new FlowControlQueue(_defaultPrefetchHighMark, _defaultPrefetchHighMark,
                                              null, null);
            }
            DefaultInstance = this;
        }
コード例 #24
0
 public static bool IsManual(this AcknowledgeMode mode)
 {
     return(mode == AcknowledgeMode.MANUAL);
 }
コード例 #25
0
        internal BasicMessageConsumer(ushort channelId, string queueName, bool noLocal,
                                      MessageFactoryRegistry messageFactory, AmqChannel channel,
                                      int prefetchHigh, int prefetchLow, bool exclusive, bool browse)
        {
            _channelId = channelId;
            _queueName = queueName;
            _noLocal = noLocal;
            _messageFactory = messageFactory;
            _channel = channel;
            _acknowledgeMode = _channel.AcknowledgeMode;
            _prefetchHigh = prefetchHigh;
            _prefetchLow = prefetchLow;
            _exclusive = exclusive;
            _browse = browse;

            if (_acknowledgeMode == AcknowledgeMode.SessionTransacted)
            {
                _receivedDeliveryTags = new LinkedList<long>();
            }
        }