/// <summary>
/// Initializes a new instance of the <see cref="RMQProducerByte"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The queue settings.</param>
public RMQProducerByte(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings, queueSettings)
{
}
// http://zoltanaltfatter.com/2016/09/06/dead-letter-queue-configuration-rabbitmq/
static RMQConfigurationManager CreateConfigurationManager()
{
var connectionSettings = new RMQConnectionSettings
{
Name = "connection",
Username = "******",
Password = "******",
VirtualHost = "/",
Uri = "amqp://host.docker.internal:5672",
DelayOnReconnect = 2000,
};
var queueSettings = new RMQQueueSettings("MY_RMQ_TEST", "MY_RMQ_TEST")
{
Durable = true,
AutoDelete = false,
Persistent = true,
Exclusive = false,
Arguments = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", "" },
{ "x-dead-letter-routing-key", "DLQ_MY_RMQ_TEST" }
}
};
return(new RMQConfigurationManager(new[] { connectionSettings }, queueSettings: new[] { queueSettings }));
}
/// <summary>
/// Creates the byte.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="exchangeSettings">The exchange settings.</param>
/// <param name="queueSettings">The queue settings.</param>
/// <returns></returns>
public IRMQPublisherByte CreateByte(
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings)
{
return(new RMQPublisherByte(_connectionFactory, connectionSettings, exchangeSettings, queueSettings));
}
/// <summary>
/// Creates the text.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="exchangeSettings">The exchange settings.</param>
/// <param name="queueSettings">The queue settings.</param>
/// <returns></returns>
public IRMQConsumerText CreateText(
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings)
{
return(new RMQSubscriberText(_connectionFactory, connectionSettings, exchangeSettings, queueSettings));
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQConsumerText" /> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The queue settings.</param>
public RMQConsumerText(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings, queueSettings)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQQueue"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The queue settings.</param>
public RMQQueue(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings)
{
_queueSettings = queueSettings;
}
public RMQSubscriberText(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings, exchangeSettings, queueSettings)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQConsumer"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The queue settings.</param>
public RMQConsumer(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings, queueSettings)
{
Mode = ConsumerMode.OnNoMessage_Timeout;
}
public RMQPublisherText(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings = null)
: base(connectionFactory, connectionSettings, exchangeSettings, queueSettings)
{
}
public RMQPublisherSubscriber(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings = null)
: base(connectionFactory, connectionSettings)
{
_exchangeSettings = exchangeSettings;
_queueSettings = queueSettings;
}
/// <summary>
/// Gets the queue settings.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="arguments">The arguments.</param>
/// <returns></returns>
public RMQQueueSettings GetQueueSettings(string name, IDictionary <string, object> arguments = null)
{
var attributes = GetAttributes("queue", name);
var routingKeys = new List <string>();
var queueSettings = new RMQQueueSettings(name)
{
QueueName = StringHelper.IfNullOrEmptyUseDefault(attributes["QueueName"], name),
Exclusive = StringHelper.IfNullOrEmptyUseDefault(attributes["exclusive"], "true") == "true",
Durable = StringHelper.IfNullOrEmptyUseDefault(attributes["durable"], "true") == "true",
AutoDelete = StringHelper.IfNullOrEmptyUseDefault(attributes["autoDelete"], "false") == "true",
Persistent = StringHelper.IfNullOrEmptyUseDefault(attributes["persistent"], "true") == "true",
RoutingKeys = routingKeys,
Arguments = arguments ?? new Dictionary <string, object>()
};
var sRoutingKeys = StringHelper.IfNullOrEmptyUseDefault(attributes["routingKeys"], string.Empty);
foreach (var routingKey in sRoutingKeys.Split(new char[] { ',' }))
{
routingKeys.Add(routingKey.Trim());
}
if (_configNode != null)
{
// get arguments if they exist
var argsNode = _configNode.GetConfigNode($"./queue[@name='{name}']/arguments");
if (argsNode != null)
{
attributes = argsNode.GetAttributes();
foreach (var key in attributes.AllKeys)
{
if (!queueSettings.Arguments.ContainsKey(key))
{
queueSettings.Arguments[key] = attributes[key];
}
}
}
// get consumer info if it exists
var consumerNode = _configNode.GetConfigNode($"./queue[@name='{name}']/consumer");
if (consumerNode != null)
{
attributes = consumerNode.GetAttributes();
queueSettings.ConsumerSettings.Tag = StringHelper.IfNullOrEmptyUseDefault(attributes["tag"], Guid.NewGuid().ToString());
queueSettings.ConsumerSettings.Exclusive = StringHelper.IfNullOrEmptyUseDefault(attributes["exclusive"], "true") == "true";
queueSettings.ConsumerSettings.NoAck = StringHelper.IfNullOrEmptyUseDefault(attributes["noAck"], "true") == "true";
queueSettings.ConsumerSettings.NoLocal = StringHelper.IfNullOrEmptyUseDefault(attributes["noLocal"], "true") == "true";
}
}
return(queueSettings);
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQObjectPoolAsync"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="instanceType">Type of the instance.</param>
/// <param name="connection">The connection.</param>
/// <param name="destination">The destination.</param>
/// <param name="exchange">The exchange.</param>
/// <param name="maxGrowSize">Maximum size of the grow.</param>
public RMQObjectPoolAsync(
IRMQSenderReceiverFactory factory,
Type instanceType,
RMQConnectionSettings connection,
RMQQueueSettings destination,
RMQExchangeSettings exchange,
int maxGrowSize) : base(0, maxGrowSize)
{
_factory = factory;
_instanceType = instanceType;
_connection = connection;
_destination = destination;
_exchange = exchange;
}
static private Task ProducerAsync()
{
var args = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", "" },
{ "x-dead-letter-routing-key", "My.DLQ" }
};
var procuderFactory = new RMQProducerFactory(new RMQConnectionFactory());
var connectionSettings = GetRMQConnectionSettings();
var queueSettings = new RMQQueueSettings("My.Queue", "My.Queue", true, false, false, true, arguments: args);
using (var producer = procuderFactory.CreateText(connectionSettings, queueSettings))
{
producer.Send("test1");
producer.Send("test2");
producer.Send("test3");
producer.Send("test4");
}
return(Task.CompletedTask);
}
/// <summary>
/// Creates the specified connection settings.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection">The connection settings.</param>
/// <param name="destination">The destination settings.</param>
/// <returns></returns>
public T Create <T>(RMQConnectionSettings connection, RMQQueueSettings destination) where T : IMessageReceiverSender
{
return((T)Create(typeof(T), connection, destination));
}
/// <summary>
/// Creates the text.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The queue settings.</param>
/// <returns></returns>
public IRMQProducerText CreateText(RMQConnectionSettings connectionSettings, RMQQueueSettings queueSettings)
{
return(new RMQProducerText(_connectionFactory, connectionSettings, queueSettings));
}
/// <summary>
/// Creates the byte.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="queueSettings">The settings.</param>
/// <returns></returns>
public IRMQProducerBytes CreateBytes(RMQConnectionSettings connectionSettings, RMQQueueSettings queueSettings)
{
return(new RMQProducerByte(_connectionFactory, connectionSettings, queueSettings));
}
/// <summary>
/// Creates the specified type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="connection">The connection settings.</param>
/// <param name="destination">The destination settings.</param>
/// <returns></returns>
/// <exception cref="KeyNotFoundException"></exception>
public IMessageReceiverSender Create(Type type, RMQConnectionSettings connection, RMQQueueSettings destination)
{
if (!_invokers.ContainsKey(type))
{
throw new KeyNotFoundException($"The following type: '{type.Name}' is not supported.");
}
var invoker = _invokers[type];
return(invoker(connection, destination));
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQConfigurationManager"/> class.
/// </summary>
/// <param name="configPath">The configuration path.</param>
public RMQConfigurationManager(string configPath = null)
{
Settings = new RMQConfigSettings();
if (configPath == null)
{
var xmlFile = $"{AppDomain.CurrentDomain.BaseDirectory}RMQSettings.config";
var jsonFile = $"{AppDomain.CurrentDomain.BaseDirectory}RMQSettings.json";
if (File.Exists(xmlFile))
{
configPath = xmlFile;
}
else if (File.Exists(jsonFile))
{
configPath = jsonFile;
}
}
if (configPath != null)
{
if (Path.GetExtension(configPath).ToLower() == ".json")
{
var json = File.ReadAllText(configPath);
Settings = JsonConvert.DeserializeObject <RMQConfigSettings>(json);
}
else // XML legacy
{
using (var configContainer = new ConfigContainer(configPath, "./rmqSettings"))
{
var configNode = configContainer.Node;
var settingNodes = configNode.GetConfigNode($"./connectionSettings");
if (settingNodes != null)
{
foreach (var settingNode in settingNodes.GetConfigNodes("."))
{
var connectionSettings = new RMQConnectionSettings();
Settings.Connections.Add(connectionSettings);
connectionSettings.Name = settingNode.GetAttribute(".", "name", "");
connectionSettings.Username = settingNode.GetAttribute(".", "username", "");
connectionSettings.Password = settingNode.GetAttribute(".", "password", "");
connectionSettings.VirtualHost = settingNode.GetAttribute(".", "virtualhost", "/");
connectionSettings.Uri = settingNode.GetAttribute(".", "uri", "amqp://*****:*****@name='{exchangeSettings.Name}']/arguments");
if (argsNode != null)
{
var attributes = argsNode.GetAttributes();
foreach (var key in attributes.AllKeys)
{
exchangeSettings.Arguments[key] = attributes[key];
}
}
}
}
var queueNodes = configNode.GetConfigNode($"./queue");
if (queueNodes != null)
{
foreach (var queueNode in queueNodes.GetConfigNodes("."))
{
var queueSettings = new RMQQueueSettings(queueNode.GetAttribute(".", "name", ""));
Settings.Queues.Add(queueSettings);
queueSettings.QueueName = queueNode.GetAttribute(".", "queueName", "");
queueSettings.Durable = queueNode.GetAttribute(".", "durable", "true") == "true";
queueSettings.Exclusive = queueNode.GetAttribute(".", "exclusive", "false") == "true";
queueSettings.AutoDelete = queueNode.GetAttribute(".", "autoDelete", "false") == "true";
queueSettings.Persistent = queueNode.GetAttribute(".", "persistent", "true") == "true";
var routingKeys = queueNode.GetAttribute(".", "routingKeys", "");
foreach (var key in routingKeys.Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
queueSettings.RoutingKeys.Add(key);
}
var argsNode = configNode.GetConfigNode($"./queue[@name='{queueSettings.Name}']/arguments");
if (argsNode != null)
{
var attributes = argsNode.GetAttributes();
foreach (var key in attributes.AllKeys)
{
queueSettings.Arguments[key] = attributes[key];
}
}
// get consumer info if it exists
var consumerNode = configNode.GetConfigNode($"./queue[@name='{queueSettings.Name}']/consumer");
if (consumerNode != null)
{
queueSettings.ConsumerSettings.Tag = queueNode.GetAttribute(".", "tag", Guid.NewGuid().ToString());
queueSettings.ConsumerSettings.Exclusive = queueNode.GetAttribute(".", "exclusive", "false") == "true";
queueSettings.ConsumerSettings.NoAck = queueNode.GetAttribute(".", "noAck", "true") == "true";
queueSettings.ConsumerSettings.NoLocal = queueNode.GetAttribute(".", "noLocal", "true") == "true";
}
}
}
}
}
}
foreach (var connection in Settings.Connections)
{
foreach (var uri in connection.Uri.Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
connection.Endpoints.Add(uri);
}
}
}
static private Task ConsumerAsync()
{
var args = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", "" },
{ "x-dead-letter-routing-key", "My.DLQ" }
};
var consumerFactory = new RMQConsumerFactory(new RMQConnectionFactory());
var connectionSettings = GetRMQConnectionSettings();
var queueSettings = new RMQQueueSettings("My.Queue", "My.Queue", true, false, false, true, arguments: args);
using (var consumer = consumerFactory.CreateText(connectionSettings, queueSettings))
{
consumer.Mode = ConsumerMode.OnNoMessage_ReturnNull;
while (true)
{
try
{
try
{
var message = consumer.Receive(1000);
if (message != null)
{
//message.Reject(true);
//message.Reject();
message.Acknowledge();
}
}
catch (TimeoutException)
{
}
catch (MessageException ex)
{
switch (ex.ExceptionCode)
{
case MessageExceptionCode.ExclusiveLock:
//await Task.Delay(5000);
break;
case MessageExceptionCode.LostConnection:
//await Task.Delay(5000);
throw;
default:
throw;
}
}
catch (SqlException ex)
{
if (SQLErrors.IsSevereErrorCode(ex.Number))
{
// issue connecting with SQL server
//await Task.Delay(5000);
}
throw;
}
}
catch (Exception ex)
{
consumer.ClearCacheBuffer();
Console.WriteLine(ex);
}
}
}
}
