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 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(), Priority = br.ReadInt16(), 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 MoveTo(string subqueue, Message message) { AssertNotDisposedOrDisposing(); EnsureEnslistment(); 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); }
public MessageBookmark Enqueue(Message message) { var bm = new MessageBookmark { QueueName = queueName }; using (var updateMsgs = new Update(session, msgs, JET_prep.Insert)) { var messageStatus = MessageStatus.InTransit; var persistentMessage = message as PersistentMessage; if (persistentMessage != null) messageStatus = persistentMessage.Status; Api.SetColumn(session, msgs, msgsColumns["timestamp"], message.SentAt.ToOADate()); Api.SetColumn(session, msgs, msgsColumns["data"], message.Data); Api.SetColumn(session, msgs, msgsColumns["instance_id"], message.Id.SourceInstanceId.ToByteArray()); Api.SetColumn(session, msgs, msgsColumns["msg_id"], message.Id.MessageIdentifier.ToByteArray()); Api.SetColumn(session, msgs, msgsColumns["subqueue"], message.SubQueue, Encoding.Unicode); Api.SetColumn(session, msgs, msgsColumns["headers"], message.Headers.ToQueryString(), Encoding.Unicode); Api.SetColumn(session, msgs, msgsColumns["status"], (int)messageStatus); updateMsgs.Save(bm.Bookmark, bm.Size, out bm.Size); } if (string.IsNullOrEmpty(message.SubQueue) == false && Subqueues.Contains(message.SubQueue) == false) { actions.AddSubqueueTo(queueName, message.SubQueue); subqueues = subqueues.Union(new[] { message.SubQueue }).ToArray(); } logger.DebugFormat("Enqueuing msg to '{0}' with subqueue: '{1}'. Id: {2}", queueName, message.SubQueue, message.Id); changeNumberOfMessages(1); return bm; }
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 wait = new ManualResetEvent(false); var sender = new Sender { Destination = new Endpoint("localhost", 23456), 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 static string OutboundInstanceName(this Endpoint endpoint, Message message) { return string.Format("{0}:{1}/{2}/{3}", endpoint.Host, endpoint.Port, message.Queue, message.SubQueue) .TrimEnd('/'); }
public MessageEventArgs(Endpoint endpoint, Message message) { Endpoint = endpoint; Message = message; }
private void OnMessageQueuedForReceive(Message message) { OnMessageQueuedForReceive(new MessageEventArgs(null, message)); }
public void MoveTo(string subqueue, Message message) { AssertNotDisposedOrDisposing(); EnsureEnslistment(); 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(); }); }
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.CompletedRecievingMessages += () => wait.Set(); 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); Assert.Equal(ProtocolConstants.Recieved, Encoding.Unicode.GetString(buffer)); stream.Write(ProtocolConstants.AcknowledgedBuffer, 0, ProtocolConstants.AcknowledgedBuffer.Length); buffer = new byte[ProtocolConstants.RevertBuffer.Length]; stream.Read(buffer, 0, buffer.Length); Assert.Equal(ProtocolConstants.Revert, Encoding.Unicode.GetString(buffer)); } wait.WaitOne(); } }
public void WillLetSenderKnowThatMessagesWereSentToInvalidQueue() { using (var reciever = new Receiver(endpointToListenTo, messages => { throw new QueueDoesNotExistsException(); })) { reciever.CompletedRecievingMessages += () => wait.Set(); 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); Assert.Equal(ProtocolConstants.QueueDoesNotExists, Encoding.Unicode.GetString(buffer)); } wait.WaitOne(); } }
public void WillCallAbortAcceptanceIfSenderSendNonConfirmation() { var acceptance = MockRepository.GenerateStub<IMessageAcceptance>(); using (var reciever = new Receiver(endpointToListenTo, messages => acceptance)) { reciever.CompletedRecievingMessages += () => wait.Set(); 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); Assert.Equal(ProtocolConstants.Recieved, Encoding.Unicode.GetString(buffer)); var bytes = Encoding.Unicode.GetBytes("Unknowledged"); stream.Write(bytes, 0, bytes.Length); } wait.WaitOne(); } acceptance.AssertWasCalled(x => x.Abort()); }
public void MoveTo(string subqueue, Message message) { queueManager.MoveTo(subqueue, message); }
protected override IMessageAcceptance AcceptMessages(Message[] msgs) { throw new Exception("Cannot accept messages."); }
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."); EnsureEnslistment(); 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, 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; }
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); }
public static string InboundInstanceName(this IQueueManager queueManager, Message message) { return queueManager.InboundInstanceName(message.Queue, message.SubQueue); }
private void OnMessageReceived(Message message) { OnMessageReceived(new MessageEventArgs(null, message)); }
private void TestEventUpdatesCorrectInstance(Action<IQueueManager> @event, Message message, string expectedInstanceName) { Setup(); var e = new MessageEventArgs(new Endpoint("localhost", 123), message); queueManager.Raise(@event, null, e); Assert.Equal(expectedInstanceName, performanceMonitor.InstanceName); }