public void Handle(ReclassifyErrors message) { if (Interlocked.Exchange(ref executing, 1) != 0) { // Prevent more then one execution at a time return; } try { using (var session = store.OpenSession()) { ReclassifyErrorSettings settings = null; if (!message.Force) { settings = session.Load <ReclassifyErrorSettings>(ReclassifyErrorSettings.IdentifierCase); if (settings != null && settings.ReclassificationDone) { logger.Info("Skipping reclassification of failures as classification has already been done."); return; } } logger.Info("Reclassification of failures started."); var query = session.Query <FailedMessage, FailedMessageViewIndex>() .Where(f => f.Status == FailedMessageStatus.Unresolved); var currentBatch = new List <Tuple <string, ClassifiableMessageDetails> >(); using (var stream = session.Advanced.Stream(query.As <FailedMessage>())) { while (!abort && stream.MoveNext()) { if (stream.Current.Document.FailureGroups.Count > 0) { continue; } currentBatch.Add(Tuple.Create(stream.Current.Document.Id, new ClassifiableMessageDetails(stream.Current.Document))); if (currentBatch.Count == BatchSize) { ReclassifyBatch(currentBatch); currentBatch.Clear(); } } } if (currentBatch.Any()) { ReclassifyBatch(currentBatch); } logger.Info("Reclassification of failures ended."); if (settings == null) { settings = new ReclassifyErrorSettings(); } settings.ReclassificationDone = true; session.Store(settings); session.SaveChanges(); } if (failedMessagesReclassified > 0) { bus.Publish(new ReclassificationOfErrorMessageComplete { NumberofMessageReclassified = failedMessagesReclassified }); } } finally { Interlocked.Exchange(ref executing, 0); } }
internal async Task <int> ReclassifyFailedMessages(IDocumentStore store, bool force, IEnumerable <IFailureClassifier> classifiers) { logger.Info("Reclassification of failures started."); var failedMessagesReclassified = 0; var currentBatch = new List <Tuple <string, ClassifiableMessageDetails> >(); using (var session = store.OpenAsyncSession()) { ReclassifyErrorSettings settings = null; if (!force) { settings = await session.LoadAsync <ReclassifyErrorSettings>(ReclassifyErrorSettings.IdentifierCase) .ConfigureAwait(false); if (settings != null && settings.ReclassificationDone) { logger.Info("Skipping reclassification of failures as classification has already been done."); return(0); } } var query = session.Query <FailedMessage, FailedMessageViewIndex>() .Where(f => f.Status == FailedMessageStatus.Unresolved); var totalMessagesReclassified = 0; using (var stream = await session.Advanced.StreamAsync(query.As <FailedMessage>()) .ConfigureAwait(false)) { while (!abort && await stream.MoveNextAsync().ConfigureAwait(false)) { currentBatch.Add(Tuple.Create(stream.Current.Document.Id, new ClassifiableMessageDetails(stream.Current.Document))); if (currentBatch.Count == BatchSize) { failedMessagesReclassified += ReclassifyBatch(store, currentBatch, classifiers); currentBatch.Clear(); totalMessagesReclassified += BatchSize; logger.Info($"Reclassification of batch of {BatchSize} failed messages completed. Total messages reclassified: {totalMessagesReclassified}"); } } } if (currentBatch.Any()) { ReclassifyBatch(store, currentBatch, classifiers); } logger.Info($"Reclassification of failures ended. Reclassified {failedMessagesReclassified} messages"); if (settings == null) { settings = new ReclassifyErrorSettings(); } settings.ReclassificationDone = true; await session.StoreAsync(settings).ConfigureAwait(false); await session.SaveChangesAsync().ConfigureAwait(false); return(failedMessagesReclassified); } }