public void CanHandleClientSendingBadLengthOfData()
{
using (var reciever = new Receiver(endpointToListenTo, messages => null))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(endpointToListenTo);
var stream = client.GetStream();
stream.Write(BitConverter.GetBytes(16), 0, 4);
stream.Write(BitConverter.GetBytes(5), 0, 4);
}
wait.WaitOne();
var warn = (from e in appender.GetEvents()
where e.Level == Level.Warn &&
e.RenderedMessage.StartsWith("Unable to read message data")
select e).FirstOrDefault();
Assert.NotNull(warn);
}
}
public void TwoMessagesInOneCall()
{
var wait = new ManualResetEvent(false);
Message[] recievedMsgs = null;
using (var reciever = new Receiver(new IPEndPoint(IPAddress.Loopback, 23456), messages =>
{
recievedMsgs = messages;
return MockRepository.GenerateStub<IMessageAcceptance>();
}))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
new Sender
{
Destination = new Endpoint("localhost", 23456),
Messages = new[]
{
new Message
{
Data = new byte[] {1, 2, 4, 5, 6},
SentAt = new DateTime(2001, 1, 1),
Queue = "hello doggy",
Id = MessageId.GenerateRandom()
},
new Message
{
Data = new byte[] {1, 2, 4, 5, 6},
SentAt = new DateTime(2001, 1, 1),
Queue = "hello doggy2",
Id = MessageId.GenerateRandom()
},
}
}.Send();
wait.WaitOne();
Assert.Equal(2, recievedMsgs.Length);
Assert.Equal("hello doggy", recievedMsgs[0].Queue);
Assert.Equal("hello doggy2", recievedMsgs[1].Queue);
}
}
public void CanHandleClientConnectAndDisconnect()
{
using (var reciever = new Receiver(endpointToListenTo, messages => null))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(endpointToListenTo);
}
wait.WaitOne();
var warn = (from e in appender.GetEvents()
where e.Level == Level.Warn &&
e.RenderedMessage.StartsWith("Unable to read length data from")
select e).FirstOrDefault();
Assert.NotNull(warn);
}
}
public QueueManager(IPEndPoint endpoint, string path)
{
NumberOfMessagesToKeepInProcessedQueues = 100;
NumberOfMessagesToKeepOutgoingQueues = 100;
NumberOfReceivedMessagesToKeep = 100000;
OldestMessageInProcessedQueues = TimeSpan.FromDays(3);
OldestMessageInOutgoingQueues = TimeSpan.FromDays(3);
this.endpoint = endpoint;
this.path = path;
queueStorage = new QueueStorage(path);
queueStorage.Initialize();
queueStorage.Global(actions =>
{
receivedMsgs.Add(actions.GetAlreadyReceivedMessageIds());
actions.Commit();
});
receiver = new Receiver(endpoint, AcceptMessages);
receiver.Start();
HandleRecovery();
queuedMessagesSender = new QueuedMessagesSender(queueStorage, this);
sendingThread = new Thread(queuedMessagesSender.Send)
{
IsBackground = true,
Name = "Rhino Queue Sender Thread for " + path
};
sendingThread.Start();
purgeOldDataTimer = new Timer(PurgeOldData, null,
TimeSpan.FromMinutes(3),
TimeSpan.FromMinutes(3));
}
public void Start()
{
AssertNotDisposedOrDisposing();
if(wasStarted)
throw new InvalidOperationException("The Start method may not be invoked more than once.");
receiver = new Receiver(endpoint, enableEndpointPortAutoSelection, AcceptMessages);
receiver.Start();
queuedMessagesSender = new QueuedMessagesSender(queueStorage, this);
sendingThread = new Thread(queuedMessagesSender.Send)
{
IsBackground = true,
Name = "Rhino Queue Sender Thread for " + path
};
sendingThread.Start();
purgeOldDataTimer = new Timer(PurgeOldData, null,
TimeSpan.FromMinutes(3),
TimeSpan.FromMinutes(3));
wasStarted = true;
}
public void CanHandleClientSendingNegativeNumberForLength()
{
using (var reciever = new Receiver(endpointToListenTo, messages => null))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(endpointToListenTo);
client.GetStream().Write(BitConverter.GetBytes(-2), 0, 4);
}
wait.WaitOne();
var warn = (from e in appender.GetEvents()
where e.Level == Level.Warn &&
e.RenderedMessage.StartsWith("Got invalid length -2")
select e).FirstOrDefault();
Assert.NotNull(warn);
}
}
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 CanHandleClientSendingUnseriliazableData()
{
using (var reciever = new Receiver(endpointToListenTo, messages => null))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(endpointToListenTo);
var stream = client.GetStream();
stream.Write(BitConverter.GetBytes(16), 0, 4);
stream.Write(Guid.NewGuid().ToByteArray(), 0, 16);
}
wait.WaitOne();
var warn = (from e in appender.GetEvents()
where e.Level == Level.Warn &&
e.RenderedMessage.StartsWith("Failed to deserialize messages from")
select e).FirstOrDefault();
Assert.NotNull(warn);
}
}
public void CanHandleClientSendingThreeBytesAndDisconnecting()
{
using (var reciever = new Receiver(endpointToListenTo, messages => null))
{
reciever.CompletedRecievingMessages += () => wait.Set();
reciever.Start();
using (var client = new TcpClient())
{
client.Connect(endpointToListenTo);
client.GetStream().Write(new byte[] { 1, 4, 6 }, 0, 3);
}
wait.WaitOne();
var warn = (from e in adapter.LoggerEvents
where e.Level == LogLevel.Warn &&
e.RenderedMessage.StartsWith("Unable to read length data from")
select e).FirstOrDefault();
Assert.NotNull(warn);
}
}