public void CreateQueue(string name) { InitializeChannel(); Channel.ExchangeDeclare(name, ExchangeType.Direct, true, false, null); QueueDeclareOk queue = Channel.QueueDeclare(name, true, false, false, null); if (queue == null) { throw new InvalidOperationException($"Creating \"{name}\" queue failed."); } Channel.QueueBind(name, name, string.Empty, null); }
public void TestDeclarationOfManyAutoDeleteExchangesWithTransientQueuesThatAreUnbound() { AssertRecordedExchanges((AutorecoveringConnection)Conn, 0); for (int i = 0; i < 1000; i++) { string x = Guid.NewGuid().ToString(); Model.ExchangeDeclare(x, "fanout", false, true, null); QueueDeclareOk q = Model.QueueDeclare(); Model.QueueBind(q, x, ""); Model.QueueUnbind(q, x, "", null); } AssertRecordedExchanges((AutorecoveringConnection)Conn, 0); }
internal void AssertQueueRecovery(IModel m, string q, bool exclusive) { m.ConfirmSelect(); m.QueueDeclarePassive(q); QueueDeclareOk ok1 = m.QueueDeclare(q, false, exclusive, false, null); Assert.AreEqual(ok1.MessageCount, 0); m.BasicPublish("", q, null, encoding.GetBytes("")); Assert.IsTrue(WaitForConfirms(m)); QueueDeclareOk ok2 = m.QueueDeclare(q, false, exclusive, false, null); Assert.AreEqual(ok2.MessageCount, 1); }
public RabbitQueue(IModel model, IRabbitSerializer serializer, QueueDeclareOk result, QueueOptions queueOptions) { _model = model; _defaultSerializer = serializer ?? queueOptions.Serializer; _queueOptions = queueOptions; this.Name = result.QueueName; this.ConsumerCount = result.ConsumerCount; this.MessageCount = result.MessageCount; }
async Task DeclareAndBindQueue(ModelContext context) { QueueDeclareOk queueOk = await context.QueueDeclare(_settings.QueueName, _settings.Durable, false, _settings.AutoDelete, _settings.QueueArguments).ConfigureAwait(false); string queueName = queueOk.QueueName; await context.QueueBind(queueName, _settings.ExchangeName, "", new Dictionary <string, object>()).ConfigureAwait(false); if (_log.IsDebugEnabled) { _log.DebugFormat("Exchange:Queue Binding: {0} ({1})", _settings.ExchangeName, queueName); } }
public void CreateConsumer(string routingKey, string exchangeName) { QueueDeclareOk queue = _model.QueueDeclare(); var consumer = new EventingBasicConsumer(_model); consumer.Received += (_, msg) => { MessageReceived(this, CreateMessage(msg)); _model.BasicAck(msg.DeliveryTag, false); }; _model.QueueBind(queue.QueueName, exchangeName, routingKey); _model.BasicConsume(queue.QueueName, false, consumer); }
public void DeserializationReturnsSurplusData() { var value = RandomSubject; var extra = Random.UInt(); var buffer = new ArrayBufferWriter <Byte>(); buffer.WriteSerializable(value) .WriteUInt32LE(extra); QueueDeclareOk.Deserialize(buffer.WrittenMemory.Span, out var _, out var surplus); Assert.Equal(expected: sizeof(UInt32), actual: surplus.Length); Assert.Equal(expected: extra, actual: BitConverter.ToUInt32(surplus)); }
public RabbitMQMessageSender(string queueName, ConnectionFactory connectionFactory) { QueueName = queueName; _factory = connectionFactory; _conn = _factory.CreateConnection(); _client = _conn.CreateModel(); QueueDeclareOk dec = _client.QueueDeclare(queue: QueueName, durable: false, exclusive: false, autoDelete: false, arguments: null); }
async Task PurgeIfRequested(ModelContext context, QueueDeclareOk queueOk, string queueName) { if (!_queueAlreadyPurged) { var purgedMessageCount = await context.QueuePurge(queueName).ConfigureAwait(false); LogContext.Debug?.Log("Purged {MessageCount} messages from queue {QueueName}", purgedMessageCount, queueName); _queueAlreadyPurged = true; } else { LogContext.Debug?.Log("Queue {QueueName} was purged at startup, skipping", queueName); } }
private void TestSubscriptionAction(Action <Subscription> action) { Model.BasicQos(0, 1, false); string queueDeclare = Model.QueueDeclare(); var subscription = new Subscription(Model, queueDeclare, false); Model.BasicPublish("", queueDeclare, null, encoding.GetBytes("a message")); BasicDeliverEventArgs res = subscription.Next(); Assert.IsNotNull(res); action(subscription); QueueDeclareOk ok = Model.QueueDeclarePassive(queueDeclare); Assert.AreEqual(0, ok.MessageCount); }
private void TestSubscriptionAction(SubscriptionAction action) { Model.BasicQos(0, 1, false); string q = Model.QueueDeclare(); Subscription sub = new Subscription(Model, q, false); Model.BasicPublish("", q, null, enc.GetBytes("a message")); BasicDeliverEventArgs res = sub.Next(); Assert.IsNotNull(res); action(sub); QueueDeclareOk ok = Model.QueueDeclarePassive(q); Assert.AreEqual(0, ok.MessageCount); }
private void btnNumberMss_Click(object sender, EventArgs e) { try { RabbitMQServer rabbitMQServer = RabbitMQManager.GetRabbitMQServer("rabbitMQKeywordSuggest"); IModel model = rabbitMQServer.CreateChannel(); QueueDeclareOk result = model.QueueDeclare("UpdateKeywordBatch.FindSuggest", true, false, false, null); uint count = result.MessageCount; rabbitMQServer.CloseChannel(model); MessageBox.Show(count.ToString()); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } }
public void CreateInfrastructure() { ConnectionFactory factory = new ConnectionFactory() { HostName = _hostname }; IConnection connection = factory.CreateConnection(); _channel = connection.CreateModel(); _channel.ExchangeDeclare(_exchangeName, "fanout", true, false); QueueDeclareOk queue = _channel.QueueDeclare(_queueName, true, false, false); _channel.QueueBind(_queueName, _exchangeName, ""); }
public QueueDeclareOk QueueDeclare(string queue, bool durable, bool exclusive, bool autoDelete, IDictionary <string, object> arguments) { QueueDeclareOk result = _delegate.QueueDeclare(queue, durable, exclusive, autoDelete, arguments); RecordedQueue rq = new RecordedQueue(this, result.QueueName). Durable(durable). Exclusive(exclusive). AutoDelete(autoDelete). Arguments(arguments). ServerNamed(string.Empty.Equals(queue)); _connection.RecordQueue(result.QueueName, rq); return(result); }
public RabbitMQMessageReceiver(string queueName, ConnectionFactory connectionFactory, ushort preFetch = 10) { QueueName = queueName; _factory = connectionFactory; _conn = _factory.CreateConnection(); _client = _conn.CreateModel(); _client.BasicQos(0, preFetch, false); QueueDeclareOk dec = _client.QueueDeclare(queue: QueueName, durable: false, exclusive: false, autoDelete: false, arguments: null); }
/// <summary> /// 主要用在exchangetype是fanout模式下面调用本方法,Queue的Name是RabbitMQ会随机为我们分配这个名字。 /// </summary> /// <param name="exchange"></param> /// <returns></returns> public IQueue QueueDeclare(IExchange exchange) { Preconditions.CheckNotNull(exchange, "exchange"); var task = this._clientCommandDispatcher.Invoke(x => x.QueueDeclare()); task.Wait(); QueueDeclareOk queueDeclareOk = task.Result; string queueName = queueDeclareOk.QueueName;//Queue的Name是RabbitMQ会随机为我们分配这个名字。 ConsoleLogger.DebugWrite("Declared Server Generted Queue '{0}'", queueName); ConsoleLogger.DebugWrite("Declared Queue: '{0}' ,Exchange Name : '{1}' ,Exchange Type : '{2}'", queueName, exchange.Name, exchange.Type); return(new Queue(queueName, true)); }
async Task IFilter <ModelContext> .Send(ModelContext context, IPipe <ModelContext> next) { await context.BasicQos(0, _settings.PrefetchCount, false); QueueDeclareOk queueOk = await context.QueueDeclare(_settings.QueueName, _settings.Durable, _settings.Exclusive, _settings.AutoDelete, _settings.QueueArguments); string queueName = queueOk.QueueName; if (_log.IsDebugEnabled) { _log.DebugFormat("Queue: {0} ({1})", queueName, string.Join(", ", new[] { _settings.Durable ? "durable" : "", _settings.Exclusive ? "exclusive" : "", _settings.AutoDelete ? "auto-delete" : "" }.Where(x => !string.IsNullOrWhiteSpace(x)))); } if (_settings.PurgeOnStartup) { await PurgeIfRequested(context, queueOk, queueName); } string exchangeName = _settings.ExchangeName ?? queueName; if (!string.IsNullOrWhiteSpace(_settings.ExchangeName) || string.IsNullOrWhiteSpace(_settings.QueueName)) { await context.ExchangeDeclare(exchangeName, _settings.ExchangeType, _settings.Durable, _settings.AutoDelete, _settings.ExchangeArguments); await context.QueueBind(queueName, exchangeName, "", new Dictionary <string, object>()); } await ApplyExchangeBindings(context, exchangeName); ReceiveSettings settings = new RabbitMqReceiveSettings(_settings) { QueueName = queueName, ExchangeName = exchangeName }; context.GetOrAddPayload(() => settings); await next.Send(context); }
public RabbitMQListenerTests() { _mockExecutor = new Mock <ITriggeredFunctionExecutor>(); _mockService = new Mock <IRabbitMQService>(); _mockLogger = new Mock <ILogger>(); _mockModel = new Mock <IRabbitMQModel>(); _mockDescriptor = new Mock <FunctionDescriptor>(); _mockService.Setup(m => m.RabbitMQModel).Returns(_mockModel.Object); QueueDeclareOk queueInfo = new QueueDeclareOk("blah", 5, 1); _mockModel.Setup(m => m.QueueDeclarePassive(It.IsAny <string>())).Returns(queueInfo); _testListener = new RabbitMQListener(_mockExecutor.Object, _mockService.Object, "blah", _mockLogger.Object, new FunctionDescriptor { Id = "TestFunction" }, 30); }
private void PublishLocal(string message, string queue) { var factory = new ConnectionFactory { HostName = settings["host"], Port = Convert.ToInt32(settings["port"]) }; using var connection = factory.CreateConnection(); using var model = connection.CreateModel(); QueueDeclareOk ok = model.QueueDeclare(queue, true, false, false, null); byte[] bodyBytes = Encoding.UTF8.GetBytes(message); model.BasicPublish(string.Empty, queue, null, bodyBytes); }
public void NonAsyncConsumerShouldThrowInvalidOperationException() { var cf = new ConnectionFactory { DispatchConsumersAsync = true }; using (IConnection c = cf.CreateConnection()) using (IModel m = c.CreateModel()) { QueueDeclareOk q = m.QueueDeclare(); IBasicProperties bp = m.CreateBasicProperties(); byte[] body = System.Text.Encoding.UTF8.GetBytes("async-hi"); m.BasicPublish("", q.QueueName, bp, body); var consumer = new EventingBasicConsumer(m); Assert.Throws <InvalidOperationException>(() => m.BasicConsume(q.QueueName, false, consumer)); } }
public QueueStatusDto GetQueueStatus(RabbitMQConnectionConfig connectionConfig, RabbitMQQueueConfig queue, RabbitMQExchangeConfig exchange, string routingKey) { this.ValidateRules(connectionConfig, queue, exchange); QueueStatusDto result; ConnectionFactory factory = this.CreateConnectionFactory(connectionConfig); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { QueueDeclareOk queueDeclare = channel.QueueDeclarePassive(queue.Name); result = new QueueStatusDto(queueDeclare.QueueName, (int)queueDeclare.MessageCount, (int)queueDeclare.ConsumerCount); } return(result); }
public QueueConnection(QueueConnector Connector) { CF = new ConnectionFactory { HostName = Connector.HostName }; Connection = CF.CreateConnection(); Channel = Connection.CreateModel(); QueueDeclaration = Channel.QueueDeclare ( queue: Connector.QueueName, durable: false, exclusive: false, autoDelete: false ); this.Connector = Connector; }
/////////////////////////////////////////////////////////////////////// // RabbitMQ Methods // /////////////////////////////////////////////////////////////////////// /// <summary> /// This method creates a connection with RabbitMQ queue /// </summary> /// <param name="rabbitMQHost">IP used by RabbitMQ (Without port number)</param> /// <param name="queueName"></param> /// <param name="maxNumberOfMessages">The maximum number of messages that will be received from RabbitMQ</param> /// <param name="errorMessage"></param> /// <returns></returns> private bool OpenRabbitQueue(string queueName, int maxnumberofMessages, RabbitMQParameters parameters, int messageTTL = 1209600000) { bool result = false; if (parameters != null) { PersistMessage = parameters.Persistent; RabbitHost = parameters.RabbitMQHost; RabbitBatchValue = Convert.ToUInt16(maxnumberofMessages); RabbitQueueName = queueName; RabbitUserName = parameters.UserName; RabbitPassword = parameters.Password; ConnectionFactory factory = new ConnectionFactory(); factory.HostName = RabbitHost; factory.UserName = parameters.UserName; factory.Password = parameters.Password; RabbitConnection = factory.CreateConnection(parameters.ConnectionName); RabbitChannel = RabbitConnection.CreateModel(); Dictionary <string, object> args = new Dictionary <string, object>(); args.Add("x-message-ttl", messageTTL); try { if (!String.IsNullOrWhiteSpace(RabbitQueueName)) { // Check queue exists QueueDeclareOk resultado = RabbitChannel.QueueDeclarePassive(queueName); result = true; } } catch (Exception ex) { ErrorCode = e_Exception; ErrorMessage = "Queue '" + RabbitQueueName + "' not found::" + ex.Message; RabbitDispose(); } } return(result); }
public static void PushCmp() { var server = RabbitMQManager.GetRabbitMQServer(ConfigCrawler.KeyRabbitMqCrawler); var sqldb = new SqlDb(ConfigCrawler.ConnectProduct); var tupleSetup = new List <Tuple <string, string> >() { new Tuple <string, string>("00", "Vip.Cmp.Crl.Fn"), new Tuple <string, string>("10", "Vip.Cmp.Crl.Rl"), new Tuple <string, string>("01", "Normal.Cmp.Crl.Fn"), new Tuple <string, string>("11", "Normal.Cmp.Crl.Rl"), }; foreach (var tuple in tupleSetup) { Log.Info(string.Format("Push to {0} {1}", tuple.Item1, tuple.Item2)); var producer = new ProducerBasic(server, tuple.Item2); var chanl = server.CreateChannel(); QueueDeclareOk dcl = chanl.QueueDeclare(tuple.Item2, true, false, false, null); if (dcl.MessageCount < 1) { var tblCmpFn = sqldb.GetTblData("[prc_Company_GetCmpToPushCrl]", CommandType.StoredProcedure, new[] { SqlDb.CreateParamteterSQL("@TypeCrl", tuple.Item1, SqlDbType.VarChar) }); foreach (DataRow variable in tblCmpFn.Rows) { long companyId = Common.Obj2Int64(variable["ID"]); if (!RedisCompanyWaitCrawler.CheckRunningCrawler(companyId)) { producer.PublishString(new JobCompanyCrawler() { CheckRunning = true, CompanyId = companyId }.GetJSon()); Log.Info(string.Format("Pushed for cmp: {0}", companyId)); } else { Log.Info("Not push because running"); } } } } return; }
/// <summary> /// 触发消费行为 /// </summary> /// <param name="queue">队列名称</param> /// <param name="callback">回调方法</param> public void Subscribe <TMessage>(string exchange, string queue, Action <TMessage> callback = null) { if (!string.IsNullOrWhiteSpace(exchange)) { exchangeName = exchange; } // 使用自定义的队队 if (!string.IsNullOrWhiteSpace(queue)) { queueName = queue; } if (!string.IsNullOrWhiteSpace(queueName)) //分发模式 { channel.ExchangeDeclare(exchangeName, "topic"); //广播 channel.QueueDeclare( queue: queueName, durable: false, //持久化 exclusive: false, //独占,只能被一个consumer使用 autoDelete: false, //自己删除,在最后一个consumer完成后删除它 arguments: null); channel.QueueBind(queueName, exchangeName, queueName); } else { //广播模式 channel.ExchangeDeclare(this.exchangeName, "fanout"); //广播 QueueDeclareOk queueOk = channel.QueueDeclare(); //每当Consumer连接时,我们需要一个新的,空的queue,如果在声明queue时不指定,那么RabbitMQ会随机为我们选择这个名字 queueName = queueOk.QueueName; //得到RabbitMQ帮我们取了名字 channel.QueueBind(queueName, exchangeName, string.Empty); //不需要指定routing key,设置了fanout,指了也没有用. } var consumer = new EventingBasicConsumer(channel); consumer.Received += (sender, e) => { var body = e.Body; var json = Encoding.UTF8.GetString(body.ToArray()); callback(SerializeMemoryHelper.JsonDeserialize <TMessage>(json)); channel.BasicAck(e.DeliveryTag, multiple: false); }; channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer); queueName = null; Console.WriteLine(" [*] Waiting for messages." + "To exit press CTRL+C"); }
/// <summary> /// Consumes only log message with info & warning severity /// </summary> static void ConsumeLog() { var connectionFactory = new ConnectionFactory(); using (IConnection connection = connectionFactory.CreateConnection()) using (IModel channel = connection.CreateModel()) { QueueDeclareOk queue = channel.QueueDeclare(); channel.QueueBind(queue: queue.QueueName, exchange: "direct_logs", routingKey: "info"); channel.QueueBind(queue: queue.QueueName, exchange: "direct_logs", routingKey: "warning"); var eventingBasicConsumer = new EventingBasicConsumer(channel); eventingBasicConsumer.Received += (publisher, message) => { string data = Encoding.UTF8.GetString(message.Body); if (message.RoutingKey == "info") { Console.ForegroundColor = ConsoleColor.Green; } else if (message.RoutingKey == "warning") { Console.ForegroundColor = ConsoleColor.Yellow; } Console.WriteLine(data); Console.ForegroundColor = ConsoleColor.White; }; channel.BasicConsume(queue.QueueName, autoAck: true, eventingBasicConsumer); Console.WriteLine("Press enter to exit"); Console.Read(); } }
/// <summary> /// 构造函数 /// </summary> /// <param name="configuration"></param> public RabbitMQSynchronizedCache(IConfiguration configuration) { string connectionStringName = configuration.GetSection("Cache:RabbitMQSynchronizedCacheConfig")["ConnectionStringName"]; if (string.IsNullOrEmpty(connectionStringName)) { connectionStringName = configuration.GetSection("RabbitMQConfiguration")["DefaultConnectionString"] ?? "default"; } string connectionString = configuration.GetSection($"RabbitMQConfiguration:ConnectionStrings:{connectionStringName}")["ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { throw new ArgumentNullException("connectionString", "Construt RabbitMQSynchronizedCache instance error.RabbitMQ conncetion string is null or empty."); } string partialQueueName = configuration.GetSection($"Cache:RabbitMQSynchronizedCacheConfig")["QueueName"]; //string queuePartialName = configuration.GetSection("Cache:RabbitMQSynchronizedCacheConfig")["QueuePartialName"]; //string queueName = $"{exchangeName}.{ queuePartialName}"; string queueName = $"{exchangeName}.{partialQueueName}.{guid}"; var factory = new ConnectionFactory(); factory.Uri = new Uri(connectionString); queueConnection = factory.CreateConnection(); channel = queueConnection.CreateModel(); channel.ExchangeDeclare(exchange: exchangeName, type: "direct", durable: true); QueueDeclareOk queueDeclareOk = channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: true, arguments: null); channel.QueueBind(queue: queueDeclareOk.QueueName, exchange: exchangeName, routingKey: cacheRemoveRoutingName, arguments: null); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += Consumer_Received; channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer); memoryCache = new MemoryCache(); List <IConfigurationSection> keyMapSections = configuration.GetSection("Cache:RabbitMQSynchronizedCacheConfig:KeyMap").GetChildren().ToList(); if (keyMapSections != null) { foreach (IConfigurationSection keyMapSection in keyMapSections) { keyMapDictionary.Add(keyMapSection.Key, keyMapSection.Value); } } }
public RabbitListener(ConnectionFactory factory, string exchangeName, string routingKey, Action <TMessage> onMessage) { _connection = factory.CreateConnection(); _channel = _connection.CreateModel(); _exchangeName = exchangeName; _routingKey = routingKey; _onMessage = onMessage; _channel.ExchangeDeclare(exchangeName, ExchangeType.Topic, true, false, null); _consumer = new EventingBasicConsumer(_channel); _consumer.Received += OnReceived; _queueName = _channel.QueueDeclare(); _channel.QueueBind(_queueName, _exchangeName, _routingKey); _channel.BasicConsume(_queueName, false, _consumer); }
private void InitChannel() { Channel?.Dispose(); Channel = Connection.CreateModel(); Channel.ExchangeDeclare(exchange: "foodapp", type: ExchangeType.Topic, true); _queue = Channel.QueueDeclare(queue: typeof(T).Name, durable: false, exclusive: false, autoDelete: false, arguments: null); Channel.QueueBind(_queue.QueueName, "foodApp", "", null); Channel.CallbackException += (sender, ea) => { InitChannel(); InitSubscription(); }; }
public void countMessage(object obj) { lock (_syncRoot) { Dictionary <string, object> args = new Dictionary <string, object>() { { "x-queue-mode", "lazy" } //count message }; QueueDeclareOk result = govChannel.QueueDeclare(queue: "gov.track0", durable: true, exclusive: false, autoDelete: false, arguments: args); uint count = result.MessageCount; Console.WriteLine("count message: " + count); WriteAppendLog(count.ToString(), "D:\\count.txt"); } }