/// <summary>
/// Attempts to acquire the global application lock.
/// </summary>
/// <remarks>
/// <note>
/// <see cref="Release" /> should be called promptly when the
/// application terminates to release the lock.
/// </note>
/// </remarks>
/// <exception cref="GlobalLockException">Thrown when there's a problem acquiring the lock.</exception>
public unsafe void Lock()
{
EnhancedMemoryStream ms;
byte *pMem;
byte[] buf;
Assembly assembly;
string path;
lock (syncLock)
{
if (initLock != null)
{
cLock++; // The lock is already acquired
return;
}
try
{
// Use a global shared memory block to enforce the lock.
assembly = Assembly.GetEntryAssembly();
if (assembly == null)
{
assembly = Assembly.GetCallingAssembly();
}
path = Helper.StripFileScheme(assembly.CodeBase);
ms = new EnhancedMemoryStream(4096);
ms.WriteString16(path);
initLock = new SharedMem();
initLock.Open("LT.Lock." + appName, 4096, SharedMem.OpenMode.CREATE_OPEN);
pMem = initLock.Lock();
if (pMem[0] != 0 || pMem[1] != 0)
{
buf = new byte[initLock.Size];
for (int i = 0; i < buf.Length; i++)
{
buf[i] = pMem[i];
}
ms = new EnhancedMemoryStream(buf);
initLock.Unlock();
initLock.Close();
initLock = null;
throw new GlobalLockException("Global lock is already acquired by [{0}].", ms.ReadString16());
}
buf = ms.ToArray();
for (int i = 0; i < buf.Length; i++)
{
pMem[i] = buf[i];
}
initLock.Unlock();
}
catch (Exception e)
{
throw new GlobalLockException(e);
}
}
cLock++;
}
/// <summary>
/// This method transmits the byte message array passed to the inbox. Note that
/// you may pass <paramref name="message" /> as <c>null</c>. In this case, the method will simply detect
/// whether or not the inbox exists and is able to accept a message transmission.
/// </summary>
/// <param name="message">The message array.</param>
/// <param name="maxWait">The maximum time to wait for the transmission to complete.</param>
/// <returns><c>true</c> if the operation was successful.</returns>
public unsafe bool Send(byte[] message, TimeSpan maxWait)
{
// See the comment in SharedMemInbox for a description of the
// shared memory block format.
byte *p;
if (message != null && message.Length > maxMsgSize)
{
throw new ArgumentException("Message is too large.", "message");
}
lock (syncLock)
{
if (inbox == null)
{
// Initialize the inbox reference. Return <c>false</c> if the inbox
// shared memory does not exist or if there's no SharedMemInbox
// listening.
try
{
inbox = new SharedMem();
inbox.Open(name, maxMsgSize, SharedMem.OpenMode.OPEN_ONLY);
}
catch
{
inbox = null;
return(false);
}
// Here's what the abbreviations mean:
//
// LT = LillTek
// SMI = SharedMemInBox
// NME = NewMessageEvent
// EBE = EmptyBoxEvent
newMsgEvent = new GlobalAutoResetEvent("LT:SMI:NME:" + name);
emptyBoxEvent = new GlobalAutoResetEvent("LT:SMI:EBE:" + name);
}
// Wait for exclusive access to an empty shared memory block and then
// send the message.
if (emptyBoxEvent == null || !emptyBoxEvent.WaitOne(maxWait, false))
{
// $todo: I really shouldn't have to close the inbox here but for
// some reason, the emptyBoxEvent is never set in some
// situations (like when a service router starts before the
// zone or machine router on the computer). At some point,
// I'd like to come back and investigate why this is happening.
inbox.Close();
newMsgEvent.Close();
emptyBoxEvent.Close();
inbox = null;
newMsgEvent = null;
emptyBoxEvent = null;
return(false);
}
if (message == null)
{
emptyBoxEvent.Set();
return(true);
}
p = inbox.Lock();
try
{
int cbMax;
if (p[SharedMemInbox.InboxListeningOffset] == 0)
{
return(false); // There's no inbox listening
}
cbMax = *(int *)&p[SharedMemInbox.MaxMsgSizeOffset];
if (cbMax != maxMsgSize)
{
throw new Exception("SharedMemInbox MaxMsgSize mismatch.");
}
for (int i = 0; i < message.Length; i++)
{
p[SharedMemInbox.MessageOffset + i] = message[i];
}
*(int *)&p[SharedMemInbox.CurMsgSizeOffset] = message.Length;
newMsgEvent.Set();
}
finally
{
inbox.Unlock();
}
}
return(true);
}