public static Message ToMessage(byte[] buffer, string queue, string file, DateTime fileDate)
{
var filePack = Path.GetFileNameWithoutExtension(file).Split('+');
var queuePack = queue.Split('\\');
var message = new Message
{
Id = new MessageId
{
SourceInstanceId = new Guid(filePack[0]),
MessageIdentifier = new Guid(filePack[1])
},
Queue = queuePack[0],
SubQueue = (queuePack.Length > 1 && !string.IsNullOrEmpty(queuePack[1]) ? queuePack[1] : null),
SentAt = fileDate,
};
using (var s = new MemoryStream(buffer))
using (var r = new BinaryReader(s))
{
var capacity = r.ReadInt32();
message.Headers = new NameValueCollection(capacity);
for (var j = 0; j < capacity; j++)
message.Headers.Add(r.ReadString(), r.ReadString());
var count = r.ReadInt32();
message.Data = r.ReadBytes(count);
}
return message;
}
public void Register(Message message)
{
_timeoutMessageIds.Write(writer =>
{
var timeToSend = XmlConvert.ToDateTime(message.Headers["time-to-send"], XmlDateTimeSerializationMode.Utc);
_logger.DebugFormat("Registering message {0} to be sent at {1} on {2}", message.Id, timeToSend, _queue.QueueName);
writer.Add(timeToSend, message.Id);
});
}
public MessageEventArgs(string endpoint, Message message)
{
Endpoint = endpoint;
Message = message;
}
private void TestEventUpdatesCorrectInstance(Action<IQueueManager> @event, Message message, string expectedInstanceName)
{
Setup();
var e = new MessageEventArgs("localhost", message);
_queueManager.Raise(@event, null, e);
Assert.Equal(expectedInstanceName, _performanceMonitor.InstanceName);
}
public void MoveTo(string subqueue, Message message)
{
_queueManager.MoveTo(subqueue, message);
}
public static string InboundInstanceName(this IQueueManager queueManager, Message message)
{
return queueManager.InboundInstanceName(message.Queue, message.SubQueue);
}
public static string OutboundInstanceName(this string endpoint, Message message)
{
return string.Format("{0}/{1}/{2}", endpoint, message.Queue, message.SubQueue).TrimEnd(new char[] { '/' });
}
public void WhenSendingDuplicateMessageTwiceWillGetItOnlyOnce()
{
var msg = new Message
{
Id = MessageId.GenerateRandom(),
Queue = "h",
Data = Encoding.Unicode.GetBytes("hello"),
SentAt = DateTime.Now
};
for (var i = 0; i < 2; i++)
{
var wait = new ManualResetEvent(false);
var sender = new Sender
{
Destination = "localhost",
Failure = exception => Assert.False(true),
Success = () => null,
Messages = new[] { msg },
};
sender.SendCompleted += () => wait.Set();
sender.Send();
wait.WaitOne();
}
using (var tx = new TransactionScope())
{
var message = _queueManager.Receive("h", null);
Assert.Equal("hello", Encoding.Unicode.GetString(message.Data));
tx.Complete();
}
using (var tx = new TransactionScope())
{
Assert.Throws<TimeoutException>(() => _queueManager.Receive("h", null, TimeSpan.Zero));
tx.Complete();
}
}
public MessageId Send(Uri uri, MessagePayload payload)
{
if (_waitingForAllMessagesToBeSent)
throw new CannotSendWhileWaitingForAllMessagesToBeSentException("Currently waiting for all messages to be sent, so we cannot send. You probably have a race condition in your application.");
EnsureEnlistment();
var parts = uri.AbsolutePath.Substring(1).Split('/');
var queue = parts[0];
string subqueue = null;
if (parts.Length > 1)
subqueue = string.Join("/", parts.Skip(1).ToArray());
var msgId = Guid.Empty;
var destination = uri.Host;
_queueStorage.Global(actions =>
{
msgId = actions.RegisterToSend(destination, queue, subqueue, payload, Enlistment.Id);
actions.Commit();
});
var messageId = new MessageId
{
SourceInstanceId = _queueStorage.Id,
MessageIdentifier = msgId
};
var message = new Message
{
Id = messageId,
Data = payload.Data,
Headers = payload.Headers,
Queue = queue,
SubQueue = subqueue
};
OnMessageQueuedForSend(new MessageEventArgs(destination, message));
return messageId;
}
private void OnMessageReceived(Message message) { OnMessageReceived(new MessageEventArgs(null, message)); }
private void OnMessageQueuedForReceive(Message message) { OnMessageQueuedForReceive(new MessageEventArgs(null, message)); }
public void MoveTo(string subqueue, Message message)
{
AssertNotDisposedOrDisposing();
EnsureEnlistment();
_queueStorage.Global(actions =>
{
var queue = actions.GetQueue(message.Queue);
var bookmark = queue.MoveTo(subqueue, (PersistentMessage)message);
actions.RegisterUpdateToReverse(Enlistment.Id, bookmark, MessageStatus.ReadyToDeliver, message.SubQueue);
actions.Commit();
});
if (((PersistentMessage)message).Status == MessageStatus.ReadyToDeliver)
OnMessageReceived(message);
var updatedMessage = new Message
{
Id = message.Id,
Data = message.Data,
Headers = message.Headers,
Queue = message.Queue,
SubQueue = subqueue,
SentAt = message.SentAt
};
OnMessageQueuedForReceive(updatedMessage);
}
protected virtual IMessageAcceptance AcceptMessages(Message[] msgs)
{
var bookmarks = new List<MessageBookmark>();
_queueStorage.Global(actions =>
{
foreach (var msg in _receivedMsgs.Filter(msgs, message => message.Id))
{
var queue = actions.GetQueue(msg.Queue);
var bookmark = queue.Enqueue(msg);
bookmarks.Add(bookmark);
}
actions.Commit();
});
return new MessageAcceptance(this, bookmarks, msgs, _queueStorage);
}
protected override IMessageAcceptance AcceptMessages(Message[] msgs)
{
throw new Exception("Cannot accept messages.");
}
public MessageBookmark Enqueue(Message message)
{
if (!Directory.Exists(_msgsPath))
throw new QueueDoesNotExistsException(_queueName);
if (!string.IsNullOrEmpty(message.SubQueue) && !Subqueues.Contains(message.SubQueue))
{
_actions.AddSubqueueTo(_queueName, message.SubQueue);
_subqueues = _subqueues.Union(new[] { message.SubQueue }).ToArray();
}
var path = (string.IsNullOrEmpty(message.SubQueue) ? _msgsPath : Path.Combine(_msgsPath, message.SubQueue));
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
var messageStatus = MessageStatus.InTransit;
var persistentMessage = (message as PersistentMessage);
if (persistentMessage != null)
messageStatus = persistentMessage.Status;
var obj = new QueueMsg
{
data = message.Data,
headers = message.Headers.ToQueryString(),
};
var path2 = Path.Combine(path, FileUtil.FromMessageId(message.Id, messageStatus.ToString()));
File.WriteAllText(path2, JsonConvert.SerializeObject(obj));
FileUtil.SetCreationTime(path2, message.SentAt);
var bm = new MessageBookmark { Bookmark = path2, QueueName = _queueName };
_logger.DebugFormat("Enqueuing msg to '{0}' with subqueue: '{1}'. Id: {2}", _queueName, message.SubQueue, message.Id);
_changeNumberOfMessages(1);
return bm;
}
