internal void TestDelayedBasicAckNackAfterChannelRecovery(TestBasicConsumer1 cons, ManualResetEventSlim latch) { string q = Model.QueueDeclare(GenerateQueueName(), false, false, false, null).QueueName; int n = 30; Model.BasicQos(0, 1, false); Model.BasicConsume(q, false, cons); AutorecoveringConnection publishingConn = CreateAutorecoveringConnection(); IModel publishingModel = publishingConn.CreateModel(); for (int i = 0; i < n; i++) { publishingModel.BasicPublish("", q, null, encoding.GetBytes("")); } Wait(latch, TimeSpan.FromSeconds(20)); Model.QueueDelete(q); publishingModel.Close(); publishingConn.Close(); }
public void TestConsumerRecoveryOnClientNamedQueueWithOneRecovery() { string q0 = "dotnet-client.recovery.queue1"; using (AutorecoveringConnection c = CreateAutorecoveringConnection()) { IModel m = c.CreateModel(); string q1 = m.QueueDeclare(q0, false, false, false, null).QueueName; Assert.AreEqual(q0, q1); var cons = new EventingBasicConsumer(m); m.BasicConsume(q1, true, cons); AssertConsumerCount(m, q1, 1); bool queueNameChangeAfterRecoveryCalled = false; c.QueueNameChangeAfterRecovery += (source, ea) => { queueNameChangeAfterRecoveryCalled = true; }; CloseAndWaitForRecovery(c); AssertConsumerCount(m, q1, 1); Assert.False(queueNameChangeAfterRecoveryCalled); CloseAndWaitForRecovery(c); AssertConsumerCount(m, q1, 1); Assert.False(queueNameChangeAfterRecoveryCalled); CloseAndWaitForRecovery(c); AssertConsumerCount(m, q1, 1); Assert.False(queueNameChangeAfterRecoveryCalled); var latch = new ManualResetEventSlim(false); cons.Received += (s, args) => latch.Set(); m.BasicPublish("", q1, null, _encoding.GetBytes("msg")); Wait(latch); m.QueueDelete(q1); } }
public void TestConsumerWorkServiceRecovery() { using (AutorecoveringConnection c = CreateAutorecoveringConnection()) { IModel m = c.CreateModel(); string q = m.QueueDeclare("dotnet-client.recovery.consumer_work_pool1", false, false, false, null).QueueName; var cons = new EventingBasicConsumer(m); m.BasicConsume(q, true, cons); AssertConsumerCount(m, q, 1); CloseAndWaitForRecovery(c); Assert.IsTrue(m.IsOpen); var latch = new ManualResetEventSlim(false); cons.Received += (s, args) => latch.Set(); m.BasicPublish("", q, null, _encoding.GetBytes("msg")); Wait(latch); m.QueueDelete(q); } }
/// <summary> /// Create a connection using a list of hostnames. The first reachable /// hostname will be used initially. Subsequent hostname picks are determined /// by the <see cref="IHostnameSelector" /> configured. /// </summary> /// <param name="hostnames"> /// List of hostnames to use for the initial /// connection and recovery. /// </param> /// <returns>Open connection</returns> /// <exception cref="BrokerUnreachableException"> /// When no hostname was reachable. /// </exception> public IConnection CreateConnection(IList <string> hostnames) { IConnection conn; try { if (AutomaticRecoveryEnabled) { var autorecoveringConnection = new AutorecoveringConnection(this); autorecoveringConnection.Init(hostnames); conn = autorecoveringConnection; } else { IProtocol protocol = Protocols.DefaultProtocol; conn = protocol.CreateConnection(this, false, CreateFrameHandler()); } } catch (Exception e) { throw new BrokerUnreachableException(e); } return(conn); }
public void TestBasicConnectionRecoveryStopsAfterManualClose() { Assert.True(_conn.IsOpen); AutorecoveringConnection c = CreateAutorecoveringConnection(); var latch = new AutoResetEvent(false); c.ConnectionRecoveryError += (o, args) => latch.Set(); try { StopRabbitMQ(); latch.WaitOne(30000); // we got the failed reconnection event. bool triedRecoveryAfterClose = false; c.Close(); Thread.Sleep(5000); c.ConnectionRecoveryError += (o, args) => triedRecoveryAfterClose = true; Thread.Sleep(10000); Assert.False(triedRecoveryAfterClose); } finally { StartRabbitMQ(); } }
/// <summary> /// Create a connection using an IEndpointResolver. /// </summary> /// <param name="endpointResolver"> /// The endpointResolver that returns the endpoints to use for the connection attempt. /// </param> /// <param name="clientProvidedName"> /// Application-specific connection name, will be displayed in the management UI /// if RabbitMQ server supports it. This value doesn't have to be unique and cannot /// be used as a connection identifier, e.g. in HTTP API requests. /// This value is supposed to be human-readable. /// </param> /// <returns>Open connection</returns> /// <exception cref="BrokerUnreachableException"> /// When no hostname was reachable. /// </exception> public IConnection CreateConnection(IEndpointResolver endpointResolver, string clientProvidedName) { IConnection conn; try { if (AutomaticRecoveryEnabled) { var autorecoveringConnection = new AutorecoveringConnection(this, clientProvidedName); autorecoveringConnection.Init(endpointResolver); conn = autorecoveringConnection; } else { conn = ((ProtocolBase)Protocols.AMQP_0_9_1).CreateConnection(this, endpointResolver.SelectOne(CreateFrameHandler), clientProvidedName); } } catch (Exception e) { throw new BrokerUnreachableException(e); } return(conn); }
///<summary>Create a connection to the specified endpoint.</summary> public virtual IConnection CreateConnection() { IConnection conn = null; try { if (this.AutomaticRecoveryEnabled) { AutorecoveringConnection ac = new AutorecoveringConnection(this); ac.init(); conn = ac; } else { IProtocol p = Protocols.DefaultProtocol; conn = p.CreateConnection(this, false, this.CreateFrameHandler()); } } catch (Exception e) { throw new BrokerUnreachableException(e); } return(conn); }
internal void AssertRecordedQueues(AutorecoveringConnection c, int n) { Assert.AreEqual(n, c.RecordedQueuesCount); }
public DisposableConnection(AutorecoveringConnection c) { Connection = c; }
internal void WaitForRecovery(AutorecoveringConnection conn) { Wait(PrepareForRecovery(conn)); }
public AutorecoveringModel(AutorecoveringConnection conn, RecoveryAwareModel _delegate) { m_connection = conn; m_delegate = _delegate; }
internal void AssertRecordedExchanges(AutorecoveringConnection c, int n) { Assert.Equal(n, c.RecordedExchangesCount); }
public void OnReconnected(AutorecoveringConnection conn) { Console.WriteLine("OnConnectionSuccess : 重新连接"); }
public void OnError(AutorecoveringConnection conn, Exception e) { Console.WriteLine("OnError : " + e.Message); }
public void OnReconnected(AutorecoveringConnection conn) { }
public void OnError(AutorecoveringConnection conn, Exception e) { }
protected void AssertRecordedExchanges(AutorecoveringConnection c, int n) { Assert.AreEqual(n, c.RecordedExchanges.Count); }
protected void WaitForRecovery(AutorecoveringConnection conn) { Wait(PrepareForRecovery(conn)); }