public void Send()
{
while (continueSending)
{
IList <PersistentMessage> messages = null;
//normal conditions will be at 5, when there are several unreliable endpoints
//it will grow up to 31 connections all attempting to connect, timeouts can take up to 30 seconds
if ((currentlySendingCount - currentlyConnecting > 5) || currentlyConnecting > 30)
{
lock (@lock)
Monitor.Wait(@lock, TimeSpan.FromSeconds(1));
continue;
}
Endpoint point = null;
queueStorage.Send(actions =>
{
messages = actions.GetMessagesToSendAndMarkThemAsInFlight(100, 1024 * 1024, out point);
actions.Commit();
});
if (messages.Count == 0)
{
lock (@lock)
Monitor.Wait(@lock, TimeSpan.FromSeconds(1));
continue;
}
Interlocked.Increment(ref currentlySendingCount);
Interlocked.Increment(ref currentlyConnecting);
new Sender
{
Connected = () => Interlocked.Decrement(ref currentlyConnecting),
Destination = point,
Messages = messages.ToArray(),
Success = OnSuccess(messages),
Failure = OnFailure(point, messages),
FailureToConnect = e =>
{
Interlocked.Decrement(ref currentlyConnecting);
OnFailure(point, messages)(e);
},
Revert = OnRevert(point),
Commit = OnCommit(point, messages)
}.Send();
}
}
public void Send()
{
while (continueSending)
{
IList <PersistentMessage> messages = null;
if (currentlySendingCount > 5)
{
lock (@lock)
Monitor.Wait(@lock, TimeSpan.FromSeconds(1));
continue;
}
Endpoint point = null;
queueStorage.Send(actions =>
{
messages = actions.GetMessagesToSendAndMarkThemAsInFlight(100, 1024 * 1024, out point);
actions.Commit();
});
if (messages.Count == 0)
{
lock (@lock)
Monitor.Wait(@lock, TimeSpan.FromSeconds(1));
continue;
}
#pragma warning disable 420
Interlocked.Increment(ref currentlySendingCount);
#pragma warning restore 420
new Sender
{
Destination = point,
Messages = messages.ToArray(),
Success = OnSuccess(messages),
Failure = OnFailure(point, messages),
Revert = OnRevert(point)
}.Send();
}
}
public void WaitForAllMessagesToBeSent()
{
_waitingForAllMessagesToBeSent = true;
try
{
bool hasMessagesToSend;
do
{
hasMessagesToSend = _queueStorage.Send(actions => actions.HasMessagesToSend());
if (hasMessagesToSend)
{
Thread.Sleep(100);
}
} while (hasMessagesToSend);
}
finally
{
_waitingForAllMessagesToBeSent = false;
}
}
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 WaitForAllMessagesToBeSent()
{
waitingForAllMessagesToBeSent = true;
try
{
var hasMessagesToSend = true;
do
{
queueStorage.Send(actions =>
{
hasMessagesToSend = actions.HasMessagesToSend();
actions.Commit();
});
if (hasMessagesToSend)
{
Thread.Sleep(100);
}
} while (hasMessagesToSend);
}
finally
{
waitingForAllMessagesToBeSent = false;
}
}
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 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 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);
});
}
}
private IEnumerable <Endpoint> gatherEndpoints(IEnumerable <Endpoint> currentlySending)
{
return(_queueStorage.Send(actions => actions.GetEndpointsToSend(currentlySending, _choke.AvailableSendingCount)));
}
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"));
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);
});
}
}
