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