public void TestIterativeTransactedProduceWithDBDelete()
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount(MSG_COUNT * 5);
}
public void TestIterativeTransactedConsume()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue(5 * MSG_COUNT);
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull(5 * MSG_COUNT);
// check messages are NOT present in the queue
VerifyNoMessagesInQueueNoRecovery();
}
public void TestRecoveryAfterCommitFailsAfterSent()
{
// 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())
{
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 TestRecoverAfterRollbackFailWhenScopeAborted()
{
// 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())
{
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
VerifyBrokerQueueCount();
}
public void TestRedelivered()
{
// enqueue several messages
PurgeDatabase();
PurgeAndFillQueue();
// receive just one
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
using (INetTxSession session = connection.CreateNetTxSession())
{
IQueue queue = session.GetQueue(testQueueName);
// read message from queue and insert into db table
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
using (SqlConnection sqlConnection = new SqlConnection(sqlConnectionString))
using (SqlCommand sqlInsertCommand = new SqlCommand())
{
sqlConnection.Open();
sqlInsertCommand.Connection = sqlConnection;
ITextMessage message = consumer.Receive(TimeSpan.FromMilliseconds(10000)) as ITextMessage;
sqlInsertCommand.CommandText =
string.Format("INSERT INTO {0} VALUES ({1})", testTable, Convert.ToInt32(message.Text));
sqlInsertCommand.ExecuteNonQuery();
scoped.Complete();
}
}
session.Close();
}
}
// check that others message have status redelivered = false
IConnectionFactory checkFactory = new ConnectionFactory(ReplaceEnvVar(connectionURI));
using (IConnection connection = checkFactory.CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession())
using (IQueueBrowser browser = session.CreateBrowser(session.GetQueue(testQueueName)))
{
IEnumerator enumerator = browser.GetEnumerator();
while (enumerator.MoveNext())
{
IMessage msg = enumerator.Current as IMessage;
Assert.IsNotNull(msg, "message is not in the queue!");
Assert.IsFalse(msg.NMSRedelivered, "message is redelivered!");
}
}
}
}
public void TestNoRecoverAfterFailOnTransactionWhenLogWriteFails()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
string newConnectionUri =
connectionUri + "?nms.RecoveryPolicy.RecoveryLoggerType=harness" +
"&nms.configuredResourceManagerId=" +
dtcFactory.ConfiguredResourceManagerId;
dtcFactory = new NetTxConnectionFactory(ReplaceEnvVar(newConnectionUri));
using (INetTxConnection connection = dtcFactory.CreateNetTxConnection())
{
IRecoveryLogger logger = (connection as NetTxConnection).RecoveryPolicy.RecoveryLogger;
Assert.IsNotNull(logger);
RecoveryLoggerHarness harness = logger as RecoveryLoggerHarness;
Assert.IsNotNull(harness);
harness.PreLogRecoveryInfoEvent += FailOnPreLogRecoveryHook;
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has not commited the transaction
VerifyDatabaseTableIsFull();
// check messages are not present in the queue
VerifyNoMessagesInQueue();
}
public void TestRecoverAfterFailOnTransactionAfterPrepareSent()
{
// 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.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
VerifyBrokerQueueCount();
}
public void TestRecoverAfterFailOnTransactionPostCommitSend()
{
// 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.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();
}
private void Run()
{
var connectionFactory = new NetTxConnectionFactory("failover:(tcp://localhost:61616,tcp://localhost:61616)?randomize=false&timeout=5000")
{
AcknowledgementMode = AcknowledgementMode.Transactional,
PrefetchPolicy = { QueuePrefetch = 1 }
};
using (var connection = connectionFactory.CreateNetTxConnection())
{
currentconnection = connection;
connection.Start();
using (var session = connection.CreateNetTxSession())
{
this.session = session;
var eventDestination = SessionUtil.GetDestination(session, "queue://Consumer.NMS.VirtualTopic.EventMessage");
var commandDestination = SessionUtil.GetDestination(session, "queue://subscribernms");
using (var eventConsumer = session.CreateConsumer(eventDestination))
using (var commandConsumer = session.CreateConsumer(commandDestination))
{
eventConsumer.Listener += OnEventMessage;
commandConsumer.Listener += this.OnCommandMessage;
Console.WriteLine("Consumer started. Press q to quit");
while (Console.ReadKey().KeyChar != 'q')
{
}
}
}
connection.Stop();
}
}
protected static void VerifyBrokerQueueCount(int expectedCount, string connectionUri)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionUri));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
// check messages are present in the queue
using (INetTxSession session = connection.CreateNetTxSession())
{
IQueue queue = session.GetQueue(testQueueName);
using (IQueueBrowser browser = session.CreateBrowser(queue))
{
connection.Start();
int count = 0;
IEnumerator enumerator = browser.GetEnumerator();
while (enumerator.MoveNext())
{
IMessage msg = enumerator.Current as IMessage;
Assert.IsNotNull(msg, "message is not in the queue !");
count++;
}
// count should match the expected count
Assert.AreEqual(expectedCount, count);
}
}
}
}
protected static void VerifyBrokerHasMessagesInQueue(string connectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
// check messages are present in the queue
using (INetTxSession session = connection.CreateNetTxSession())
{
IDestination queue = session.GetQueue(testQueueName);
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
connection.Start();
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "message is not in the queue !");
}
consumer.Close();
}
}
}
}
public void TestConfigureRecoveryPolicyLoggerUsingDefaultLogger(string location, bool autoCreate)
{
string testuri = string.Format("activemq:tcp://${{activemqhost}}:61616" +
"?nms.RecoveryPolicy.RecoveryLogger.Location={0}" +
"&nms.RecoveryPolicy.RecoveryLogger.AutoCreateLocation={1}",
location, autoCreate);
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
NetTxConnection netTxConnection = connection as NetTxConnection;
Assert.IsNotNull(netTxConnection);
NetTxRecoveryPolicy policy = netTxConnection.RecoveryPolicy;
Assert.AreEqual("file", policy.RecoveryLoggerType);
RecoveryFileLogger logger = policy.RecoveryLogger as RecoveryFileLogger;
Assert.IsNotNull(logger);
Assert.AreEqual(location, logger.Location);
Assert.AreEqual(autoCreate, logger.AutoCreateLocation);
}
}
public void TestRecoverAfterRollbackFailWhenScopeAborted()
{
// 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.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 TestRecoverAfterFailOnTransactionPostCommitSend()
{
// 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.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 TestURI(string connectionURI)
{
{
Uri uri = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(connectionURI));
NetTxConnectionFactory factory = new NetTxConnectionFactory(uri);
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.CreateTemporaryTopic();
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Close();
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Close();
}
session.Close();
}
connection.Close();
}
}
{
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = connection.CreateSession())
{
Assert.IsNotNull(session as INetTxSession);
IDestination destination = session.CreateTemporaryTopic();
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Close();
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Close();
}
session.Close();
}
connection.Close();
}
}
}
public void TestConfigureRecoveryPolicyLoggerTypeWithInvalidType(
[Values("tcp://${activemqhost}:61616?nms.RecoveryPolicy.RecoveryLoggerType=invalid")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (IConnection connection = factory.CreateConnection()){}
}
public void TestTransactedProduceAndConsume(
[Values("tcp://${activemqhost}:61616")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
using (INetTxSession session = connection.CreateNetTxSession())
{
IDestination destination = session.CreateTemporaryQueue();
using (IMessageProducer producer = session.CreateProducer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
Assert.IsNotNull(Transaction.Current);
for (int i = 0; i < MSG_COUNT; ++i)
{
producer.Send(session.CreateTextMessage("Hello World"));
}
scoped.Complete();
}
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "Message was null for index: " + i);
}
scoped.Complete();
}
}
// No more messages should be in the Q, non rolled back or otherwise.
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNull(msg, "Message was not null.");
}
session.Close();
}
connection.Close();
}
}
public void TestTransactedProduceAndConsume(
[Values("tcp://${activemqhost}:61616")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using(INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
using(INetTxSession session = connection.CreateNetTxSession())
{
IDestination destination = session.CreateTemporaryQueue();
using(IMessageProducer producer = session.CreateProducer(destination))
{
using(TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
Assert.IsNotNull(Transaction.Current);
for(int i = 0; i < MSG_COUNT; ++i)
{
producer.Send(session.CreateTextMessage("Hello World"));
}
scoped.Complete();
}
}
using(IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
using(TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
for(int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "Message was null for index: " + i);
}
scoped.Complete();
}
}
// No more messages should be in the Q, non rolled back or otherwise.
using(IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNull(msg, "Message was not null.");
}
session.Close();
}
connection.Close();
}
}
public void TestSessionCreateFailsWithInvalidLogLocation()
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
NetTxConnection con = connection as NetTxConnection;
NetTxRecoveryPolicy policy = con.RecoveryPolicy;
(policy.RecoveryLogger as RecoveryFileLogger).Location = nonExistantPath;
connection.CreateNetTxSession();
}
}
public void TestSessionCreateFailsWithInvalidLogLocation()
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
NetTxConnection con = connection as NetTxConnection;
NetTxRecoveryPolicy policy = con.RecoveryPolicy;
(policy.RecoveryLogger as RecoveryFileLogger).Location = nonExistantPath;
connection.CreateNetTxSession();
}
}
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);
}
private static void RegisterDTCManagedTransactionSessionFactory(TransportConfig transportConfig, Dictionary <string, string> connectionConfiguration)
{
NetTxConnection.ConfiguredResourceManagerId = connectionConfiguration.ContainsKey(ResourceManagerIdKey)
? new Guid(connectionConfiguration[ResourceManagerIdKey])
: DefaultResourceManagerId;
var connectionFactory = new NetTxConnectionFactory(connectionConfiguration[UriKey])
{
AcknowledgementMode = AcknowledgementMode.Transactional,
RedeliveryPolicy = new RedeliveryPolicy {
MaximumRedeliveries = transportConfig.MaxRetries, BackOffMultiplier = 0, UseExponentialBackOff = false
}
};
var pooledSessionFactory = new PooledSessionFactory(connectionFactory);
var sessionFactory = new DTCTransactionSessionFactory(pooledSessionFactory);
NServiceBus.Configure.Component(() => sessionFactory, DependencyLifecycle.SingleInstance);
}
public void TestConnectionFactoryParseParams(
[Values("tcp://${activemqhost}:61616", "activemq:tcp://${activemqhost}:61616")]
string baseConnectionURI,
[Values(AcknowledgementMode.ClientAcknowledge, AcknowledgementMode.AutoAcknowledge)]
AcknowledgementMode ackMode,
[Values(true, false)]
bool asyncSend,
[Values(true, false)]
bool alwaysSyncSend,
[Values(true, false)]
bool asyncClose,
[Values(true, false)]
bool copyMessageOnSend,
[Values(3000, 1000)]
int requestTimeout,
[Values(true, false)]
bool sendAcksAsync,
[Values(true, false)]
bool dispatchAsync)
{
string connectionURI = string.Format("{0}?" +
"connection.AckMode={1}&" +
"connection.AsyncSend={2}&" +
"connection.AlwaysSyncSend={3}&" +
"connection.AsyncClose={4}&" +
"connection.CopyMessageOnSend={5}&" +
"connection.RequestTimeout={6}&" +
"connection.SendAcksAsync={7}&" +
"connection.DispatchAsync={8}",
baseConnectionURI, ackMode, asyncSend, alwaysSyncSend, asyncClose, copyMessageOnSend, requestTimeout, sendAcksAsync, dispatchAsync);
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
using (Connection connection = factory.CreateConnection() as Connection)
{
Assert.AreEqual(ackMode, connection.AcknowledgementMode);
Assert.AreEqual(asyncSend, connection.AsyncSend);
Assert.AreEqual(alwaysSyncSend, connection.AlwaysSyncSend);
Assert.AreEqual(asyncClose, connection.AsyncClose);
Assert.AreEqual(copyMessageOnSend, connection.CopyMessageOnSend);
Assert.AreEqual(requestTimeout, connection.RequestTimeout.TotalMilliseconds);
Assert.AreEqual(sendAcksAsync, connection.SendAcksAsync);
Assert.AreEqual(dispatchAsync, connection.DispatchAsync);
}
}
public void TestTransactedAsyncConsumption()
{
PurgeDatabase();
PurgeAndFillQueue(MSG_COUNT * BATCH_COUNT);
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
using (NetTxSession session = connection.CreateNetTxSession() as NetTxSession)
{
IQueue queue = session.GetQueue(testQueueName);
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += AsyncTxAwareOnMessage;
// Be carefull, message are dispatched once this is done, so you could receive
// a Message outside a TX. We use the awaitBatchProcessingStart event here to
// gate te OnMessage callback, once that method returns the Message is ack'd and
// no longer has a chance to participate in a TX.
connection.Start();
for (int i = 0; i < BATCH_COUNT; ++i)
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
session.Enlist(Transaction.Current);
batchTxControl = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
awaitBatchProcessingStart.Set();
scoped.Complete();
}
// Reenlisting to fast seems to annoy the DTC. Also since DTC operations are
// async we need to allow a little time for lag so that the last TX actually
// completes before we start a new one.
Thread.Sleep(250);
}
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull(MSG_COUNT * BATCH_COUNT);
// check messages are NOT present in the queue
VerifyNoMessagesInQueue();
}
public void TestConnectionFactorySetParams(
[Values("tcp://${activemqhost}:61616", "activemq:tcp://${activemqhost}:61616")]
string connectionURI,
[Values(AcknowledgementMode.ClientAcknowledge, AcknowledgementMode.AutoAcknowledge)]
AcknowledgementMode ackMode,
[Values(true, false)]
bool asyncSend,
[Values(true, false)]
bool alwaysSyncSend,
[Values(true, false)]
bool asyncClose,
[Values(true, false)]
bool copyMessageOnSend,
[Values(3000, 1000)]
int requestTimeout,
[Values(true, false)]
bool sendAcksAsync,
[Values(true, false)]
bool dispatchAsync)
{
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
factory.AcknowledgementMode = ackMode;
factory.AsyncSend = asyncSend;
factory.AlwaysSyncSend = alwaysSyncSend;
factory.AsyncClose = asyncClose;
factory.CopyMessageOnSend = copyMessageOnSend;
factory.RequestTimeout = requestTimeout;
factory.SendAcksAsync = sendAcksAsync;
factory.DispatchAsync = dispatchAsync;
using (Connection connection = factory.CreateConnection() as Connection)
{
Assert.AreEqual(ackMode, connection.AcknowledgementMode);
Assert.AreEqual(asyncSend, connection.AsyncSend);
Assert.AreEqual(alwaysSyncSend, connection.AlwaysSyncSend);
Assert.AreEqual(asyncClose, connection.AsyncClose);
Assert.AreEqual(copyMessageOnSend, connection.CopyMessageOnSend);
Assert.AreEqual(requestTimeout, connection.RequestTimeout.TotalMilliseconds);
Assert.AreEqual(sendAcksAsync, connection.SendAcksAsync);
Assert.AreEqual(dispatchAsync, connection.DispatchAsync);
}
}
static void Main(string[] args)
{
var connectionFactory = new NetTxConnectionFactory("failover:(tcp://localhost:61616,tcp://localhost:61616)?randomize=false&timeout=5000")
{
AcknowledgementMode = AcknowledgementMode.Transactional,
PrefetchPolicy = { QueuePrefetch = 1, TopicPrefetch = 1, DurableTopicPrefetch = 1 }
};
using (var connection = connectionFactory.CreateNetTxConnection())
{
connection.Start();
using (var session = connection.CreateSession())
using (var consumer = CreateResponseConsumer(session))
{
RunProducer(connection);
}
connection.Stop();
}
}
public void TestConfigureRecoveryPolicyLoggerType(
[Values("tcp://${activemqhost}:61616?nms.RecoveryPolicy.RecoveryLoggerType=file")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
NetTxConnection netTxConnection = connection as NetTxConnection;
Assert.IsNotNull(netTxConnection);
NetTxRecoveryPolicy policy = netTxConnection.RecoveryPolicy;
Assert.AreEqual("file", policy.RecoveryLoggerType);
RecoveryFileLogger logger = policy.RecoveryLogger as RecoveryFileLogger;
Assert.IsNotNull(logger);
Assert.AreEqual(Directory.GetCurrentDirectory(), logger.Location);
}
}
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 TestTransactedDBReadAndProduce()
{
// 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();
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestRecoverAfterTransactionScopeAborted()
{
// 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();
ReadFromDbAndProduceToQueueWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsFull();
// check messages are NOT present in the queue
VerifyNoMessagesInQueue();
}
public void TestTransactedDBReadAndProduce()
{
// 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();
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestTransacteDequeueAndDbWrite()
{
// Test initialize - Fills in DB with data to send.
PurgeDatabase();
PurgeAndFillQueue();
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction and stored all messages
VerifyDatabaseTableIsFull();
// check no messages are present in the queue after commit.
VerifyNoMessagesInQueueNoRecovery();
}
public void TestRecoverAfterTransactionScopeAborted()
{
// 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())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestTransacteDequeueAndDbWrite()
{
// Test initialize - Fills in DB with data to send.
PurgeDatabase();
PurgeAndFillQueue();
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction and stored all messages
VerifyDatabaseTableIsFull();
// check no messages are present in the queue after commit.
VerifyNoMessagesInQueueNoRecovery();
}
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 TestIterativeTransactedConsume()
{
// Test initialize - Fills in queue with data to send and clears the DB.
PurgeDatabase();
PurgeAndFillQueue(5 * MSG_COUNT);
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
ReadFromQueueAndInsertIntoDbWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull(5 * MSG_COUNT);
// check messages are NOT present in the queue
VerifyNoMessagesInQueueNoRecovery();
}
public void TestRecoveryAfterCommitFailsAfterSent()
{
// 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())
{
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 TestRecoverAfterRollbackFailWhenScopeAborted()
{
// 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.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 TestIterativeTransactedProduceWithDBDelete()
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.ExceptionListener += this.OnException;
connection.Start();
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
PrepareDatabase();
ReadFromDbAndProduceToQueueWithCommit(connection);
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount(MSG_COUNT * 5);
}
protected static void VerifyBrokerHasMessagesInQueue(string connectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
// check messages are present in the queue
using (INetTxSession session = connection.CreateNetTxSession())
{
IDestination queue = session.GetQueue(testQueueName);
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
connection.Start();
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "message is not in the queue !");
}
consumer.Close();
}
}
}
}
protected static void VerifyBrokerQueueCount(int expectedCount, string connectionUri)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionUri));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
// check messages are present in the queue
using (INetTxSession session = connection.CreateNetTxSession())
{
IQueue queue = session.GetQueue(testQueueName);
using (IQueueBrowser browser = session.CreateBrowser(queue))
{
connection.Start();
int count = 0;
IEnumerator enumerator = browser.GetEnumerator();
while (enumerator.MoveNext())
{
IMessage msg = enumerator.Current as IMessage;
Assert.IsNotNull(msg, "message is not in the queue !");
count++;
}
// count should match the expected count
Assert.AreEqual(expectedCount, count);
}
}
}
}
public void TestNoRecoverAfterFailOnTransactionWhenLogWriteFails()
{
// Test initialize - Fills in DB with data to send.
PrepareDatabase();
const string newConnectionUri =
connectionURI + "?nms.RecoveryPolicy.RecoveryLoggerType=harness";
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(newConnectionUri));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
IRecoveryLogger logger = (connection as NetTxConnection).RecoveryPolicy.RecoveryLogger;
Assert.IsNotNull(logger);
RecoveryLoggerHarness harness = logger as RecoveryLoggerHarness;
Assert.IsNotNull(harness);
harness.PreLogRecoveryInfoEvent += FailOnPreLogRecoveryHook;
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromDbAndProduceToQueueWithCommit(connection);
Thread.Sleep(2000);
}
// verify sql server has not commited the transaction
VerifyDatabaseTableIsFull();
// check messages are not present in the queue
VerifyNoMessagesInQueue();
}
public void TestTransactedAsyncConsumption()
{
PurgeDatabase();
PurgeAndFillQueue(MSG_COUNT * BATCH_COUNT);
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(connectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
using (NetTxSession session = connection.CreateNetTxSession() as NetTxSession)
{
IQueue queue = session.GetQueue(testQueueName);
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += AsyncTxAwareOnMessage;
// Be carefull, message are dispatched once this is done, so you could receive
// a Message outside a TX. We use the awaitBatchProcessingStart event here to
// gate te OnMessage callback, once that method returns the Message is ack'd and
// no longer has a chance to participate in a TX.
connection.Start();
for (int i = 0; i < BATCH_COUNT; ++i)
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
session.Enlist(Transaction.Current);
batchTxControl = Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
awaitBatchProcessingStart.Set();
scoped.Complete();
}
// Reenlisting to fast seems to annoy the DTC. Also since DTC operations are
// async we need to allow a little time for lag so that the last TX actually
// completes before we start a new one.
Thread.Sleep(250);
}
}
// verify sql server has commited the transaction
VerifyDatabaseTableIsFull(MSG_COUNT * BATCH_COUNT);
// check messages are NOT present in the queue
VerifyNoMessagesInQueue();
}
public void TestRecoverAfterTransactionScopeAborted()
{
// 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())
{
connection.ExceptionListener += this.OnException;
connection.Start();
ReadFromQueueAndInsertIntoDbWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsEmpty();
// check messages are present in the queue
VerifyBrokerQueueCount();
}
public void TestTransactedProduceConsumeWithSessionClose(
[Values("tcp://${activemqhost}:61616")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
IDestination destination = null;
using (INetTxSession session = connection.CreateNetTxSession())
{
destination = session.CreateTemporaryQueue();
using (IMessageProducer producer = session.CreateProducer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
Assert.IsNotNull(Transaction.Current);
for (int i = 0; i < MSG_COUNT; ++i)
{
producer.Send(session.CreateTextMessage("Hello World"));
}
scoped.Complete();
}
session.Close();
}
}
using (INetTxSession session = connection.CreateNetTxSession())
{
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "Message was null for index: " + i);
}
scoped.Complete();
}
session.Close();
}
}
using (INetTxSession session = connection.CreateNetTxSession())
{
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(50));
Assert.IsNull(msg, "Message was not null for index: " + i);
}
}
session.Close();
}
connection.Close();
}
}
public void TestRecoverAfterFailOnTransactionAfterPrepareSent()
{
// 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.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
VerifyBrokerQueueCount();
}
public void TestRecoverAfterTransactionScopeAborted()
{
// 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();
ReadFromDbAndProduceToQueueWithScopeAborted(connection);
Thread.Sleep(2000);
}
// verify sql server has NOT commited the transaction
VerifyDatabaseTableIsFull();
// check messages are NOT present in the queue
VerifyNoMessagesInQueue();
}
public void TestTransactedProduceConsumeWithSessionClose(
[Values("tcp://${activemqhost}:61616")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
IDestination destination = null;
using (INetTxSession session = connection.CreateNetTxSession())
{
session.TransactionStartedListener += TransactionStarted;
session.TransactionCommittedListener += TransactionCommitted;
session.TransactionRolledBackListener += TransactionRolledBack;
destination = session.CreateTemporaryQueue();
using (IMessageProducer producer = session.CreateProducer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
Assert.IsFalse(this.transactionStarted);
Assert.IsNotNull(Transaction.Current);
for (int i = 0; i < MSG_COUNT; ++i)
{
producer.Send(session.CreateTextMessage("Hello World"));
}
Assert.IsTrue(this.transactionStarted, "A TX should have been started by producing");
scoped.Complete();
}
Assert.IsFalse(this.transactionStarted, "TX Should have Committed and cleared Started");
Assert.IsTrue(this.transactionCommitted, "TX Should have Committed");
Assert.IsFalse(this.transactionRolledBack, "TX Should not have Rolledback");
session.Close();
}
}
using (INetTxSession session = connection.CreateNetTxSession())
{
session.TransactionStartedListener += TransactionStarted;
session.TransactionCommittedListener += TransactionCommitted;
session.TransactionRolledBackListener += TransactionRolledBack;
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
Assert.IsFalse(this.transactionStarted);
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "Message was null for index: " + i);
}
Assert.IsTrue(this.transactionStarted, "A TX should have been started by consuming");
scoped.Complete();
}
Assert.IsFalse(this.transactionStarted, "TX Should have Committed and cleared Started");
Assert.IsTrue(this.transactionCommitted, "TX Should have Committed");
Assert.IsFalse(this.transactionRolledBack, "TX Should not have Rolledback");
session.Close();
}
}
using (INetTxSession session = connection.CreateNetTxSession())
{
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(50));
Assert.IsNull(msg, "Message was not null for index: " + i);
}
}
session.Close();
}
connection.Close();
}
}
public void TestRecoverAfterRollbackFailWhenScopeAborted()
{
// 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())
{
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
VerifyBrokerQueueCount();
}
public void TestConsumeWithDBInsertLogLocation()
{
const string logLocation = @".\RecoveryDir";
const string newConnectionUri =
connectionURI + "?nms.RecoveryPolicy.RecoveryLogger.Location=" + logLocation;
// 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);
INetTxConnectionFactory factory = new NetTxConnectionFactory(ReplaceEnvVar(newConnectionUri));
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;
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
VerifyBrokerQueueCount(0, newConnectionUri);
Assert.AreEqual(0, Directory.GetFiles(logLocation).Length);
}
