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");
}
}
