public void Dispose() { _channel?.Dispose(); _channel = null; _connection?.Dispose(); _connection = null; }
private IConnection CreateConnection(RabbitMQ.Client.IConnection connection, IModel outboundModel) { var builder = new ConsumedMessageBuilder(_configuration.SerializationConfiguration, _configuration.MessageTypeResolver); var outboundChannel = _configuration.OutboundChannelBuilder(outboundModel, _configuration); var consumers = _promises.Select(_ => { var model = CreateInboundModel(connection, _configuration.PrefetchSize, _configuration.PrefetchCount); var consumer = _(builder).BuildConsumer(new InboundChannel(model), outboundChannel); return(new { Model = model, Consumer = consumer }); }) .ToList(); foreach (var consumer in consumers) { consumer.Consumer.Declare(consumer.Model); } return(new Connection(connection, consumers.Select(_ => _.Consumer), outboundChannel, _configuration)); }
public Task Close() { if (!taskQueue.IsValueCreated) { return(Task.CompletedTask); } return(taskQueue.Value.Add(() => { if (channelInstance != null) { channelInstance.Dispose(); channelInstance = null; } // ReSharper disable once InvertIf if (connection != null) { connection.Dispose(); connection = null; } taskQueue.Value.Dispose(); })); }
/// <summary> /// 生产者 /// </summary> /// <param name="settings"></param> /// <param name="delayedMessageEnabled">延迟消息已启用(需启用插件 rabbitmq_delayed_message_exchange)</param> /// <param name="autoConfig">自动建Exchange和Bind</param> public Producer(ProducerSettings settings, bool delayedMessageEnabled, bool autoConfig) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (settings.AmqpConnection == null && settings.AmqpUri == null) { throw new ArgumentNullException("AmqpConnection or AmqpUri must be set."); } _clientName = string.IsNullOrEmpty(settings.ClientName) ? "undefined producer client" : settings.ClientName; _amqpUri = settings.AmqpUri; if (settings.AmqpConnection != null) { _amqpConnection = settings.AmqpConnection; _clientName = settings.AmqpConnection.ClientProvidedName; } if (settings.SendMsgTimeout > 0) { _sendMsgTimeout = TimeSpan.FromSeconds(settings.SendMsgTimeout); } if (settings.MaxChannelIdleDuration > 0) { _maxIdleDuration = TimeSpan.FromSeconds(settings.MaxChannelIdleDuration); } _delayedMessageEnabled = delayedMessageEnabled; _autoConfig = autoConfig; _channelPool = new ConcurrentQueue <Tuple <DateTime, IRabbitMQChannel> >(); _cleanIdleChannelTimer = new Timer(ClearIdleChannel); }
private static void WriteMessage(RabbitMQ.Client.IConnection conn, string from) { Console.Write("To: "); var to = Console.ReadLine(); if (String.IsNullOrEmpty(to)) { return; } Console.Write("Message: "); var message = Console.ReadLine(); try { using (var model = conn.CreateModel()) { model.BasicReturn += new EventHandler <RabbitMQ.Client.Events.BasicReturnEventArgs>(blabla); var rabbitMessage = new RabbitMessage() { From = from, Message = message }; var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(rabbitMessage)); model.BasicPublish(to + "Exchange", string.Empty, new BasicProperties() { DeliveryMode = 2 }, body); } } catch (Exception ex) { string msg = ex.Message; } }
/// <summary> /// Registers the mq listen and hubs. /// </summary> public static void RegisterMQListenAndHubs() { ConnectionFactory factory = new ConnectionFactory(); factory.UserName = "******"; // "gue factory.Password = "******"; factory.VirtualHost = "/"; factory.HostName = "192.168.1.105"; RabbitMQ.Client.IConnection conn = factory.CreateConnection(); IModel channel = conn.CreateModel(); var consumer = new EventingBasicConsumer(channel); consumer.Received += (ch, ea) => { var body = ea.Body; if (body != null) { string message = System.Text.Encoding.Default.GetString(body); GlobalHost.ConnectionManager.GetHubContext <RealTimeDataHub>().Clients.All.realData(message); } ((IModel)ch).BasicAck(ea.DeliveryTag, false); }; String consumerTag = channel.BasicConsume("lenovo", false, consumer); }
/// <summary> /// 执行关闭 /// </summary> /// <returns>事件数据</returns> protected override object ExecClose() { if (channels.Count > 0) { foreach (IModel channel in channels) { if (channel.IsOpen) { channel.Close(); channel.Dispose(); } } channels.Clear(); } if (Status == ConnectionStatusType.OPENED) { connection.Close(); connection.Dispose(); } connection = null; virtualPath = RabbitConnectionInfo.DEFAULT_VIRTUAL_PATH; return(null); }
public void Dispose() { lock (this.syncRoot) { try { this.Close(); if (this.connection != null) { this.logger.Trace( $"[{this.endpoint}]: disposing connection [{this.Id}] at [{this.connection.Endpoint}]."); this.connection?.Dispose(); this.connection = null; } } catch (Exception ex) { this.logger.Trace($"An error '{ex.Message}' during connection cleanup has been suppressed"); } finally { this.OnDisposed(); } } }
public void Open(CancellationToken token) { this.logger.Info($"Connecting to RabbitMQ using [{this.ConnectionString}]."); var clientProperties = new Dictionary <string, object> { { "Endpoint", this.endpoint.Address }, { "Machine", Environment.MachineName }, { "Location", Path.GetDirectoryName( Assembly.GetExecutingAssembly().CodeBase) } }; var connectionFactory = new ConnectionFactory { Uri = this.ConnectionString, ClientProperties = clientProperties, RequestedConnectionTimeout = ConnectionTimeout }; var retryCount = 0; while (!token.IsCancellationRequested) { INativeConnection con = null; try { con = connectionFactory.CreateConnection(); con.ConnectionShutdown += this.OnConnectionShutdown; this.connection = con; this.OnOpened(); this.logger.Info($"Connection [{this.Id}] opened at [{this.connection.Endpoint}]"); return; } catch (Exception ex) { var secondsToRetry = Math.Min(10, retryCount); this.logger.WarnFormat( "Unable to connect to RabbitMQ. Retrying in {0} seconds...", ex, secondsToRetry); if (con != null) { con.ConnectionShutdown -= this.OnConnectionShutdown; con.Abort(OperationTimeout); } Thread.Sleep(TimeSpan.FromSeconds(secondsToRetry)); retryCount++; } } }
} // AmqpClient #region ConnectionHandlerProgram private Exception MakeNewConnection(ref RmqCl.IConnection connection, ref RmqCl.IModel channel, bool reconnecting) { // This method attempts to make a new connection. Returns true if success, otherwise false. var connRequest = ConnectionRequestObj; var factory = new RmqCl.ConnectionFactory() { HostName = connRequest.Host, UserName = connRequest.Username, Password = connRequest.Password }; // Secure connection? if (connRequest.Secure) { factory.Ssl.Enabled = true; factory.Ssl.ServerName = connRequest.Host; factory.Ssl.Version = System.Security.Authentication.SslProtocols.Tls12; } try { // Create connection and channel connection = factory.CreateConnection(); channel = connection.CreateModel(); // Declare the exchange channel.ExchangeDeclare(exchange: connRequest.Exchange, type: "topic", autoDelete: false, durable: true, arguments: null); // Create a queue to receive messages var queueName = channel.QueueDeclare(queue: "", // Use a generated queue name durable: false, // The queue does not survive a broker restart exclusive: true, // The queue is only for this application, and it will be deleted on app exit autoDelete: true, // The queue is deleted when no one is bound to it arguments: null ).QueueName; // Bind the queue to the topic pattern channel.QueueBind(queue: queueName, exchange: connRequest.Exchange, routingKey: connRequest.TopicPattern, arguments: null); // Set up a consumer for messages m_messageConsumer = new RmqCl.Events.EventingBasicConsumer(channel); m_messageConsumer.Received += MessageReceived; channel.BasicConsume(queue: queueName, noAck: true, consumerTag: "", noLocal: false, exclusive: false, arguments: new Dictionary <string, object> { }, consumer: m_messageConsumer); // Sign up for the shutdown event channel.ModelShutdown += ModelShutdown; // This event will fire if the connection is lost return(null); } catch (Exception e) { // Clean the connection DestroyConnection(ref connection, ref channel); return(e); } } // MakeNewConnection
/// <summary> /// 关闭 /// </summary> public override void Close() { if (channels.Count > 0) { foreach (IModel channel in channels) { if (channel.IsOpen) { channel.Close(); channel.Dispose(); } } channels.Clear(); } if (Status == ConnectionStatusType.OPENED) { connection.Close(); connection.Dispose(); } connection = null; OnClosed(); }
public void Dispose() { if (!(_connection is null)) { _connection.Dispose(); _connection = null; } }
protected internal virtual IModel CreateInboundModel(RabbitMQ.Client.IConnection connection, UInt32 prefetchSize, UInt16 prefetchCount) { var model = connection.CreateModel(); model.BasicQos(prefetchSize, prefetchCount, false); return(model); }
private void OnConnectionShutdown(INativeConnection conn, ShutdownEventArgs eventArgs) { Task.Factory.StartNew( () => { conn.ConnectionShutdown -= this.OnConnectionShutdown; this.OnClosed(); }); }
//options internal IModel CreateChannel(IConnection connection) { var channel = connection.CreateModel(); channel.QueueDeclare(QueueName, Durable, Exclusive, AutoDelete, Arguments); //configure channel using options here return(channel); }
private void ConnectionHandlerProgram() { // This method is run in the connection handler thread. // Multiple variables are declared here, because this limits their access for this thread only. RmqCl.IConnection connection = null; RmqCl.IModel channel = null; // This indicates if the connection is being restored bool connectionRestoreSequenceOn = false; // Run the thread until "break" while (true) { // Wait for something to happen. // This wait has a maximum length, as this same wait call occurs between reconnect attempts. m_connectionWait.WaitOne(TimeSpan.FromSeconds(RetryIntervalSeconds)); // Choosing what to do based on the flags if (m_disposed.Value || m_userHasRequestedTerminate.Value) { // Quitting break; } else if (m_triggerConnectionRestore.Value || connectionRestoreSequenceOn) { // Connection lost! Attempting to restore. // Reset the triggering flag m_triggerConnectionRestore.Value = false; // Keep on attempting restore until successful connectionRestoreSequenceOn = !AttemptConnectionRestore(ref connection, ref channel); } else if (ConnectionRequestObj != null && connection == null) { // Attempting to connect SendConnectionEvent(true, ConnectionEventType.Connecting); var exception = MakeNewConnection(ref connection, ref channel, false); if (exception == null) { SendConnectionEvent(true, ConnectionEventType.Connected); } else { SendConnectionEvent(false, ConnectionEventType.ConnectingFailed, exception); } } // Otherwise, nothing to do } // Quitting the thread TerminateImpl(ref connection, ref channel); m_connectionWait.Dispose(); } // ConnectionHandlerProgram
public static void CreateConnection() { _factory = new ConnectionFactory { HostName = "localhost", UserName = "******", Password = "******" }; _connection = _factory.CreateConnection(); _model = _connection.CreateModel(); _model.ExchangeDeclare(ExchangeName, "fanout", true); }
public RabbitMQConnection(string exchange, Rabbit.IConnection connection) { if (string.IsNullOrWhiteSpace(exchange)) { throw new ArgumentNullException(nameof(exchange)); } _exchange = exchange; _connection = connection ?? throw new ArgumentNullException(nameof(connection)); }
/// <remarks> /// Only call this from a task in the taskQueue to ensure IModel is only used /// by a single thread, as is recommended in the RabbitMQ .NET Client documentation. /// </remarks> private async Task <IModel> GetChannel(int?maxAttempts = null) { if (channelInstance != null) { return(channelInstance); } var attempts = 0; var connectionFactory = new ConnectionFactory { HostName = ConnectionParams.HostName, Port = ConnectionParams.Port, VirtualHost = ConnectionParams.VirtualHost, UserName = ConnectionParams.Username, Password = ConnectionParams.Password, AutomaticRecoveryEnabled = true, // The created connection is an IRecoverable RequestedHeartbeat = 30 }; while (true) { try { connection = connectionFactory.CreateConnection(); channelInstance = connection.CreateModel(); if (ConnectionParams.PrefetchCount > 0) { channelInstance.BasicQos(0, ConnectionParams.PrefetchCount, false); } ((IRecoverable)connection).Recovery += (sender, e) => ConnectionEventListener?.Reconnected(); channelInstance.ModelShutdown += (sender, e) => ConnectionEventListener?.Disconnected(); ConnectionEventListener?.Connected(); break; } catch (BrokerUnreachableException) { attempts++; if (maxAttempts.HasValue && attempts > maxAttempts.Value) { throw; } await Task.Delay(ReconnectDelay); } } return(channelInstance); }
public RabbitMQWrapper(RabbitMQ.Client.IConnection connection) { _rmqConnection = connection; _rmqModel = _rmqConnection.CreateModel(); _rmqModel.ExchangeDeclare(_exchangeName, ExchangeType.Topic); _serializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Ignore }; }
private void SetupConnection() { if (_connection != null && _connection.IsOpen) { return; } _connection?.Dispose(); _connection = _factory.CreateConnection(); _connection.ConnectionShutdown += _connection_ConnectionShutdown; _logger.LogInformation("Connection is ready"); }
public void Constructor_NullConnection_ArgumentNullException() { //Arrange string exchange = nameof(exchange); Rabbit.IConnection connection = null; //Act var action = new Action(() => new RabbitMQConnection(exchange, connection)); //Assert Assert.Throws <ArgumentNullException>(nameof(connection), action); }
/// <summary> /// 关闭 /// </summary> public void Shutdown() { if (Interlocked.CompareExchange(ref _isRunning, 0, 1) == 1) { Thread.Sleep(100); if (_amqpConnection != null) { if (_mode == ConsumeMode.Push) { foreach (var topic in _globalConsumers.Keys) { var consumers = _globalConsumers[topic]; foreach (var queueIndex in consumers.Keys) { var channel = consumers[queueIndex].Model; if (channel.IsOpen) { channel.Close(RabbitMQConstants.ConnectionForced, $"\"{topic}-{queueIndex}\"'s normal channel disposed"); } } consumers.Clear(); } _globalConsumers.Clear(); } else { foreach (var topic in _globalChannels.Keys) { var channels = _globalChannels[topic]; foreach (var queueIndex in channels.Keys) { var channel = channels[queueIndex].Item1; var consumerThread = channels[queueIndex].Item2; if (channel.IsOpen) { channel.Close(RabbitMQConstants.ConnectionForced, $"\"{topic}-{queueIndex}\"'s normal channel disposed"); } } channels.Clear(); } _globalChannels.Clear(); } if (_selfCreate) { _amqpConnection.Close(); _amqpConnection = null; } } } }
public void Open(CancellationToken token) { lock (this.syncRoot) { if (this.connection?.IsOpen ?? false) { this.logger.Trace($"Connection [{this.Id}] is already open"); return; } this.logger.Info($"Connecting to RabbitMQ using [{this.ConnectionString}]"); var retryCount = 0; while (true) { token.ThrowIfCancellationRequested(); INativeConnection con = null; try { con = this.connectionFactory.CreateConnection(); con.ConnectionShutdown += this.OnConnectionShutdown; this.connection = con; this.OnOpened(); this.logger.Info($"Connection [{this.Id}] opened at [{this.connection.Endpoint}]"); return; } catch (Exception ex) { var secondsToRetry = Math.Min(10, retryCount); this.logger.WarnFormat( "Unable to connect to RabbitMQ. Retrying in {0} seconds...", ex, secondsToRetry); if (con != null) { con.ConnectionShutdown -= this.OnConnectionShutdown; con.Abort(OperationTimeout); } Thread.Sleep(TimeSpan.FromSeconds(secondsToRetry)); retryCount++; } } } }
private static RabbitMQ.Client.IConnection InitRabbitMqConn() { RabbitMqConfigs rabbitmqConfigs = new RabbitMqConfigs(_configs.GetSection("rabbitMq")); ConnectionFactory factory = new ConnectionFactory { HostName = rabbitmqConfigs.Host, Port = rabbitmqConfigs.Port, UserName = rabbitmqConfigs.User, Password = rabbitmqConfigs.Password, }; RabbitMQ.Client.IConnection rabbitmqConn = factory.CreateConnection(); return(rabbitmqConn); }
private void OnConnectionShutdown(INativeConnection conn, ShutdownEventArgs eventArgs) { Task.Factory.StartNew( () => { this.logger.Trace($"Connection [{this.Id}] has been closed due to {eventArgs.ReplyText} ({eventArgs.ReplyCode})"); lock (this.syncRoot) { conn.ConnectionShutdown -= this.OnConnectionShutdown; } this.OnClosed(); }); }
/// <summary> /// 启动 /// </summary> public void Start() { if (Interlocked.CompareExchange(ref _isRunning, 1, 0) == 0) { if (_amqpConnection == null) { var connFactory = new RabbitMQConnectionFactory { Uri = _amqpUri }; _amqpConnection = connFactory.CreateConnection(_clientName); _selfCreate = true; } if (_autoConfig) { using (var channelForConfig = _amqpConnection.CreateModel()) { foreach (var topic in _topics.Keys) { var queueCount = _topics[topic]; var subscribeQueues = GetSubscribeQueues(queueCount, _consumerCount, _consumerSequence); var subTopic = GetSubTopic(topic); channelForConfig.ExchangeDeclare(topic, ExchangeType.Fanout, true, false, null); channelForConfig.ExchangeDeclare(subTopic, ExchangeType.Direct, true, false, null); channelForConfig.ExchangeBind(subTopic, topic, "", null); for (byte queueIndex = 0; queueIndex < queueCount; queueIndex++) { string queueName = GetQueue(topic, queueIndex); channelForConfig.QueueDeclare(queueName, true, false, false, null); channelForConfig.QueueBind(queueName, subTopic, queueIndex.ToString(), null); } } channelForConfig.Close(); } } if (_mode == ConsumeMode.Push) { ConsumeByPush(); } else { ConsumeByPull(); } } }
public RabbitMessageProcessor( ITransformer <TSrc, TDst> transformer, IWriter <TDst> writer, ILoggerFactory loggerFactory, IOptions <RabbitConfig> options, IConnection connection) { _writer = writer; _connection = connection; _logger = loggerFactory.CreateLogger(GetType()); _rabbitConfig = options.Value; _transformer = transformer; _channel = connection.CreateModel(); _consumer = new EventingBasicConsumer(_channel); _consumerTag = Guid.NewGuid().ToString(); }
/// <summary> /// 每次重启时,清空队列 /// </summary> public static void DeleteQueue() { using (IConnection conn = RabbitMqFactory.CreateConnection()) { using (IModel channel = conn.CreateModel()) { try { channel.QueueDelete(QueueName, true, false); } catch (Exception e) { LogWrite.WriteLogInfo($"重启时,存在消费者,不删除队列,异常{e.Message}"); } } } }
public EventConsumer() { _factory = new ConnectionFactory { HostName = HostName, UserName = UserName, Password = Password }; _connection = _factory.CreateConnection(); _model = _connection.CreateModel(); _model.QueueDeclare(QueueName, true, false, false, null); _model.QueueBind(QueueName, ExchangeName, ""); _model.BasicQos(0, 1, false); _subscription = new Subscription(_model, QueueName, false); _gameRepository = new MongoRepository <HSGame>(); _deckRepository = new MongoRepository <HSDeck>(); }
public RabbitMqMessageBus(IDependencyResolver resolver, RabbitMqScaleoutConfiguration configuration) : base(resolver, configuration) { Open(0); var connectionFactory = CreateConnectionFactory(configuration); connection = connectionFactory.CreateConnection(); model = connection.CreateModel(); var exchange = configuration.ExchangeName ?? "messages"; model.QueueDeclare(configuration.QueueName, false, false, true, new Hashtable()); model.ExchangeDeclare(exchange, ExchangeType.Fanout); model.QueueBind(configuration.QueueName, exchange, ""); consumerTag = model.BasicConsume(configuration.QueueName, true, new Consumer(this.OnReceived)); }
/// <summary>Initializes a new instance of the <see cref="SimpleConnection"/> class.</summary> /// <param name="connectionDelegate">The connection delegate.</param> public SimpleConnection(RabbitMQ.Client.IConnection connectionDelegate) { this.connectionDelegate = connectionDelegate; }
protected virtual void ConnectToBroker() { if (_outboundModel != null && !_outboundModel.IsClosed) return; _connection = _connectionBuilder.CreateConnection(_configuration.EndpointUri); //Logger.DebugFormat("RMQMessagingGateway: Opening channel to Rabbit MQ on connection {0}", Configuration.AMPQUri.GetSanitizedUri()); _outboundModel = _connection.CreateModel(); //When AutoClose is true, the last channel to close will also cause the connection to close1. If it is set to //true before any channel is created, the connection will close then and there. if (_connection.AutoClose == false) _connection.AutoClose = true; foreach (var exchange in _exchanges) exchange.Declare(_outboundModel); foreach (var queue in _queues) queue.Declare(_outboundModel); foreach (var binding in _bindings) binding.Declare(_outboundModel); var builder = new ConsumedMessageBuilder(_configuration.SerializationConfiguration, _configuration.MessageTypeResolver); _outboundChannel = _configuration.OutboundChannelBuilder(_outboundModel, _configuration); var consumers = _promises.Select(_ => { var model = CreateInboundModel(_connection, _configuration.PrefetchSize, _configuration.PrefetchCount); var consumer = _(builder).BuildConsumer(new InboundChannel(model), _outboundChannel); return new {Model = model, Consumer = consumer}; }) .ToList(); foreach (var consumer in consumers) consumer.Consumer.Declare(consumer.Model); _consumers = consumers.Select(_ => _.Consumer); }
/// <summary> /// Queues the exists. /// </summary> /// <param name="connection">The connection.</param> /// <param name="queue">The queue.</param> /// <returns></returns> /// Use native Rabbit API to test queue, bypassing all the connection and channel caching and callbacks in Spring /// AMQP. /// @param connection the raw connection to use /// @param queue the Queue to test /// @return true if the queue exists /// <remarks></remarks> private bool QueueExists(IConnection connection, Queue queue) { var target = connection; if (target == null) { var connectionFactory = new ConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetPort(); target = connectionFactory.CreateConnection(); } var channel = target.CreateModel(); try { var result = channel.QueueDeclarePassive(queue.Name); return result != null; } catch (Exception e) { if (e.Message.Contains("RESOURCE_LOCKED")) { return true; } return false; } finally { if (connection == null) { target.Close(); } } }