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");
}
protected override void checkForMessage()
{
Message message = new Message();
ReadWriteResult result = m_fromClientQueue.Receive(message);
IClientMethod clMethod = null;
if (result == ReadWriteResult.OK)
{
string data = Encoding.UTF8.GetString(message.MessageBytes, 0, message.MessageBytes.GetLength(0));
Logger.Write("receive data from client: " + data);
clMethod = (IClientMethod)m_methodSelector.selectMethod(data);
clMethod.setQueueForAnswer(m_toClientQueue);
}
processMessage(clMethod);
}
protected override void checkForMessage()
{
Message message = new Message();
ReadWriteResult result = m_serviceClientQueue.Receive(message);
//ReadWriteResult result = ReadWriteResult.OK;
IServerCommand clMethod = null;
if (result == ReadWriteResult.OK)
{
string data = Encoding.UTF8.GetString(message.MessageBytes, 0, message.MessageBytes.GetLength(0));
//string data = "{ \"Name\": \"registerClient\", \"PrinterID\": \"\", \"rhoString\": \"manual_common_spec\" }";
Logger.Write("[manager] receive data from client: " + data);
clMethod = (IServerCommand)m_methodSelector.selectMethod(data);
}
processMessage(clMethod);
}
/// <summary>
/// Deletes all the messages contained in the queue.
/// Applicable only for read queues (CanRead = true)
/// </summary>
public void Purge()
{
if (this.CanWrite)
{
throw new ApplicationException("Queue is write only. Purge not applicable");
}
if (hQue.Equals(InvalidHandle))
{
throw new ApplicationException("Invalid Handle. Please use new queue");
}
ReadWriteResult rwr = ReadWriteResult.OK;
while (rwr == ReadWriteResult.OK)
{
Message msg = new Message();
rwr = this.Receive(msg, 0);
}
}
public static void checkForMessage()
{
///if (Settings.Instance.InstanceId == null) continue;
Message message = new Message();
ReadWriteResult result = queue.Receive(message);
if (result == ReadWriteResult.OK)
{
string data = Encoding.UTF8.GetString(message.MessageBytes, 0, message.MessageBytes.GetLength(0));
AppInfo ai = JsonConvert.DeserializeObject <AppInfo>(data);
Debug.WriteLine("Received Command: " + data + ", " + DateTime.Now.ToString());
// find if we already have ai with matching key and use it
ai = Settings.Instance.findAndUpdateAppInfo(ai);
Debug.WriteLine("AppInfo: " + ai.User + ", " + ai.Pass + ", at " + DateTime.Now.ToString());
//int index = Settings.Instance.getServerIndexByToken(ai.Token);
int index = Settings.Instance.getServerIndexByUrl(ai.ServerUrl);
if (index == -1)
{
Settings.Instance.Servers.Add(new ServerInfo(ai.ServerUrl, ai.User, ai.Pass));
Settings.Save(Settings.Instance);
serverThreads.Add(new ServerThread(Settings.Instance, Settings.Instance.Servers.Count() - 1));
index = serverThreads.Count() - 1;
}
if (ai.Command.Equals("Register"))
{
serverThreads[index].Register(ai);
}
else if (ai.Command.Equals("Unregister"))
{
serverThreads[index].Unregister(ai);
}
}
}
public ReadWriteResult ApplyRule(string table_name, string index_name, int look_back_minutes, ProvisionedThroughputDescription current_provisioned_throughput)
{
ReadWriteResult read_write_result = new ReadWriteResult();
consumed_capacity_units = GetConsumedCapacityUnits(table_name, index_name, look_back_minutes);
current_capacity_units = GetCurrentCapacityUnits(current_provisioned_throughput);
read_write_result.consumed_capacity_units = consumed_capacity_units;
read_write_result.look_back_minutes = look_back_minutes;
// when provided poorly set up rules, favor increase over decrease for safety
if (increase != null)
{
read_write_result.increase_result = this.increase.ApplyRule(consumed_capacity_units, current_capacity_units, current_provisioned_throughput);
read_write_result.new_capacity_units = read_write_result.increase_result.new_capacity_units;
}
if (!read_write_result.new_capacity_units.HasValue && decrease != null)
{
read_write_result.decrease_result = this.decrease.ApplyRule(consumed_capacity_units, current_capacity_units, current_provisioned_throughput);
read_write_result.new_capacity_units = read_write_result.decrease_result.new_capacity_units;
}
return(read_write_result);
}
/// <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);
}
public WriteResult(ReadWriteResult result, int written)
{
Result = result;
Written = written;
}
public ReadResult(ReadWriteResult result, SmartBuffer memory, int read)
{
Result = result;
Memory = memory;
Read = read;
}
