public async Task When_a_group_is_forwarded_the_status_is_Completed()
{
var domainEvents = new FakeDomainEvents();
var retryManager = new RetryingManager(domainEvents);
using (var documentStore = InMemoryStoreBuilder.GetInMemoryStore())
{
await CreateAFailedMessageAndMarkAsPartOfRetryBatch(documentStore, retryManager, "Test-group", true, 1);
var sender = new TestSender();
var bodyStorage = new RavenAttachmentsBodyStorage
{
DocumentStore = documentStore
};
var returnToSender = new TestReturnToSenderDequeuer(new ReturnToSender(bodyStorage), documentStore, domainEvents, "TestEndpoint");
var processor = new RetryProcessor(sender, domainEvents, returnToSender, retryManager);
using (var session = documentStore.OpenAsyncSession())
{
await processor.ProcessBatches(session, CancellationToken.None); // mark ready
await session.SaveChangesAsync();
await processor.ProcessBatches(session, CancellationToken.None);
await session.SaveChangesAsync();
}
var status = retryManager.GetStatusForRetryOperation("Test-group", RetryType.FailureGroup);
Assert.AreEqual(RetryState.Completed, status.RetryState);
}
}
public async Task When_a_group_is_prepared_with_three_batches_and_SC_is_restarted_while_the_first_group_is_being_forwarded_then_the_count_still_matches()
{
var domainEvents = new FakeDomainEvents();
var retryManager = new RetryingManager(domainEvents);
RetryingManager.RetryOperations = new Dictionary <string, InMemoryRetry>();
using (var documentStore = InMemoryStoreBuilder.GetInMemoryStore())
{
CreateAFailedMessageAndMarkAsPartOfRetryBatch(documentStore, retryManager, "Test-group", true, 2001);
new RetryBatches_ByStatus_ReduceInitialBatchSize().Execute(documentStore);
var sender = new TestSender();
var bodyStorage = new RavenAttachmentsBodyStorage
{
DocumentStore = documentStore
};
var settingsHolder = new NServiceBus.Settings.SettingsHolder();
settingsHolder.Set("EndpointName", "TestEndpoint");
var configure = new Configure(settingsHolder, new TestContainer(), new List <Action <NServiceBus.ObjectBuilder.IConfigureComponents> >(), new NServiceBus.Pipeline.PipelineSettings(new BusConfiguration()));
var processor = new RetryProcessor(sender, domainEvents, new TestReturnToSenderDequeuer(bodyStorage, sender, documentStore, domainEvents, configure), retryManager);
documentStore.WaitForIndexing();
using (var session = documentStore.OpenAsyncSession())
{
await processor.ProcessBatches(session, CancellationToken.None); // mark ready
await session.SaveChangesAsync();
// Simulate SC restart
retryManager = new RetryingManager(domainEvents);
RetryingManager.RetryOperations = new Dictionary <string, InMemoryRetry>();
var documentManager = new CustomRetryDocumentManager(false, documentStore)
{
OperationManager = retryManager
};
await documentManager.RebuildRetryOperationState(session);
processor = new RetryProcessor(sender, domainEvents, new TestReturnToSenderDequeuer(bodyStorage, sender, documentStore, domainEvents, configure), retryManager);
await processor.ProcessBatches(session, CancellationToken.None);
await session.SaveChangesAsync();
}
var status = retryManager.GetStatusForRetryOperation("Test-group", RetryType.FailureGroup);
Assert.AreEqual(2001, status.TotalNumberOfMessages);
}
}
public async Task When_there_is_one_poison_message_it_is_removed_from_batch_and_the_status_is_Complete()
{
var domainEvents = new FakeDomainEvents();
var retryManager = new RetryingManager(domainEvents);
using (var documentStore = InMemoryStoreBuilder.GetInMemoryStore())
{
await CreateAFailedMessageAndMarkAsPartOfRetryBatch(documentStore, retryManager, "Test-group", true, "A", "B", "C");
var sender = new TestSender();
sender.Callback = operation =>
{
//Always fails staging message B
if (operation.Message.MessageId == "FailedMessages/B")
{
throw new Exception("Simulated");
}
};
var bodyStorage = new RavenAttachmentsBodyStorage
{
DocumentStore = documentStore
};
var returnToSender = new TestReturnToSenderDequeuer(new ReturnToSender(bodyStorage), documentStore, domainEvents, "TestEndpoint");
var processor = new RetryProcessor(documentStore, sender, domainEvents, returnToSender, retryManager);
bool c;
do
{
try
{
using (var session = documentStore.OpenAsyncSession())
{
c = await processor.ProcessBatches(session, CancellationToken.None);
await session.SaveChangesAsync();
}
}
catch (Exception)
{
//Continue trying until there is no exception -> poison message is removed from the batch
c = true;
}
} while (c);
var status = retryManager.GetStatusForRetryOperation("Test-group", RetryType.FailureGroup);
Assert.AreEqual(RetryState.Completed, status.RetryState);
Assert.AreEqual(3, status.NumberOfMessagesPrepared);
Assert.AreEqual(2, status.NumberOfMessagesForwarded);
Assert.AreEqual(1, status.NumberOfMessagesSkipped);
}
}
private static void AssertRetryProcessorReportsContinue(HistoryEvent[] history, int firstEventIndex, int maxNumberOfAttempts)
{
var shouldRetry = RetryProcessor.Process(
history,
history[firstEventIndex],
maxNumberOfAttempts,
onSuccess: result => { Assert.True(false, $"Unexpected output: {result}"); },
onFinalFailure: reason => { Assert.True(false, $"Unexpected failure: {reason}"); });
Assert.True(shouldRetry);
}
public async Task ProcessFullFailure()
{
var processor = Substitute.For <IProcessor <int> >();
processor.Process(1).Returns(false);
var rp = new RetryProcessor <int>(processor);
var result = await rp.Process(1);
Assert.IsFalse(result);
processor.Received(3).Process(1);
}
public async Task Process()
{
var processor = Substitute.For <IProcessor <int> >();
processor.Process(1).Returns(true);
var rp = new RetryProcessor <int>(processor);
var result = await rp.Process(1);
Assert.IsTrue(result);
processor.Received().Process(1);
}
public async Task ProcessSingleFailure()
{
var processor = Substitute.For <IProcessor <int> >();
processor.Process(1).Returns(false, true);
var rp = new RetryProcessor <int>(processor);
var result = await rp.Process(1);
Assert.IsTrue(result);
await processor.Received(2).Process(1);
}
private static void AssertRetryProcessorReportsSuccess(HistoryEvent[] history, int firstEventIndex, int maxNumberOfAttempts, string expectedOutput)
{
string actualOutput = null;
var shouldRetry = RetryProcessor.Process(
history,
history[firstEventIndex],
maxNumberOfAttempts,
onSuccess: result =>
{
Assert.Null(actualOutput);
actualOutput = result;
},
onFinalFailure: reason => { Assert.True(false, $"Unexpected failure: {reason}"); });
Assert.False(shouldRetry);
Assert.Equal(expectedOutput, actualOutput);
}
public async Task When_a_group_has_one_batch_out_of_two_forwarded_the_status_is_Forwarding()
{
var domainEvents = new FakeDomainEvents();
var retryManager = new RetryingManager(domainEvents);
RetryingManager.RetryOperations = new Dictionary <string, InMemoryRetry>();
using (var documentStore = InMemoryStoreBuilder.GetInMemoryStore())
{
CreateAFailedMessageAndMarkAsPartOfRetryBatch(documentStore, retryManager, "Test-group", true, 1001);
var bodyStorage = new RavenAttachmentsBodyStorage
{
DocumentStore = documentStore
};
var sender = new TestSender();
var settingsHolder = new NServiceBus.Settings.SettingsHolder();
settingsHolder.Set("EndpointName", "TestEndpoint");
var configure = new Configure(settingsHolder, new TestContainer(), new List <Action <NServiceBus.ObjectBuilder.IConfigureComponents> >(), new NServiceBus.Pipeline.PipelineSettings(new BusConfiguration()));
var processor = new RetryProcessor(sender, domainEvents, new TestReturnToSenderDequeuer(bodyStorage, sender, documentStore, domainEvents, configure), retryManager);
documentStore.WaitForIndexing();
using (var session = documentStore.OpenAsyncSession())
{
await processor.ProcessBatches(session, CancellationToken.None); // mark ready
await session.SaveChangesAsync();
await processor.ProcessBatches(session, CancellationToken.None);
await session.SaveChangesAsync();
}
var status = retryManager.GetStatusForRetryOperation("Test-group", RetryType.FailureGroup);
Assert.AreEqual(RetryState.Forwarding, status.RetryState);
}
}
public void When_a_group_is_forwarded_the_status_is_Completed()
{
var retryManager = new RetryingManager();
RetryingManager.RetryOperations = new Dictionary <string, InMemoryRetry>();
using (var documentStore = InMemoryStoreBuilder.GetInMemoryStore())
{
CreateAFailedMessageAndMarkAsPartOfRetryBatch(documentStore, retryManager, "Test-group", true, 1);
var testBus = new TestBus();
var sender = new TestSender();
var bodyStorage = new RavenAttachmentsBodyStorage
{
DocumentStore = documentStore
};
var settingsHolder = new NServiceBus.Settings.SettingsHolder();
settingsHolder.Set("EndpointName", "TestEndpoint");
var configure = new Configure(settingsHolder, new TestContainer(), new List <Action <NServiceBus.ObjectBuilder.IConfigureComponents> >(), new NServiceBus.Pipeline.PipelineSettings(new BusConfiguration()));
var returnToSender = new TestReturnToSenderDequeuer(bodyStorage, sender, documentStore, testBus, configure);
var processor = new RetryProcessor(sender, testBus, returnToSender, retryManager);
using (var session = documentStore.OpenSession())
{
processor.ProcessBatches(session, CancellationToken.None); // mark ready
session.SaveChanges();
processor.ProcessBatches(session, CancellationToken.None);
session.SaveChanges();
}
var status = retryManager.GetStatusForRetryOperation("Test-group", RetryType.FailureGroup);
Assert.AreEqual(RetryState.Completed, status.RetryState);
}
}
static void Main(string[] args)
{
Console.WriteLine(@" _____ _ _____ _ ");
Console.WriteLine(@" / ____| Sitecore | | |_ _| | | ");
Console.WriteLine(@"| (___ ___ __ _ _ __ ___| |__ | | _ __ __| | _____ _ ");
Console.WriteLine(@" \___ \ / _ \/ _` | '__/ __| '_ \ | | | '_ \ / _` |/ _ \ \/ /");
Console.WriteLine(@" ____) | __/ (_| | | | (__| | | |_| |_| | | | (_| | __/> < ");
Console.WriteLine(@"|_____/ \___|\__,_|_| \___|_| |_|_____|_| |_|\__,_|\___/_/\_\");
Console.WriteLine(@" Builder ");
var parser = new Parser(s => {
s.HelpWriter = Console.Error;
s.CaseSensitive = false;
});
parser
.ParseArguments <DeployOptions, SetupOptions, ConvertOptions, IndexingOptions, RetryOptions, RemoveOptions>(args)
.WithParsed <DeployOptions>(o => DeployProcessor.RunProcess(o))
.WithParsed <SetupOptions>(o => SetupProcessor.RunProcess(o))
.WithParsed <ConvertOptions>(o => ConvertProcessor.RunProcess(o))
.WithParsed <IndexingOptions>(o => IndexingProcessor.RunProcess(o))
.WithParsed <RetryOptions>(o => RetryProcessor.RunProcess(o))
.WithParsed <RemoveOptions>(o => RemoveProcessor.RunProcess(o));
}
