public P2PQueueTraceListener()
{
m_queue = new P2PMessageQueue(true, "OpenNETCF.P2PTrace");
m_queue.DataOnQueueChanged += new EventHandler(m_queue_DataOnQueueChanged);
m_serializer = new BasicBinarySerializer();
}
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");
}
public void CTorInvalidMessageLengthTest()
{
ArgumentException expected = null;
P2PMessageQueue queue = null;
try
{
queue = new P2PMessageQueue(true, "queueName", 0, 10);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
expected = null;
try
{
queue = new P2PMessageQueue(true, "queueName", -1, 10);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
private void TeardownQueueListener()
{
if (m_ndisQueue != null)
{
NDISUIO.CancelNotifications();
m_ndisQueue.Close();
m_ndisQueue = null;
}
}
public void OpenExistingPositiveTest()
{
P2PMessageQueue originalQueue = new P2PMessageQueue(true);
Assert.IsNotNull(originalQueue);
P2PMessageQueue copyQueue = P2PMessageQueue.OpenExisting(false, GetCurrentProcessHandle(), originalQueue.Handle);
Assert.IsNotNull(copyQueue);
}
private void SetupQueueListener()
{
if (m_ndisQueue != null)
{
m_ndisQueue = new P2PMessageQueue(true, null, NDISUIO_DEVICE_NOTIFICATION.Size, 0);
m_ndisQueue.DataOnQueueChanged += new EventHandler(DataOnQueueChanged);
NDISUIO.RequestNotifications(m_ndisQueue);
}
}
public void OpenExistingBadHandleTest()
{
ArgumentException expected = null;
// create a "valid" (non zero, non negative 1) handle
IntPtr validHandleValue = new IntPtr(0x8000000);
IntPtr zeroHandle = IntPtr.Zero;
IntPtr minusOneHandle = new IntPtr(-1);
try
{
P2PMessageQueue.OpenExisting(true, zeroHandle, validHandleValue);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
expected = null;
try
{
P2PMessageQueue.OpenExisting(true, minusOneHandle, validHandleValue);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
expected = null;
try
{
P2PMessageQueue.OpenExisting(true, validHandleValue, zeroHandle);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
expected = null;
try
{
P2PMessageQueue.OpenExisting(true, validHandleValue, minusOneHandle);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
/// <summary>
/// Initiates a worker thread to listen for reports of device
/// changes. Listeners can register for notification of these
/// changes, which the thread will send.
/// </summary>
public void StartStatusMonitoring()
{
if (!Active)
{
// Create a point-to-point message queue to get the notifications.
m_p2pmq = new P2PMessageQueue(true);
m_p2pmq.DataOnQueueChanged += new EventHandler(p2pmq_DataOnQueueChanged);
// Ask the system to notify our message queue when devices of
// the indicated class are added or removed.
m_requestHandle = RequestDeviceNotifications(m_deviceClass.ToByteArray(), m_p2pmq.Handle, m_fAll);
}
}
/// <summary>
/// Stops the worker thread which monitors for changes of status
/// of the adapter. This must be done, if monitoring has been
/// started, before the object is destroyed.
/// </summary>
public void StopStatusMonitoring()
{
if (Active)
{
// Close the point-to-point message queue.
P2PMessageQueue q = m_p2pmq;
m_p2pmq = null;
q.Close();
// Stop notifications to us.
StopDeviceNotifications(m_requestHandle);
m_requestHandle = IntPtr.Zero;
}
}
public void CTorInvalidMaxMessagesTest()
{
ArgumentException expected = null;
P2PMessageQueue queue = null;
try
{
queue = new P2PMessageQueue(true, "queueName", 4096, -1);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public void CTorNameTooLongTest()
{
ArgumentException expected = null;
P2PMessageQueue queue = null;
string longName = new string('N', 261);
try
{
queue = new P2PMessageQueue(true, longName);
}
catch (ArgumentException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public static void RequestNotifications(P2PMessageQueue rxQueue)
{
NDISUIO ndis = new NDISUIO();
try
{
NDISUIO_REQUEST_NOTIFICATION request = new NDISUIO_REQUEST_NOTIFICATION();
request.hMsgQueue = rxQueue.Handle;
request.dwNotificationTypes = ALL_NOTIFICATIONS;
ndis.DeviceIoControl(IOCTL_NDISUIO_REQUEST_NOTIFICATION, request.GetBytes(), null);
}
finally
{
ndis.Dispose();
}
}
public void CTorCreatedNewTest()
{
string queueName = "cnQueue";
int maxMessageLength = 0xABCD;
int maxMessageCount = P2PMessageQueue.InfiniteQueueSize;
bool createdNew;
P2PMessageQueue originalQueue = new P2PMessageQueue(true, queueName, maxMessageLength, maxMessageCount, out createdNew);
Assert.IsNotNull(originalQueue);
Assert.IsTrue(createdNew);
P2PMessageQueue copyQueue = new P2PMessageQueue(true, queueName, maxMessageLength, maxMessageCount, out createdNew);
Assert.IsNotNull(copyQueue);
Assert.IsFalse(createdNew);
}
static PowerManagement()
{
try
{
// Create message queue for power broadcasts
m_powerQueue = new P2PMessageQueue(true, "PowerEventWaitQueue");
}
catch (MissingMethodException)
{
// power manager not supported on this platform
// don't create the thread
return;
}
m_powerQueue.DataOnQueueChanged += new EventHandler(m_powerQueue_DataOnQueueChanged);
IntPtr hNotif = NativeMethods.RequestPowerNotifications(m_powerQueue.Handle, PowerEventType.PBT_POWERSTATUSCHANGE | PowerEventType.PBT_RESUME | PowerEventType.PBT_TRANSITION);
m_invokerControl.Disposed += new EventHandler(OnDispose);
}
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 CTorSameNameCheckTest()
{
string queueName = "queueName";
int maxMessageLength = 0xABCD;
int maxMessageCount = P2PMessageQueue.InfiniteQueueSize;
// create a matched pair
P2PMessageQueue readQueue = new P2PMessageQueue(true, queueName, maxMessageLength, maxMessageCount);
Assert.IsNotNull(readQueue);
P2PMessageQueue writeQueue = new P2PMessageQueue(false, queueName, maxMessageLength, maxMessageCount);
Assert.IsNotNull(readQueue);
Assert.AreEqual(readQueue.CurrentReaders, 1, "readQueue CurrentReaders failed");
Assert.AreEqual(readQueue.CurrentWriters, 1, "readQueue CurrentWriters failed");
Assert.AreEqual(writeQueue.CurrentReaders, 1, "writeQueue CurrentReaders failed");
Assert.AreEqual(writeQueue.CurrentWriters, 1, "writeQueue CurrentWriters failed");
}
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);
}
public void CTorWriteQueuePositiveTest()
{
string queueName = "writeQueueName";
int maxMessageLength = 0xABCD;
int maxMessageCount = P2PMessageQueue.InfiniteQueueSize;
P2PMessageQueue queue = new P2PMessageQueue(false, queueName, maxMessageLength, maxMessageCount);
Assert.IsNotNull(queue);
// property checks
Assert.IsFalse(queue.CanRead, "CanRead failed");
Assert.IsTrue(queue.CanWrite, "CanWrite failed");
Assert.AreEqual(queue.MaxMessageLength, maxMessageLength, "MaxMessageLength failed");
Assert.AreEqual(queue.MaxMessagesAllowed, maxMessageCount, "MaxMessagesAllowed failed");
Assert.AreEqual(queue.QueueName, queueName, "QueueName failed");
Assert.AreEqual(queue.MessagesInQueueNow, 0, "MessagesInQueueNow failed");
Assert.AreEqual(queue.MostMessagesSoFar, 0, "MostMessagesSoFar failed");
Assert.AreEqual(queue.CurrentReaders, 0, "CurrentReaders failed");
Assert.AreEqual(queue.CurrentWriters, 1, "CurrentWriters failed"); // we're a writer on this queue
Assert.AreNotEqual(queue.Handle, 0, "Handle failed");
Assert.AreNotEqual(queue.Handle, -1, "Handle failed");
}
public ClientThread(string uuid, MainForm mainForm) : base(mainForm)
{
m_toClientQueue = new P2PMessageQueue(false, fromQueuePrefix + uuid);
m_fromClientQueue = new P2PMessageQueue(true, toQueuePrefix + uuid);
}
public ClientsManager(MainForm appForm) : base(appForm)
{
m_serviceClientQueue = new P2PMessageQueue(true, serviceQueueName);
}
public MethodResult(P2PMessageQueue toClientQueue)
{
m_toClientQueue = toClientQueue;
}
public ClientsManager(MainForm appForm) : base(appForm)
{
m_serviceClientQueue = new P2PMessageQueue(true, serviceQueueName);
}
/// <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);
}
/// <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);
}
}
}
}
}
public void setQueueForAnswer(P2PMessageQueue queue)
{
m_queue = queue;
}
public void setQueueForAnswer(P2PMessageQueue queue) { }
public ClientThread(string uuid, MainForm mainForm) : base(mainForm)
{
m_toClientQueue = new P2PMessageQueue(false, fromQueuePrefix + uuid);
m_fromClientQueue = new P2PMessageQueue(true, toQueuePrefix + uuid);
}
public P2PQueueTraceWriter()
{
m_queue = new P2PMessageQueue(false, "OpenNETCF.P2PTrace");
m_serializer = new BasicBinarySerializer();
}
