public void TestRecoverAfterFailOnTransactionAfterPrepareSent()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue();
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPostProcessor += this.FailOnPrepareTransportHook;
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// not visible yet because it must be rolled back
VerifyNoMessagesInQueueNoRecovery();
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
NetTxTransactionContext.ResetDtcRecovery();
VerifyBrokerQueueCount();
}
public void TestConnection()
{
IConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionUri));
using (connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://TEST.test.in");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Connection amqConnection = connection as Connection;
connection.ExceptionListener += ConnectionException;
consumer.Listener += OnMessage;
TcpFaultyTransport transport = amqConnection.ITransport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(transport);
transport.OnewayCommandPreProcessor += FailOnKeepAlive;
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.Start();
Assert.IsTrue(exceptionOccuredEvent.WaitOne(TimeSpan.FromSeconds(30 * 3)),
"Exception didnt occured within waiting time");
}
}
}
public void TestRecoverAfterRollbackFailWhenScopeAborted()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue();
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnRollbackTransportHook;
ReadFromQueueAndInsertIntoDbWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are recovered and present in the queue
NetTxTransactionContext.ResetDtcRecovery();
VerifyBrokerQueueCount();
}
public void TestRecoveryAfterCommitFailsAfterSent()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue();
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPostProcessor += this.FailOnCommitTransportHook;
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(1000);
}
// transaction should have been commited
VerifyNoMessagesInQueueNoRecovery();
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull();
// check messages are not present in the queue
VerifyNoMessagesInQueue();
}
public void TestRecoverAfterFailOnTransactionPostCommitSend()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPostProcessor += this.FailOnCommitTransportHook;
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(1000);
}
// transaction should have been commited
VerifyBrokerQueueCountNoRecovery();
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestRecoverAfterRollbackFailWhenScopeAborted()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnRollbackTransportHook;
ReadFromDbAndProduceToQueueWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull();
// before recovering, messages should NOT be present in the queue
VerifyNoMessagesInQueueNoRecovery();
// check messages are not present in the queue after recover
VerifyNoMessagesInQueue();
}
public void TestRecoverAfterFailOnTransactionBeforePrepareSent()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue();
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnPrepareTransportHook;
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// Messages are visible since no prepare sent
VerifyBrokerQueueCountNoRecovery();
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestRecoverAfterFailOnTransactionDuringPrepareSend()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPostProcessor += this.FailOnPrepareTransportHook;
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull();
// check messages are present in the queue
VerifyNoMessagesInQueue();
}
public void FailoverWithShortLivedProducerTest()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
PurgeQueue(connection, destination);
}
Tracer.Debug("Test is putting " + MSG_COUNT + " messages on the queue: " + destinationName);
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
IDestination destination = session.GetQueue(destinationName);
PutMsgIntoQueue(session, destination, false);
tcpFaulty.Close();
PutMsgIntoQueue(session, destination, false);
session.Commit();
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
Tracer.Debug("Test is attempting to read " + MSG_COUNT +
" messages from the queue: " + destinationName);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
IMessageConsumer consumer = session.CreateConsumer(destination);
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(msg, "Should receive message[" + (i + 1) + "] after commit failed once.");
}
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}
public void TestConsumeWithDBInsertLogLocation()
{
const string logLocation = @".\RecoveryDir";
string newConnectionUri =
connectionUri + "?nms.RecoveryPolicy.RecoveryLogger.Location=" + logLocation +
"&nms.configuredResourceManagerId=" +
dtcFactory.ConfiguredResourceManagerId;
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue();
if (Directory.Exists(logLocation))
{
Directory.Delete(logLocation, true);
}
Directory.CreateDirectory(logLocation);
dtcFactory = new NetTxConnectionFactory(ReplaceEnvVar(newConnectionUri));
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
Assert.AreEqual(1, Directory.GetFiles(logLocation).Length);
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull();
// check messages are NOT present in the queue
NetTxTransactionContext.ResetDtcRecovery();
VerifyBrokerQueueCount(0, newConnectionUri);
Assert.AreEqual(0, Directory.GetFiles(logLocation).Length);
}
public void TestMessageDeliveredAfterCommitFailsAndRollback()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
DeleteQueue(connection, destination);
PutOneMsgIntoQueue(session, destination);
}
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
IMessageConsumer consumer = session.CreateConsumer(session.GetQueue(destinationName));
IMessage message = consumer.Receive(TimeSpan.FromSeconds(30));
Assert.IsNotNull(message, "Message was not delivered");
Tracer.Debug("Commiting transaction");
try
{
Tracer.Info("Now attempting to commit the transaction");
session.Commit();
}
catch (Exception ex)
{
Tracer.InfoFormat("Commit failed as expected. {0}", ex.Message);
}
message = consumer.Receive(TimeSpan.FromSeconds(30));
Assert.IsNotNull(message, "message was not redilivered");
}
}
}
public void TestNoRecoverAfterFailOnTransactionWhenLogDeleted()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
NetTxConnectionFactory netTxFactory = factory as NetTxConnectionFactory;
RecoveryFileLogger logger = netTxFactory.RecoveryPolicy.RecoveryLogger as RecoveryFileLogger;
string logDirectory = logger.Location;
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// transaction should not have been commited
VerifyNoMessagesInQueueNoRecovery();
// delete all recovery files
foreach (string file in Directory.GetFiles(logDirectory, "*.bin"))
{
File.Delete(file);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are NOT present in the queue bacause recovery file has been deleted
VerifyNoMessagesInQueue();
}
public void TestConnectUsingBasicTransport(
[Values("tcpfaulty://${activemqhost}:61616", "activemq:tcpfaulty://${activemqhost}:61616")]
string connectionURI)
{
ConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
using (Connection connection = factory.CreateConnection() as Connection)
{
ITransport transport = connection.ITransport.Narrow(typeof(TcpFaultyTransport)) as ITransport;
Assert.IsNotNull(transport);
TcpFaultyTransport testee = transport as TcpFaultyTransport;
testee.OnewayCommandPreProcessor += new CommandHandler(this.OnPreProcessCommand);
testee.OnewayCommandPostProcessor += new CommandHandler(this.OnPostProcessCommand);
using (ISession session = connection.CreateSession())
{
Assert.IsTrue(session.Transacted == false);
}
Assert.IsTrue(this.preProcessorFired);
Assert.IsTrue(this.postProcessorFired);
}
}
public void TestConnection()
{
IConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionUri));
using (connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://TEST.test.in");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Connection amqConnection = connection as Connection;
connection.ExceptionListener += ConnectionException;
consumer.Listener += OnMessage;
TcpFaultyTransport transport = amqConnection.ITransport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(transport);
transport.OnewayCommandPreProcessor += FailOnKeepAlive;
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.Start();
int count = 30;
while (count-- > 0)
{
if (!connectionClosed)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
}
}
Assert.IsTrue(connectionClosed);
}
}
}
public void FailoverAfterCommitSentTest()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPostProcessor += this.FailOnCommitTransportHook;
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
DeleteQueue(connection, destination);
}
Tracer.Debug("Test is putting " + MSG_COUNT + " messages on the queue: " + destinationName);
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
IDestination destination = session.GetQueue(destinationName);
PutMsgIntoQueue(session, destination, false);
try
{
session.Commit();
Assert.Fail("Should have thrown a TransactionRolledBackException");
}
catch (TransactionRolledBackException)
{
Tracer.Info("TEST: Caught expected TransactionRolledBackException");
}
catch (Exception ex)
{
Assert.Fail("Should have thrown a TransactionRolledBackException, but was: " +
ex.GetType().Name);
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
Tracer.Debug("Test is attempting to read " + MSG_COUNT +
" messages from the queue: " + destinationName);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
IMessageConsumer consumer = session.CreateConsumer(destination);
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(msg, "Should receive message[" + (i + 1) + "] after commit failed once.");
}
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}
public void FailoverBeforeCommitSentTest()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
PurgeQueue(connection, destination);
}
Tracer.Debug("Test is putting " + MSG_COUNT + " messages on the queue: " + destinationName);
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
IDestination destination = session.GetQueue(destinationName);
PutMsgIntoQueue(session, destination, false);
try
{
session.Commit();
Assert.Fail("Should have thrown a TransactionRolledBackException");
}
catch (TransactionRolledBackException)
{
}
catch
{
Assert.Fail("Should have thrown a TransactionRolledBackException");
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
Tracer.Debug("Test is attempting to read a message from" +
destinationName + " but no messages are expected");
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
IMessageConsumer consumer = session.CreateConsumer(destination);
IMessage msg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNull(msg, "Should not receive a message after commit failed.");
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}
