public void CanCreateNewQueueFactory()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
}
}
protected QueueTest(string connectionStringName)
{
var connectionStringBuilder =
new SqlConnectionStringBuilder(ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString);
var databaseName = connectionStringBuilder.InitialCatalog;
connectionStringBuilder.InitialCatalog = "master";
using (var connection = new SqlConnection(connectionStringBuilder.ConnectionString))
{
connection.Open();
using (var createCommand = new SqlCommand(
@"
IF ((SELECT DB_ID ('<databasename, sysname, queuedb>')) IS NULL)
BEGIN
CREATE DATABASE [<databasename, sysname, queuedb>]
END" .Replace("<databasename, sysname, queuedb>", databaseName), connection))
{
createCommand.CommandType = CommandType.Text;
createCommand.ExecuteNonQuery();
}
}
try
{
var storage = new QueueStorage(connectionStringName);
storage.Initialize();
}
catch (SqlException)
{
new SchemaCreator().Create(connectionStringName, 2204);
}
StorageUtil.PurgeAll(connectionStringName);
}
public QueueManager(string connectionStringName)
{
queueStorage = new QueueStorage(connectionStringName);
queueStorage.Initialize();
purgeOldDataTimer = new Timer(PurgeOldData, null, TimeSpan.FromMinutes(3), TimeSpan.FromMinutes(3));
}
public void WillGetMessagesBackInOrder()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("h");
actions.Commit();
});
qf.Global(actions =>
{
var queue = actions.GetQueue("h");
var bookmark = queue.Enqueue(new Message
{
Queue = "h",
Id = MessageId.GenerateRandom(),
Data = new byte[] { 1 },
});
queue.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
bookmark = queue.Enqueue(new Message
{
Queue = "h",
Id = MessageId.GenerateRandom(),
Data = new byte[] { 2 },
});
queue.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
bookmark = queue.Enqueue(new Message
{
Queue = "h",
Id = MessageId.GenerateRandom(),
Data = new byte[] { 3 },
});
queue.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
actions.Commit();
});
qf.Global(actions =>
{
var m1 = actions.GetQueue("h").Dequeue(null);
var m2 = actions.GetQueue("h").Dequeue(null);
var m3 = actions.GetQueue("h").Dequeue(null);
Assert.Equal(new byte[] { 1 }, m1.Data);
Assert.Equal(new byte[] { 2 }, m2.Data);
Assert.Equal(new byte[] { 3 }, m3.Data);
actions.Commit();
});
}
}
public CanUseQueue() : base("testqueue")
{
qf = new QueueStorage("testqueue");
qf.Initialize();
qf.Global(actions =>
{
actions.BeginTransaction();
actions.CreateQueue(queueUri);
actions.Commit();
});
}
public void MovesMessageToOutgoingHistoryAfterMaxAttempts()
{
Directory.Delete("test.esent", true);
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
DeliverBy = null,
Headers = new NameValueCollection(),
MaxAttempts = 1
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
actions.MarkOutgoingMessageAsFailedTransmission(msgs.First().Bookmark, false);
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.Empty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
PersistentMessageToSend message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
Assert.NotNull(message);
Assert.Equal(OutgoingMessageStatus.Failed, message.OutgoingStatus);
actions.Commit();
});
}
}
public void MovesMessageToOutgoingFromHistory()
{
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("test");
actions.Commit();
});
var testMessage = new MessagePayload
{
Data = new byte[0],
Headers = new NameValueCollection(),
};
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
actions.Commit();
});
qf.Send(actions =>
{
Endpoint endpoint;
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
var bookmark = actions.MarkOutgoingMessageAsSuccessfullySent(msgs[0].Bookmark);
actions.RevertBackToSend(new[] { bookmark });
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, out endpoint);
Assert.NotEmpty(msgs);
actions.Commit();
});
qf.Global(actions =>
{
var messages = actions.GetSentMessages();
Assert.Empty(messages);
actions.Commit();
});
}
}
public void CanPutSingleMessageInQueue()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("h");
actions.Commit();
});
MessageBookmark bookmark = null;
var guid = Guid.NewGuid();
var identifier = Guid.NewGuid();
qf.Global(actions =>
{
bookmark = actions.GetQueue("h").Enqueue(new Message
{
Queue = "h",
Data = new byte[] { 13, 12, 43, 5 },
SentAt = new DateTime(2004, 5, 5),
Id = new MessageId {
SourceInstanceId = guid, MessageIdentifier = identifier
}
});
actions.Commit();
});
qf.Global(actions =>
{
actions.GetQueue("h").SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
actions.Commit();
});
qf.Global(actions =>
{
var message = actions.GetQueue("h").Dequeue(null);
Assert.Equal(new byte[] { 13, 12, 43, 5 }, message.Data);
Assert.Equal(identifier, message.Id.MessageIdentifier);
Assert.Equal(guid, message.Id.SourceInstanceId);
Assert.Equal("h", message.Queue);
Assert.Equal(new DateTime(2004, 5, 5), message.SentAt);
actions.Commit();
});
}
}
public QueueManager(IPEndPoint endpoint, string path, QueueManagerConfiguration configuration, ILogger logger = null)
{
Configuration = configuration;
_endpoint = endpoint;
_path = path;
_logger = logger ?? LogManager.GetLogger(GetType());
_queueStorage = new QueueStorage(path, configuration);
_queueStorage.Initialize();
_queueStorage.Global(actions =>
{
_receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());
});
HandleRecovery();
}
public QueueManager(IPEndPoint endpoint, string path, QueueManagerConfiguration configuration, ILogger logger = null)
{
Configuration = configuration;
_endpoint = endpoint;
_path = path;
_logger = logger ?? LogManager.GetLogger(GetType());
_queueStorage = new QueueStorage(path, configuration);
_queueStorage.Initialize();
_queueStorage.Global(actions =>
{
_receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());
});
HandleRecovery();
}
public void MovesMessageToOutgoingHistoryAfterMaxAttempts()
{
Directory.Delete("test.esent", true);
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration(), ObjectMother.Logger()))
{
qf.Initialize();
qf.Global(actions => actions.CreateQueueIfDoesNotExists("test"));
var testMessage = new MessagePayload
{
Data = new byte[0],
DeliverBy = null,
Headers = new NameValueCollection(),
MaxAttempts = 1
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
});
qf.Send(actions =>
{
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
actions.MarkOutgoingMessageAsFailedTransmission(msgs.First().Bookmark, false);
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
msgs.ShouldHaveCount(0);
});
qf.Global(actions =>
{
PersistentMessageToSend message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
message.ShouldNotBeNull();
OutgoingMessageStatus.Failed.ShouldEqual(message.OutgoingStatus);
});
}
}
public QueueManager(IPEndPoint endpoint, string path, QueueManagerConfiguration configuration)
{
Configuration = configuration;
this.endpoint = endpoint;
this.path = path;
queueStorage = new QueueStorage(path, configuration);
queueStorage.Initialize();
queueStorage.Global(actions =>
{
receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());
actions.Commit();
});
HandleRecovery();
}
public void MovesMessageToOutgoingFromHistory()
{
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions => actions.CreateQueueIfDoesNotExists("test"));
var testMessage = new MessagePayload
{
Data = new byte[0],
Headers = new NameValueCollection(),
};
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
actions.RegisterToSend(new Endpoint("localhost", 0),
"test",
null,
testMessage,
transactionId);
actions.MarkAsReadyToSend(transactionId);
});
qf.Send(actions =>
{
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
var bookmark = actions.MarkOutgoingMessageAsSuccessfullySent(msgs[0].Bookmark);
actions.RevertBackToSend(new[] { bookmark });
msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
msgs.ShouldNotBeNull();
msgs.ShouldHaveCount(1);
});
qf.Global(actions =>
{
var messages = actions.GetSentMessages();
messages.ShouldHaveCount(0);
});
}
}
public void WillGiveNullWhenNoItemsAreInQueue()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
qf.Global(actions =>
{
actions.CreateQueueIfDoesNotExists("h");
actions.Commit();
});
qf.Global(actions =>
{
var message = actions.GetQueue("h").Dequeue(null);
Assert.Null(message);
actions.Commit();
});
}
}
public void CanDeleteOldEntries()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
var random = MessageId.GenerateRandom();
qf.Global(actions =>
{
for (int i = 0; i < 5; i++)
{
actions.MarkReceived(MessageId.GenerateRandom());
}
actions.MarkReceived(random);
for (int i = 0; i < 5; i++)
{
actions.MarkReceived(MessageId.GenerateRandom());
}
actions.Commit();
});
qf.Global(actions =>
{
actions.DeleteOldestReceivedMessages(6).ToArray(); //consume & activate
actions.Commit();
});
qf.Global(actions =>
{
var array = actions.GetAlreadyReceivedMessageIds().ToArray();
Assert.Equal(6, array.Length);
Assert.Equal(random, array[0]);
actions.Commit();
});
}
}
public void CanRegisterReceivedMessageIds()
{
using (var qf = new QueueStorage("test.esent"))
{
qf.Initialize();
var random = MessageId.GenerateRandom();
qf.Global(actions =>
{
actions.MarkReceived(random);
actions.Commit();
});
qf.Global(actions =>
{
Assert.True(actions.GetAlreadyReceivedMessageIds().Contains(random));
actions.Commit();
});
}
}
public void MovesExpiredMessageToOutgoingHistory()
{
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration()))
{
qf.Initialize();
qf.Global(actions => actions.CreateQueueIfDoesNotExists("test"));
var testMessage = new MessagePayload{
Data = new byte[0],
DeliverBy = DateTime.Now.AddSeconds(-1),
Headers = new NameValueCollection(),
MaxAttempts = null
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0), "test", null, testMessage, transactionId);
actions.MarkAsReadyToSend(transactionId);
});
qf.Send(actions =>
{
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
msgs.ShouldHaveCount(0);
});
qf.Global(actions =>
{
var message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
message.ShouldNotBeNull();
OutgoingMessageStatus.Failed.ShouldEqual(message.OutgoingStatus);
});
}
}
public void MovesExpiredMessageToOutgoingHistory()
{
using (var qf = new QueueStorage("test.esent", new QueueManagerConfiguration(), ObjectMother.Logger()))
{
qf.Initialize();
qf.Global(actions => actions.CreateQueueIfDoesNotExists("test"));
var testMessage = new MessagePayload {
Data = new byte[0],
DeliverBy = DateTime.Now.AddSeconds(-1),
Headers = new NameValueCollection(),
MaxAttempts = null
};
Guid messageId = Guid.Empty;
qf.Global(actions =>
{
Guid transactionId = Guid.NewGuid();
messageId = actions.RegisterToSend(new Endpoint("localhost", 0), "test", null, testMessage, transactionId);
actions.MarkAsReadyToSend(transactionId);
});
qf.Send(actions =>
{
var msgs = actions.GetMessagesToSendAndMarkThemAsInFlight(int.MaxValue, int.MaxValue, new Endpoint("localhost", 0));
msgs.ShouldHaveCount(0);
});
qf.Global(actions =>
{
var message = actions.GetSentMessages().FirstOrDefault(x => x.Id.MessageIdentifier == messageId);
message.ShouldNotBeNull();
OutgoingMessageStatus.Failed.ShouldEqual(message.OutgoingStatus);
});
}
}
public QueueManager(IPEndPoint endpoint, string path)
{
NumberOfMessagesToKeepInProcessedQueues = 100;
NumberOfMessagesToKeepOutgoingQueues = 100;
NumberOfReceivedMessagesToKeep = 100000;
OldestMessageInProcessedQueues = TimeSpan.FromDays(3);
OldestMessageInOutgoingQueues = TimeSpan.FromDays(3);
this.endpoint = endpoint;
this.path = path;
queueStorage = new QueueStorage(path);
queueStorage.Initialize();
queueStorage.Global(actions =>
{
receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());
actions.Commit();
});
receiver = new Receiver(endpoint, AcceptMessages);
receiver.Start();
HandleRecovery();
queuedMessagesSender = new QueuedMessagesSender(queueStorage, this);
sendingThread = new Thread(queuedMessagesSender.Send)
{
IsBackground = true,
Name = "Rhino Queue Sender Thread for " + path
};
sendingThread.Start();
purgeOldDataTimer = new Timer(PurgeOldData, null,
TimeSpan.FromMinutes(3),
TimeSpan.FromMinutes(3));
}
