public async Task Send(Stream stream, Action success, Message[] messages, string destination)
{
var buffer = messages.Serialize();
await new WriteLength(_logger, buffer.Length, destination).ProcessAsync(stream);
await new WriteMessage(_logger, buffer, destination).ProcessAsync(stream);
await new ReadReceived(_logger, destination).ProcessAsync(stream);
await new WriteAcknowledgement(_logger, destination).ProcessAsync(stream);
success();
await new ReadRevert(_logger, destination).ProcessAsync(stream);
}
public async Task Send(Stream stream, Action success, Message[] messages, string destination)
{
var buffer = messages.Serialize();
try
{
await new WriteLength(_logger, buffer.Length, destination).ProcessAsync(stream).ConfigureAwait(false);
await new WriteMessage(_logger, buffer, destination).ProcessAsync(stream).ConfigureAwait(false);
await new ReadReceived(_logger, destination).ProcessAsync(stream).ConfigureAwait(false);
await new WriteAcknowledgement(_logger, destination).ProcessAsync(stream).ConfigureAwait(false);
success();
await new ReadRevert(_logger, destination).ProcessAsync(stream).ConfigureAwait(false);
}
catch (ObjectDisposedException)
{
// Swallowing this so we don't have unobserved task exceptions in the finalizer when we timeout.
}
}
public static Message[] ToMessages(byte[] buffer)
{
using (var ms = new MemoryStream(buffer))
using (var br = new BinaryReader(ms))
{
var numberOfMessages = br.ReadInt32();
var msgs = new Message[numberOfMessages];
for (int i = 0; i < numberOfMessages; i++)
{
msgs[i] = new Message
{
Id = new MessageId
{
SourceInstanceId = new Guid(br.ReadBytes(16)),
MessageIdentifier = new Guid(br.ReadBytes(16))
},
Queue = br.ReadString(),
SubQueue = br.ReadString(),
SentAt = DateTime.FromBinary(br.ReadInt64()),
};
var headerCount = br.ReadInt32();
msgs[i].Headers = new NameValueCollection(headerCount);
for (var j = 0; j < headerCount; j++)
{
msgs[i].Headers.Add(
br.ReadString(),
br.ReadString()
);
}
var byteCount = br.ReadInt32();
msgs[i].Data = br.ReadBytes(byteCount);
if (string.IsNullOrEmpty(msgs[i].SubQueue))
msgs[i].SubQueue = null;
}
return msgs;
}
}
public void QueuedForSend(Message message, Endpoint destination)
{
_queuedForSend.Add(new QueuedForSend(message, destination));
}
public QueuedForSend(Message message, Endpoint destination)
{
Message = message;
Destination = destination;
}
public void QueuedForReceive(Message message)
{
Debug("Message {0} queued for receive in queue {1}", message.Id, message.Queue);
}
public void QueuedForReceive(Message message)
{
_queuedForReceive.Add(message);
}
public MessageQueuedForReceive(Message message)
{
Message = message;
}
protected override IMessageAcceptance AcceptMessages(Message[] msgs)
{
throw new Exception("Cannot accept messages.");
}
public void QueuedForSend(Message message, Endpoint destination)
{
Debug("Message {0} queued for send to {1}", message.Id, destination);
}
public void WhenSendingDuplicateMessageTwiceWillGetItOnlyOnce()
{
var msg = new Message
{
Id = MessageId.GenerateRandom(),
Queue = "h",
Data = Encoding.Unicode.GetBytes("hello"),
SentAt = DateTime.Now
};
for (int i = 0; i < 2; i++)
{
var sender = new Sender(ObjectMother.Logger())
{
Destination = new Endpoint("localhost", 23456),
Messages = new[] { msg, },
};
try
{
sender.Send().Wait();
}
catch (Exception)
{
//don't care if the sender throws on 2nd round
}
}
using (var tx = new TransactionScope())
{
var message = queueManager.Receive("h", null);
"hello".ShouldEqual(Encoding.Unicode.GetString(message.Data));
tx.Complete();
}
using (var tx = new TransactionScope())
{
Assert.Throws<TimeoutException>(() => queueManager.Receive("h", null, TimeSpan.Zero));
tx.Complete();
}
}
public void WillSendConfirmationForClient()
{
var acceptance = MockRepository.GenerateStub<IMessageAcceptance>();
using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance))
{
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(_endpointToListenTo);
var stream = client.GetStream();
var serialize = new Message[0].Serialize();
stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4);
stream.Write(serialize, 0, serialize.Length);
var buffer = new byte[ProtocolConstants.RecievedBuffer.Length];
stream.Read(buffer, 0, buffer.Length);
ProtocolConstants.RecievedBuffer.ShouldEqual(buffer);
}
}
}
public void WillTellSenderIfCommitFailed()
{
var acceptance = MockRepository.GenerateStub<IMessageAcceptance>();
acceptance.Stub(x => x.Commit()).Throw(new InvalidOperationException());
using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance))
{
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(_endpointToListenTo);
var stream = client.GetStream();
var serialize = new Message[0].Serialize();
stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4);
stream.Write(serialize, 0, serialize.Length);
var buffer = new byte[ProtocolConstants.RecievedBuffer.Length];
stream.Read(buffer, 0, buffer.Length);
ProtocolConstants.RecievedBuffer.ShouldEqual(buffer);
stream.Write(ProtocolConstants.AcknowledgedBuffer, 0, ProtocolConstants.AcknowledgedBuffer.Length);
buffer = new byte[ProtocolConstants.RevertBuffer.Length];
stream.Read(buffer, 0, buffer.Length);
ProtocolConstants.RevertBuffer.ShouldEqual(buffer);
}
}
}
public void WillLetSenderKnowThatMessagesWereSentToInvalidQueue()
{
using (var reciever = new Receiver(_endpointToListenTo, messages =>
{
throw new QueueDoesNotExistsException();
}))
{
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(_endpointToListenTo);
var stream = client.GetStream();
var serialize = new Message[0].Serialize();
stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4);
stream.Write(serialize, 0, serialize.Length);
var buffer = new byte[ProtocolConstants.ProcessingFailureBuffer.Length];
stream.Read(buffer, 0, buffer.Length);
ProtocolConstants.QueueDoesNoExiststBuffer.ShouldEqual(buffer);
}
}
}
public void WillCallCommitAcceptanceIfSenderSendConfirmation()
{
var commitCalled = false;
var acceptance = MockRepository.GenerateStub<IMessageAcceptance>();
acceptance.Expect(x => x.Commit()).WhenCalled(x => commitCalled = true);
using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance))
{
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(_endpointToListenTo);
var stream = client.GetStream();
var serialize = new Message[0].Serialize();
stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4);
stream.Write(serialize, 0, serialize.Length);
var buffer = new byte[ProtocolConstants.RecievedBuffer.Length];
stream.Read(buffer, 0, buffer.Length);
ProtocolConstants.RecievedBuffer.ShouldEqual(buffer);
stream.Write(ProtocolConstants.AcknowledgedBuffer, 0, ProtocolConstants.AcknowledgedBuffer.Length);
}
}
Wait.Until(() => commitCalled);
acceptance.VerifyAllExpectations();
}
public MessagesSent(Message[] messages, Endpoint destination)
{
Messages = messages;
Destination = destination;
}
public MessageReceived(Message message)
{
Message = message;
}
protected virtual IMessageAcceptance AcceptMessages(Message[] msgs)
{
var bookmarks = _queueStorage.Global(actions => _receivedMsgs.Filter(msgs, message => message.Id)
.Select(x => acceptedBookmarks(actions, x))
.ToList());
return new MessageAcceptance(this, bookmarks, msgs, _queueStorage);
}
public TransactionCallback(ITransactionalScope transaction, Message message, IDelayedMessageCache<MessageId> delayedMessages)
{
_transaction = transaction;
_message = message;
_delayedMessages = delayedMessages;
}
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
);
message.SubQueue = subqueue;
});
if (((PersistentMessage)message).Status == MessageStatus.ReadyToDeliver)
_logger.MessageReceived(message);
_logger.QueuedForReceive(message);
}
public MessageBookmark Enqueue(Message message)
{
var bm = _messages.Insert(() =>
{
var messageStatus = MessageStatus.InTransit;
var persistentMessage = message as PersistentMessage;
if (persistentMessage != null)
messageStatus = persistentMessage.Status;
_messages.ForColumnType<DateTimeColumn>().Set("timestamp", message.SentAt);
_messages.ForColumnType<BytesColumn>().Set("data", message.Data);
_messages.ForColumnType<GuidColumn>().Set("instance_id", message.Id.SourceInstanceId);
_messages.ForColumnType<GuidColumn>().Set("msg_id", message.Id.MessageIdentifier);
_messages.ForColumnType<StringColumn>().Set("subqueue", message.SubQueue);
_messages.ForColumnType<StringColumn>().Set("headers", message.Headers.ToQueryString());
_messages.ForColumnType<IntColumn>().Set("status", (int)messageStatus);
});
bm.QueueName = _queueName;
if (string.IsNullOrEmpty(message.SubQueue) == false &&
Subqueues.Contains(message.SubQueue) == false)
{
_actions.AddSubqueueTo(_queueName, message.SubQueue);
_subqueues = _subqueues.Union(new[] { message.SubQueue }).ToArray();
}
_logger.Debug("Enqueuing msg to '{0}' with subqueue: '{1}'. Id: {2}", _queueName, message.SubQueue, message.Id);
_changeNumberOfMessages(1);
return bm;
}
public void MoveTo(string subqueue, Message message)
{
queueManager.MoveTo(subqueue, message);
}
private MessageBookmark acceptedBookmarks(GlobalActions actions, Message message)
{
var queue = actions.GetQueue(message.Queue);
var bookmark = queue.Enqueue(message);
return bookmark;
}
public MessageQueuedForSend(Endpoint destination, Message message)
{
Destination = destination;
Message = message;
}
public MessageId Send(ITransaction transaction, 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.");
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());
}
Guid msgId = Guid.Empty;
var port = uri.Port;
if (port == -1)
port = 2200;
var destination = new Endpoint(uri.Host, port);
_queueStorage.Global(actions =>
{
msgId = actions.RegisterToSend(destination, queue,
subqueue, payload, transaction.Id);
});
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
};
_logger.QueuedForSend(message, destination);
return messageId;
}
public void MessageReceived(Message message)
{
_received.Add(message);
}
public MessageEventArgs(Endpoint endpoint, Message message)
{
Endpoint = endpoint;
Message = message;
}
public void MessageReceived(Message message)
{
Debug("Message {0} received", message.Id);
}
