public void SynchronousSendReceiveTest()
{
string messageToSend = "This is a test message";
Message outbound = new Message(Encoding.ASCII.GetBytes(messageToSend));
string queueName = "queue";
P2PMessageQueue sendQueue = new P2PMessageQueue(false, queueName);
Assert.IsNotNull(sendQueue, "ctor failed");
P2PMessageQueue recvQueue = new P2PMessageQueue(true, queueName);
Assert.IsNotNull(recvQueue, "ctor failed");
Message inbound = new Message();
ReadWriteResult result = sendQueue.Send(outbound);
Assert.AreEqual(result, ReadWriteResult.OK, "Send failed");
Assert.AreEqual(recvQueue.MessagesInQueueNow, 1, "MessagesInQueueNow failure (not added)");
result = recvQueue.Receive(inbound, 1000);
Assert.AreEqual(result, ReadWriteResult.OK, "Message was not received");
string messageReceived = Encoding.ASCII.GetString(inbound.MessageBytes, 0, inbound.MessageBytes.Length);
Assert.AreEqual(messageToSend, messageReceived, "Received data did not match sent data");
Assert.AreEqual(recvQueue.MessagesInQueueNow, 0, "MessagesInQueueNow failure (not removed)");
Assert.AreEqual(recvQueue.MostMessagesSoFar, 1, "MostMessagesSoFar failure");
}
private void processEndofAnswer()
{
byte[] convertJson = Encoding.UTF8.GetBytes(END_OF_MESSAGE_TAG);
Message message = new Message(convertJson);
m_toClientQueue.Send(message);
}
private void processAnswer(string result, bool isError)
{
Logger.Write("call result: " + result);
Message message = null;
byte[] convertJson = Encoding.UTF8.GetBytes(result);
message = new Message(convertJson, isError);
m_toClientQueue.Send(message);
}
public void SendNullDataTest()
{
P2PMessageQueue queue = new P2PMessageQueue(true);
Assert.IsNotNull(queue);
ArgumentException expected = null;
Message msg = new Message();
try
{
queue.Send(null);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public void SendEmptyDataTest()
{
P2PMessageQueue queue = new P2PMessageQueue(true);
Assert.IsNotNull(queue);
ArgumentException expected = null;
Message msg = new Message();
msg.MessageBytes = new byte[0];
try
{
queue.Send(msg);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
/// <summary>
/// Runs server thread.
/// Perform server polling for new requests.
/// </summary>
private void Run()
{
Debug.WriteLine("Starting Server Thread with ID: " + serverIndex + " at " + DateTime.Now.ToString());
Http http = new Http(serverIndex);
while (settings.Servers[serverIndex].Cookie == null)
{
Thread.Sleep(1000);
}
while (true)
{
bool receiveNow = false;
lock (thisLock)
{
receiveNow = (queues.Values.Count > 0);
}
// nothing to do - wait
if (!receiveNow)
{
Thread.Sleep(http.fetchMessageTimeoutRetryDelay);
continue;
}
else
{
// TODO: Handle situation when network is down
Debug.WriteLine("Entering FetchMessage at " + DateTime.Now.ToString());
ServerResponse sr = http.FetchMessage(settings.Servers[serverIndex].InstanceId, settings.Servers[serverIndex].Cookie, settings.Servers[serverIndex].LastMessageId);
// check if message is valid
if (sr.token == null)
{
Debug.WriteLine("Skipped message with empty token");
continue;
}
OutgoingMessage om = new OutgoingMessage {
Action = "Received", Id = sr.id, Token = sr.token, Data = JsonConvert.SerializeObject(sr.data)
};
Debug.WriteLine("Entering send message at " + DateTime.Now.ToString());
int currentReaders = 0;
string path;
string args;
lock (thisLock)
{
try
{
AppInfo ai = settings.Servers[serverIndex].Queues.First(queue => queue.Token.Equals(om.Token));
if (queues.ContainsKey(ai.GetKey()))
{
P2PMessageQueue q = queues[ai.GetKey()];
currentReaders = q.CurrentReaders;
path = ai.Path;
args = ai.Args;
}
else
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
continue;
}
}
catch (InvalidOperationException)
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
continue;
}
}
// if no readers - start the app and make sure that Ai is still valid
bool messageSkipped = false;
if (currentReaders == 0)
{
Process.Start(path, args);
while (currentReaders == 0)
{
Thread.Sleep(10000);
lock (thisLock) {
try
{
AppInfo ai = settings.Servers[serverIndex].Queues.First(queue => queue.Token.Equals(om.Token));
if (queues.ContainsKey(ai.GetKey()))
{
P2PMessageQueue q = queues[ai.GetKey()];
currentReaders = q.CurrentReaders;
}
else
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
messageSkipped = true;
break;
}
}
catch (InvalidOperationException)
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
messageSkipped = true;
break;
}
}
}
if (messageSkipped)
{
continue;
}
// give a chance for the client app to fully initialize
Thread.Sleep(10000);
}
// send the message
lock (thisLock)
{
try
{
AppInfo ai = settings.Servers[serverIndex].Queues.First(queue => queue.Token.Equals(om.Token));
if (queues.ContainsKey(ai.GetKey()))
{
P2PMessageQueue q = queues[ai.GetKey()];
string data = JsonConvert.SerializeObject(om);
Message message = new Message(Encoding.UTF8.GetBytes(data), false);
Debug.WriteLine("About to send message at " + DateTime.Now.ToString());
ReadWriteResult result = q.Send(message, 0);
// If message delivered save its id
// TODO: Verify client responce to ensure message is readed
if (result == ReadWriteResult.OK)
{
settings.Servers[serverIndex].LastMessageId = sr.id;
Settings.Save(settings);
}
else
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token + ", result of Send is : " + result.ToString());
}
Debug.WriteLine("Delivered: " + ai.GetKey() + ", " + data + " at " + DateTime.Now.ToString());
}
else
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
}
}
catch (InvalidOperationException)
{
Debug.WriteLine("Skipped: " + om.Id + ", " + om.Token);
}
}
}
}
}
/// <summary>
/// Sends the supplied message to the specified outgoing queue.
/// Acess to the queue should be protected with the lock.
/// </summary>
/// <param name="queue">A queue to send to.</param>
/// <param name="om">A message to send.</param>
private void Send(P2PMessageQueue queue, OutgoingMessage om)
{
string data = JsonConvert.SerializeObject(om);
Message message = new Message(Encoding.UTF8.GetBytes(data), false);
ReadWriteResult result = queue.Send(message, 0);
}
private void Send(string message, string category)
{
var msg = new TraceMessage(m_serializer, message, category);
m_queue.Send(msg, 1000);
}
