private void PurgeOutgoingHistory()
{
// Outgoing messages are still stored in the history in case the sender
// needs to revert, so there will still be messages to purge even when
// the QueueManagerConfiguration has disabled outgoing history.
//
// To make this batchable:
// 1: Move to the end of the history (to the newest messages) and seek
// backword by NumberOfMessagesToKeepInOutgoingHistory.
// 2: Save a bookmark of the current position.
// 3: Delete from the beginning of the table (oldest messages) in batches until
// a) we reach the bookmark or b) we hit OldestMessageInOutgoingHistory.
MessageBookmark purgeLimit = null;
int numberOfMessagesToKeep = Configuration.NumberOfMessagesToKeepInOutgoingHistory;
if (numberOfMessagesToKeep > 0 && Configuration.EnableOutgoingMessageHistory)
{
queueStorage.Global(actions =>
{
purgeLimit = actions.GetSentMessageBookmarkAtPosition(numberOfMessagesToKeep);
actions.Commit();
});
if (purgeLimit == null)
{
return;
}
}
bool foundMessages = false;
do
{
foundMessages = false;
queueStorage.Global(actions =>
{
IEnumerable <PersistentMessageToSend> sentMessages = actions.GetSentMessages(batchSize: 250)
.TakeWhile(x => (purgeLimit == null || !x.Bookmark.Equals(purgeLimit)) &&
(!Configuration.EnableOutgoingMessageHistory || (DateTime.Now - x.SentAt) > Configuration.OldestMessageInOutgoingHistory));
foreach (var sentMessage in sentMessages)
{
foundMessages = true;
logger.DebugFormat("Purging sent message {0} to {1}/{2}/{3}", sentMessage.Id, sentMessage.Endpoint,
sentMessage.Queue, sentMessage.SubQueue);
actions.DeleteMessageToSendHistoric(sentMessage.Bookmark);
}
actions.Commit();
});
} while (foundMessages);
}
private void PurgeProcessedMessagesInQueue(string queue)
{
// To make this batchable:
// 1: Move to the end of the history (to the newest messages) and seek
// backword by NumberOfMessagesToKeepInProcessedHistory.
// 2: Save a bookmark of the current position.
// 3: Delete from the beginning of the table (oldest messages) in batches until
// a) we reach the bookmark or b) we hit OldestMessageInProcessedHistory.
MessageBookmark purgeLimit = null;
int numberOfMessagesToKeep = Configuration.NumberOfMessagesToKeepInProcessedHistory;
if (numberOfMessagesToKeep > 0)
{
queueStorage.Global(actions =>
{
var queueActions = actions.GetQueue(queue);
purgeLimit = queueActions.GetMessageHistoryBookmarkAtPosition(numberOfMessagesToKeep);
actions.Commit();
});
if (purgeLimit == null)
{
return;
}
}
bool foundMessages = false;
do
{
foundMessages = false;
queueStorage.Global(actions =>
{
var queueActions = actions.GetQueue(queue);
var messages = queueActions.GetAllProcessedMessages(batchSize: 250)
.TakeWhile(x => (purgeLimit == null || !x.Bookmark.Equals(purgeLimit)) &&
(DateTime.Now - x.SentAt) > Configuration.OldestMessageInProcessedHistory);
foreach (var message in messages)
{
foundMessages = true;
logger.DebugFormat("Purging message {0} from queue {1}/{2}", message.Id, message.Queue, message.SubQueue);
queueActions.DeleteHistoric(message.Bookmark);
}
actions.Commit();
});
} while (foundMessages);
}
public void CanPutSingleMessageInQueue()
{
using (var qf = CreateQueueStorage())
{
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 MessageBookmark MarkOutgoingMessageAsSuccessfullySent(MessageBookmark bookmark)
{
var path = bookmark.Bookmark;
if (!path.StartsWith(_outgoingPath))
return null;
if (!Directory.Exists(_outgoingHistoryPath))
Directory.CreateDirectory(_outgoingHistoryPath);
//var obj = JsonConvert.DeserializeObject<Outgoing>(File.ReadAllText(path));
var msgId = "msgId"; //obj.msgId;
var newBookmark = new MessageBookmark { Bookmark = FileUtil.MoveBase(path, _outgoingPath, _outgoingHistoryPath, OutgoingMessageStatus.Sent.ToString()) };
_logger.DebugFormat("Successfully sent output message {0}", msgId);
return newBookmark;
}
public PersistentMessage Peek(string subQueue)
{
var path = (string.IsNullOrEmpty(subQueue) ? _msgsPath : Path.Combine(_msgsPath, subQueue));
if (!Directory.Exists(path))
return null;
return Directory.EnumerateFiles(path, FileUtil.SearchMessageId(null, MessageStatus.ReadyToDeliver.ToString()))
.OrderBy(x => x)
.Select(x =>
{
var id = FileUtil.ToMessageId(x);
var status = FileUtil.ParseExtension<MessageStatus>(x);
_logger.DebugFormat("Scanning incoming message {2} on '{0}/{1}' with status {3}", _queueName, subQueue, id, status);
if (status != MessageStatus.ReadyToDeliver)
return null;
var obj = JsonConvert.DeserializeObject<QueueMsg>(File.ReadAllText(x));
var bookmark = new MessageBookmark { Bookmark = x, QueueName = _queueName };
_logger.DebugFormat("Peeking message {2} from '{0}/{1}'", _queueName, subQueue, id);
return new PersistentMessage
{
Bookmark = bookmark,
Headers = HttpUtility.ParseQueryString(obj.headers),
Queue = _queueName,
SentAt = File.GetCreationTime(x),
Data = obj.data,
Id = id,
SubQueue = subQueue,
Status = status,
};
})
.FirstOrDefault();
}
public void MarkOutgoingMessageAsFailedTransmission(MessageBookmark bookmark, bool queueDoesNotExistsInDestination)
{
var path = bookmark.Bookmark;
if (!path.StartsWith(_outgoingPath) && !File.Exists(path))
return;
var obj = JsonConvert.DeserializeObject<Outgoing>(File.ReadAllText(path));
var numOfRetries = obj.numberOfRetries;
var msgId = obj.msgId;
if (numOfRetries < 100 && !queueDoesNotExistsInDestination)
{
var timeToSend = DateTime.Now.AddSeconds(numOfRetries * numOfRetries);
obj.timeToSend = timeToSend;
obj.numberOfRetries++;
File.WriteAllText(path, JsonConvert.SerializeObject(obj));
bookmark.Bookmark = FileUtil.MoveExtension(path, OutgoingMessageStatus.Ready.ToString());
_logger.DebugFormat("Marking outgoing message {0} as failed with retries: {1}", msgId, numOfRetries);
}
else
MoveFailedMessageToOutgoingHistory(path, numOfRetries, msgId);
}
public void SetMessageStatus(MessageBookmark bookmark, MessageStatus status)
{
_messages.MoveTo(bookmark);
var id = _messages.GetMessageId();
_messages.Update(() => _messages.ForColumnType<IntColumn>().Set("status", (int)status));
_logger.Debug("Changing message {0} status to {1} on {2}",
id, status, _queueName);
}
public void DeleteHistoric(MessageBookmark bookmark)
{
_messageHistory.MoveTo(bookmark);
_messageHistory.Delete();
}
public void RegisterUpdateToReverse(Guid txId, MessageBookmark bookmark, MessageStatus statusToRestore, string subQueue)
{
var actualBookmark = bookmark.Bookmark.Take(bookmark.Size).ToArray();
var enumerator = txs.GetEnumerator(new BookmarkIndex(bookmark.Size, actualBookmark));
if(enumerator.MoveNext())
{
txs.Delete();
}
txs.Insert(() =>
{
txs.ForColumnType<GuidColumn>().Set("tx_id", txId);
txs.ForColumnType<IntColumn>().Set("bookmark_size", bookmark.Size);
txs.ForColumnType<BytesColumn>().Set("bookmark_data", actualBookmark);
txs.ForColumnType<IntColumn>().Set("value_to_restore", (int)statusToRestore);
txs.ForColumnType<StringColumn>().Set("queue", bookmark.QueueName);
txs.ForColumnType<StringColumn>().Set("subqueue", subQueue);
});
}
public void DeleteHistoric(MessageBookmark bookmark)
{
var path = bookmark.Bookmark;
if (File.Exists(path) && path.StartsWith(_msgsHistoryPath))
File.Delete(path);
}
public PersistentMessage PeekById(MessageId id)
{
var path = _msgsPath;
if (!Directory.Exists(path))
return null;
var msgsPathLength = _msgsPath.Length;
return Directory.EnumerateFiles(path, FileUtil.SearchMessageId(id, MessageStatus.ReadyToDeliver.ToString()), SearchOption.AllDirectories)
.OrderBy(x => x)
.Select(x =>
{
var subQueue = Path.GetDirectoryName(x).Substring(msgsPathLength);
var status = FileUtil.ParseExtension<MessageStatus>(x);
if (status != MessageStatus.ReadyToDeliver)
return null;
var obj = JsonConvert.DeserializeObject<QueueMsg>(File.ReadAllText(x));
var bookmark = new MessageBookmark { Bookmark = x, QueueName = _queueName };
return new PersistentMessage
{
Bookmark = bookmark,
Headers = HttpUtility.ParseQueryString(obj.headers),
Queue = _queueName,
SentAt = File.GetCreationTime(x),
Data = obj.data,
Id = id,
SubQueue = (string.IsNullOrEmpty(subQueue) ? null : subQueue),
Status = status,
};
})
.FirstOrDefault();
}
public void ReverseAllFrom(Guid transactionId)
{
var enumerator = txs.GetEnumerator(new GuidIndex(transactionId, "by_tx_id"));
while(enumerator.MoveNext())
{
var oldStatus = (MessageStatus) txs.ForColumnType<IntColumn>().Get("value_to_restore");
var queue = txs.ForColumnType<StringColumn>().Get("queue");
var subqueue = txs.ForColumnType<StringColumn>().Get("subqueue");
var bookmark = new MessageBookmark
{
QueueName = queue,
Bookmark = txs.ForColumnType<BytesColumn>().Get("bookmark_data"),
Size = txs.ForColumnType<IntColumn>().Get("bookmark_size")
};
var actions = GetQueue(queue);
var newStatus = actions.GetMessageStatus(bookmark);
switch (newStatus)
{
case MessageStatus.SubqueueChanged:
actions.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver, subqueue);
break;
case MessageStatus.EnqueueWait:
actions.Delete(bookmark);
break;
default:
actions.SetMessageStatus(bookmark, oldStatus);
break;
}
}
}
public void RevertBackToSend(MessageBookmark[] bookmarks)
{
foreach (var bookmark in bookmarks)
{
outgoingHistory.MoveTo(bookmark);
var msgId = outgoingHistory.ForColumnType<GuidColumn>().Get("msg_id");
outgoing.Insert(() =>
{
foreach (var column in ColumnsInformation.OutgoingColumns.Keys)
{
var bytes = outgoingHistory.ForColumnType<BytesColumn>().Get(column);
outgoing.ForColumnType<BytesColumn>().Set(column, bytes);
}
outgoing.ForColumnType<IntColumn>().Set("send_status", (int) OutgoingMessageStatus.Ready);
var previousRetry = outgoingHistory.ForColumnType<IntColumn>().Get("number_of_retries");
outgoing.ForColumnType<IntColumn>().Set("number_of_retries", previousRetry + 1);
_logger.Debug("Reverting output message {0} back to Ready mode", msgId);
});
outgoingHistory.Delete();
}
}
private void revert(MessageBookmark[] sendHistoryBookmarks, IEnumerable<PersistentMessage> messages)
{
_queueStorage.Send(actions => actions.RevertBackToSend(sendHistoryBookmarks));
failedToSend(messages);
}
public MessageBookmark MarkOutgoingMessageAsSuccessfullySent(MessageBookmark bookmark)
{
outgoing.MoveTo(bookmark);
var newBookmark = outgoingHistory.Insert(() =>
{
foreach (var column in outgoing.ColumnNames)
{
var bytes = outgoing.ForColumnType<BytesColumn>().Get(column);
outgoingHistory.ForColumnType<BytesColumn>().Set(column, bytes);
}
outgoingHistory.ForColumnType<IntColumn>().Set("send_status", (int)OutgoingMessageStatus.Sent);
});
var msgId = outgoing.ForColumnType<GuidColumn>().Get("msg_id");
outgoing.Delete();
_logger.Debug("Successfully sent output message {0}", msgId);
return newBookmark;
}
public void MarkOutgoingMessageAsFailedTransmission(MessageBookmark bookmark, bool queueDoesNotExistsInDestination)
{
outgoing.MoveTo(bookmark);
var numOfRetries = outgoing.ForColumnType<IntColumn>().Get("number_of_retries");
var msgId = outgoing.ForColumnType<GuidColumn>().Get("msg_id");
if (numOfRetries < 100 && queueDoesNotExistsInDestination == false)
{
outgoing.Update(() =>
{
outgoing.ForColumnType<IntColumn>().Set("send_status", (int)OutgoingMessageStatus.Ready);
outgoing.ForColumnType<DateTimeColumn>().Set("time_to_send", DateTime.Now.AddSeconds(numOfRetries * numOfRetries));
outgoing.ForColumnType<IntColumn>().Set("number_of_retries", numOfRetries + 1);
_logger.Debug("Marking outgoing message {0} as failed with retries: {1}", msgId, numOfRetries);
});
}
else
{
MoveFailedMessageToOutgoingHistory(numOfRetries, msgId);
}
}
public PersistentMessage Dequeue(string subQueue)
{
var path = (string.IsNullOrEmpty(subQueue) ? _msgsPath : Path.Combine(_msgsPath, subQueue));
if (!Directory.Exists(path))
throw new QueueDoesNotExistsException(_queueName);
return Directory.EnumerateFiles(path, FileUtil.SearchMessageId(null, MessageStatus.ReadyToDeliver.ToString()))
.OrderBy(x => x)
.Select(x =>
{
var id = FileUtil.ToMessageId(x);
var status = FileUtil.ParseExtension<MessageStatus>(x);
_logger.DebugFormat("Scanning incoming message {2} on '{0}/{1}' with status {3}", _queueName, subQueue, id, status);
if (status != MessageStatus.ReadyToDeliver)
return null;
var obj = JsonConvert.DeserializeObject<QueueMsg>(File.ReadAllText(x));
try { x = FileUtil.MoveExtension(x, MessageStatus.Processing.ToString()); }
catch (ErrorException e)
{
_logger.DebugFormat("Write conflict on '{0}/{1}' for {2}, skipping message", _queueName, subQueue, id);
if (e.Error == ErrorException.ErrorType.WriteConflict)
return null;
throw;
}
var bookmark = new MessageBookmark { Bookmark = x, QueueName = _queueName };
_changeNumberOfMessages(-1);
_logger.DebugFormat("Dequeuing message {2} from '{0}/{1}'", _queueName, subQueue, id);
return new PersistentMessage
{
Bookmark = bookmark,
Headers = HttpUtility.ParseQueryString(obj.headers),
Queue = _queueName,
SentAt = File.GetCreationTime(x),
Data = obj.data,
Id = id,
SubQueue = subQueue,
Status = status,
};
})
.Where(x => x != null)
.FirstOrDefault();
}
public void RevertBackToSend(MessageBookmark[] bookmarks)
{
foreach (var bookmark in bookmarks)
{
var path = bookmark.Bookmark;
if (!path.StartsWith(_outgoingHistoryPath))
return;
var obj = JsonConvert.DeserializeObject<Outgoing>(File.ReadAllText(path));
var msgId = obj.msgId;
obj.numberOfRetries++;
_logger.DebugFormat("Reverting output message {0} back to Ready mode", msgId);
File.WriteAllText(path, JsonConvert.SerializeObject(obj));
bookmark.Bookmark = FileUtil.MoveBase(path, _outgoingHistoryPath, _outgoingPath, OutgoingMessageStatus.Ready.ToString());
}
}
public void Discard(MessageBookmark bookmark)
{
Delete(bookmark);
}
public IList<PersistentMessage> GetMessagesToSendAndMarkThemAsInFlight(int maxNumberOfMessage, int maxSizeOfMessagesInTotal, out string endPoint)
{
endPoint = null;
if (!Directory.Exists(_outgoingPath))
return Enumerable.Empty<PersistentMessage>().ToList();
string queue = null;
var messages = new List<PersistentMessage>();
foreach (var path in Directory.EnumerateFiles(_outgoingPath, FileUtil.SearchMessageId(null, OutgoingMessageStatus.Ready.ToString())).OrderBy(x => x))
{
var obj = JsonConvert.DeserializeObject<Outgoing>(File.ReadAllText(path));
var msgId = obj.msgId;
var status = FileUtil.ParseExtension<OutgoingMessageStatus>(path);
var time = obj.timeToSend;
_logger.DebugFormat("Scanning message {0} with status {1} to be sent at {2}", msgId, status, time);
if (status != OutgoingMessageStatus.Ready)
continue;
// Check if the message has expired, and move it to the outgoing history.
var deliverBy = obj.deliverBy;
if (deliverBy != null && deliverBy.Value < DateTime.Now)
{
_logger.InfoFormat("Outgoing message {0} was not succesfully sent by its delivery time limit {1}", msgId, deliverBy.Value);
var numOfRetries = obj.numberOfRetries;
MoveFailedMessageToOutgoingHistory(path, numOfRetries, msgId);
continue;
}
var maxAttempts = obj.maxAttempts;
if (maxAttempts != null)
{
var numOfRetries = obj.numberOfRetries;
if (numOfRetries > maxAttempts)
{
_logger.InfoFormat("Outgoing message {0} has reached its max attempts of {1}", msgId, maxAttempts);
MoveFailedMessageToOutgoingHistory(path, numOfRetries, msgId);
continue;
}
}
if (time > DateTime.Now)
continue;
var rowEndpoint = obj.address;
if (endPoint == null)
endPoint = rowEndpoint;
if (!endPoint.Equals(rowEndpoint))
continue;
var rowQueue = obj.queue;
if (queue == null)
queue = rowQueue;
if (queue != rowQueue)
continue;
var bookmark = new MessageBookmark { Bookmark = FileUtil.MoveExtension(path, OutgoingMessageStatus.InFlight.ToString()) };
_logger.DebugFormat("Adding message {0} to returned messages", msgId);
messages.Add(new PersistentMessage
{
Id = new MessageId
{
SourceInstanceId = _instanceId,
MessageIdentifier = msgId
},
Headers = HttpUtility.ParseQueryString(obj.headers),
Queue = rowQueue,
SubQueue = obj.subqueue,
SentAt = obj.sentAt,
Data = obj.data,
Bookmark = bookmark
});
_logger.DebugFormat("Marking output message {0} as InFlight", msgId);
if (maxNumberOfMessage < messages.Count)
break;
if (maxSizeOfMessagesInTotal < messages.Sum(x => x.Data.Length))
break;
}
return messages;
}
public void MoveToHistory(MessageBookmark bookmark)
{
_messages.MoveTo(bookmark);
var id = _messages.GetMessageId();
_messageHistory.Insert(() =>
{
_messages.ColumnNames.Each(x =>
{
var columnBytes = _messages.ForColumnType<BytesColumn>().Get(x);
_messageHistory.ForColumnType<BytesColumn>().Set(x, columnBytes);
});
_messageHistory.ForColumnType<DateTimeColumn>().Set("moved_to_history_at", DateTime.Now);
});
_messages.Delete();
_logger.Debug("Moving message {0} on queue {1} to history",
id, _queueName);
}
public void RemoveReversalsMoveCompletedMessagesAndFinishSubQueueMove(Guid transactionId)
{
var enumerator = txs.GetEnumerator(new GuidIndex(transactionId, "by_tx_id"));
while(enumerator.MoveNext())
{
var queue = txs.ForColumnType<StringColumn>().Get("queue");
var actions = GetQueue(queue);
var bookmark = new MessageBookmark
{
Bookmark = txs.ForColumnType<BytesColumn>().Get("bookmark_data"),
QueueName = queue,
Size = txs.ForColumnType<IntColumn>().Get("bookmark_size")
};
switch (actions.GetMessageStatus(bookmark))
{
case MessageStatus.SubqueueChanged:
case MessageStatus.EnqueueWait:
actions.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
break;
default:
if (configuration.EnableProcessedMessageHistory)
actions.MoveToHistory(bookmark);
else
actions.Delete(bookmark);
break;
}
txs.Delete();
}
}
public void SetMessageStatus(MessageBookmark bookmark, MessageStatus status, string subQueue = null)
{
var path = bookmark.Bookmark;
var id = FileUtil.ToMessageId(path);
if (!File.Exists(path))
return;
bookmark.Bookmark = FileUtil.MoveExtension(path, status.ToString());
if (subQueue == null)
_logger.DebugFormat("Changing message {0} status to {1} on {2}", id, status, _queueName);
else
_logger.DebugFormat("Changing message {0} status to {1} on queue '{2}' and set subqueue to '{3}'", id, status, _queueName, subQueue);
}
public void DeleteMessageToSendHistoric(MessageBookmark bookmark)
{
outgoingHistory.MoveTo(bookmark);
outgoingHistory.Delete();
}
public Guid RegisterToSend(string destination, string queue, string subQueue, MessagePayload payload, Guid transactionId)
{
if (!Directory.Exists(_outgoingPath))
Directory.CreateDirectory(_outgoingPath);
var msgId = GuidCombGenerator.Generate();
var obj = new Outgoing
{
msgId = msgId,
txId = transactionId,
address = destination,
timeToSend = DateTime.Now,
sentAt = DateTime.Now,
queue = queue,
subqueue = subQueue,
headers = payload.Headers.ToQueryString(),
data = payload.Data,
numberOfRetries = 1,
sizeOfData = payload.Data.Length,
deliverBy = payload.DeliverBy,
maxAttempts = payload.MaxAttempts,
};
var path = Path.Combine(_outgoingPath, FileUtil.FromTransactionId(transactionId, OutgoingMessageStatus.NotReady.ToString()));
File.WriteAllText(path, JsonConvert.SerializeObject(obj));
var bookmark = new MessageBookmark { Bookmark = path };
_outgoingBookmark = bookmark;
_logger.DebugFormat("Created output message '{0}' for 'file://{1}/{2}/{3}' as NotReady", msgId, destination, queue, subQueue);
return msgId;
}
public MessageStatus GetMessageStatus(MessageBookmark bookmark)
{
_messages.MoveTo(bookmark);
return (MessageStatus)_messages.ForColumnType<IntColumn>().Get("status");
}
public void RegisterUpdateToReverse(Guid txId, MessageBookmark bookmark, MessageStatus statusToRestore, string subQueue)
{
if (!Directory.Exists(_txsPath))
Directory.CreateDirectory(_txsPath);
var path = Path.Combine(_txsPath, FileUtil.FromTransactionId(txId, null));
if (File.Exists(path))
File.Delete(path);
var obj = new Tx
{
txId = txId,
bookmark = bookmark.Bookmark,
valueToRestore = (int)statusToRestore,
queue = bookmark.QueueName,
subQueue = subQueue,
};
File.WriteAllText(path, JsonConvert.SerializeObject(obj));
}
public void SetMessageStatus(MessageBookmark bookmark, MessageStatus status, string subqueue)
{
_messages.MoveTo(bookmark);
var id = _messages.GetMessageId();
_messages.Update(() =>
{
_messages.ForColumnType<IntColumn>().Set("status", (int)status);
_messages.ForColumnType<StringColumn>().Set("subqueue", subqueue);
});
_logger.Debug("Changing message {0} status to {1} on queue '{2}' and set subqueue to '{3}'",
id, status, _queueName, subqueue);
}
public void RemoveReversalsMoveCompletedMessagesAndFinishSubQueueMove(Guid transactionId)
{
if (!Directory.Exists(_txsPath))
return;
foreach (var path in Directory.EnumerateFiles(_txsPath, FileUtil.SearchTransactionId(transactionId, null)))
{
var obj = JsonConvert.DeserializeObject<Tx>(File.ReadAllText(path));
var actions = GetQueue(obj.queue);
var bookmark = new MessageBookmark { Bookmark = obj.bookmark, QueueName = obj.queue };
switch (actions.GetMessageStatus(bookmark))
{
case MessageStatus.SubqueueChanged:
case MessageStatus.EnqueueWait:
actions.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver);
break;
default:
if (_configuration.EnableProcessedMessageHistory)
actions.MoveToHistory(bookmark);
else
actions.Delete(bookmark);
break;
}
File.Delete(path);
}
}
public void Delete(MessageBookmark bookmark)
{
_messages.MoveTo(bookmark);
_messages.Delete();
}
public void ReverseAllFrom(Guid transactionId)
{
if (!Directory.Exists(_txsPath))
return;
foreach (var x in Directory.EnumerateFiles(_txsPath, FileUtil.SearchTransactionId(transactionId, null)))
{
var obj = JsonConvert.DeserializeObject<Tx>(File.ReadAllText(x));
var oldStatus = (MessageStatus)obj.valueToRestore;
var subqueue = obj.subQueue;
var actions = GetQueue(obj.queue);
var bookmark = new MessageBookmark { Bookmark = obj.bookmark, QueueName = obj.queue };
switch (actions.GetMessageStatus(bookmark))
{
case MessageStatus.SubqueueChanged:
actions.SetMessageStatus(bookmark, MessageStatus.ReadyToDeliver, subqueue);
break;
case MessageStatus.EnqueueWait:
actions.Delete(bookmark);
break;
default:
actions.SetMessageStatus(bookmark, oldStatus);
break;
}
}
}
public void DeleteMessageToSendHistoric(MessageBookmark bookmark)
{
if (bookmark.Bookmark.StartsWith(_outgoingHistoryPath))
File.Delete(bookmark.Bookmark);
}
public void MoveToHistory(MessageBookmark bookmark)
{
var path = bookmark.Bookmark;
var id = FileUtil.ToMessageId(path);
if (!File.Exists(path))
return;
bookmark.Bookmark = FileUtil.MoveBase(path, _msgsPath, _msgsHistoryPath, null);
FileUtil.SetLastWriteTime(bookmark.Bookmark, DateTime.Now);
_logger.DebugFormat("Moving message {0} on queue {1} to history", id, _queueName);
}
