public RMQSubscriberText(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings)
: base(connectionFactory, connectionSettings, exchangeSettings, queueSettings)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQPublisher" /> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="exchangeSettings">The exchange settings.</param>
public RMQPublisher(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings)
: base(connectionFactory, connectionSettings)
{
_exchangeSettings = exchangeSettings;
}
/// <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 RMQPublisherText(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings = null)
: base(connectionFactory, connectionSettings, exchangeSettings, queueSettings)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RMQReceiverSender"/> class.
/// </summary>
/// <param name="connectionFactory">The connection factory.</param>
/// <param name="connectionSettings">The connection settings.</param>
public RMQReceiverSender(IRMQConnectionFactory connectionFactory, RMQConnectionSettings connectionSettings)
{
Disposed = false;
_lastConnectionDateTime = DateTime.MinValue;
_connectionFactory = connectionFactory;
_connectionSettings = connectionSettings;
_channel = null;
}
/// <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 RMQPublisherSubscriber(
IRMQConnectionFactory connectionFactory,
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings,
RMQQueueSettings queueSettings = null)
: base(connectionFactory, connectionSettings)
{
_exchangeSettings = exchangeSettings;
_queueSettings = queueSettings;
}
/// <summary>
/// Creates the connection.
/// </summary>
/// <param name="settings">The settings.</param>
/// <returns></returns>
/// <exception cref="MessageException">
/// There are no acceptable endpoints to connect too.
/// or
/// </exception>
public IConnection CreateConnection(RMQConnectionSettings settings)
{
if (settings.Endpoints.Count == 0)
{
throw new MessageException(MessageExceptionCode.NoAcceptableEndpoints, "There are no acceptable endpoints to connect any RabbitMQ Broker.");
}
var exceptionList = new List <Exception>();
var retries = settings.Endpoints.Count - 1;
while (true)
{
try
{
var connectionFactory = new ConnectionFactory()
{
UserName = settings.Username,
Password = settings.Password,
VirtualHost = settings.VirtualHost,
Protocol = settings.Protocol,
Uri = new Uri(settings.Endpoints[settings.ActiveEndpointIndex]),
};
var connection = connectionFactory.CreateConnection();
return(connection);
}
catch (BrokerUnreachableException ex)
{
exceptionList.Add(new MessageException(MessageExceptionCode.LostConnection, ex.Message, ex));
}
catch (IOException ex)
{
exceptionList.Add(new MessageException(MessageExceptionCode.LostConnection, ex.Message, ex));
}
catch (UriFormatException ex)
{
exceptionList.Add(ex);
}
retries--;
if (retries < 0)
{
var finalException = new AggregateException($"Unable to connect to any RabbitMQ Broker using the following connection uri: {settings.Uri}, for named connection settings: '{settings.Name}'.", exceptionList);
throw new MessageException(MessageExceptionCode.LostConnection, finalException.Message, finalException);
}
settings.ActiveEndpointIndex++;
if (settings.ActiveEndpointIndex >= settings.Endpoints.Count)
{
settings.ActiveEndpointIndex = 0;
}
Thread.Sleep(settings.DelayOnReconnect);
}
}
/// <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="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;
}
// http://zoltanaltfatter.com/2016/09/06/dead-letter-queue-configuration-rabbitmq/
static private RMQConnectionSettings GetRMQConnectionSettings()
{
var connectionSettings = new RMQConnectionSettings
{
Name = "defaultConnection",
Username = "******",
Password = "******",
VirtualHost = "local-dev-vh",
Uri = "amqp://localhost:5673",
DelayOnReconnect = 1000,
ForceReconnectionTime = TimeSpan.FromMinutes(6),
};
// prepare endpoints
foreach (var uri in connectionSettings.Uri.Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
connectionSettings.Endpoints.Add(uri);
}
return(connectionSettings);
}
/// <summary>
/// Gets the connection settings.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public RMQConnectionSettings GetConnectionSettings(string name)
{
var attributes = GetAttributes("connectionSettings", name);
var settings = new RMQConnectionSettings()
{
Protocol = Protocols.DefaultProtocol,
Name = StringHelper.IfNullOrEmptyUseDefault(attributes["name"], string.Empty),
Username = StringHelper.IfNullOrEmptyUseDefault(attributes["username"], string.Empty),
Password = StringHelper.IfNullOrEmptyUseDefault(attributes["password"], string.Empty),
VirtualHost = StringHelper.IfNullOrEmptyUseDefault(attributes["virtualhost"], string.Empty),
DelayOnReconnect = int.Parse(StringHelper.IfNullOrEmptyUseDefault(attributes["delayOnReconnect"], "1000")),
Uri = StringHelper.IfNullOrEmptyUseDefault(attributes["uri"], "amqp://localhost:5672"),
ForceReconnectionTime = TimeSpan.FromMinutes(int.Parse(StringHelper.IfNullOrEmptyUseDefault(attributes["forceReconnectionTime"], "0")))
};
foreach (var uri in settings.Uri.Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
settings.Endpoints.Add(uri);
}
return(settings);
}
/// <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);
}
}
}
/// <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 byte.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="exchangeSettings">The exchange settings.</param>
/// <returns></returns>
public IRMQPublisherBytes CreateBytes(
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings)
{
return(new RMQPublisherByte(_connectionFactory, connectionSettings, exchangeSettings));
}
/// <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 specified connection.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connection">The connection.</param>
/// <param name="exchange">The exchange.</param>
/// <returns></returns>
public T Create <T>(RMQConnectionSettings connection, RMQExchangeSettings exchange) where T : IMessageReceiverSender
{
return((T)Create(typeof(T), connection, exchange));
}
/// <summary>
/// Creates the text.
/// </summary>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="exchangeSettings">The exchange settings.</param>
/// <returns></returns>
public IRMQPublisherText CreateText(
RMQConnectionSettings connectionSettings,
RMQExchangeSettings exchangeSettings)
{
return(new RMQPublisherText(_connectionFactory, connectionSettings, exchangeSettings));
}
public Connector(ILogger <Connector> logger, RMQConnectionSettings connectionSettings)
{
this._logger = logger;
this._connectionSettings = connectionSettings;
}
