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); }