public void Disposed_Set ()
{
var ewh = new EventWaitHandle (false, EventResetMode.ManualReset);
ewh.Dispose();
try {
ewh.Set();
Assert.Fail ();
} catch (ObjectDisposedException) {
}
}
public void CleanUp()
{
target?.Dispose();
waitHandle?.Dispose();
stateWaitHandle?.Dispose();
HangUpConnectionById(entryId);
HangUpConnectionById(invalidEntryId);
}
private void Dispose(bool disposing)
{
if (disposing)
{
if (_fDisposed)
{
throw new ObjectDisposedException(null);
}
if (WaitingReadCount > 0 || WaitingUpgradeCount > 0 || WaitingWriteCount > 0)
{
throw new SynchronizationLockException(SR.SynchronizationLockException_IncorrectDispose);
}
if (IsReadLockHeld || IsUpgradeableReadLockHeld || IsWriteLockHeld)
{
throw new SynchronizationLockException(SR.SynchronizationLockException_IncorrectDispose);
}
if (_writeEvent != null)
{
_writeEvent.Dispose();
_writeEvent = null;
}
if (_readEvent != null)
{
_readEvent.Dispose();
_readEvent = null;
}
if (_upgradeEvent != null)
{
_upgradeEvent.Dispose();
_upgradeEvent = null;
}
if (_waitUpgradeEvent != null)
{
_waitUpgradeEvent.Dispose();
_waitUpgradeEvent = null;
}
_fDisposed = true;
}
}
/// <summary>
/// Opens the server channel, including aborting any existing channels
/// and retrying.
/// </summary>
internal static bool OpenChannel(int retries, out IChannel channel, out EventWaitHandle notifyEvent)
{
// If anyone else is listening, abort them so they close the channel
using (var evt = GetNotifyEvent()) {
if (evt != null) {
evt.Set();
}
}
channel = null;
notifyEvent = null;
while (retries-- > 0) {
try {
// We have to open an IPC channel with a single global name,
// since our test adapter has no way to know which VS
// instance started it. We will only keep the channel open
// for a short period, and close it immediately when we stop
// debugging. As long as you don't attempt to debug two unit
// tests in two different VS instances at the same time,
// nobody should get confused.
notifyEvent = CreateNotifyEvent();
channel = Internal.VSTestHostPackage.RegisterChannel(DebugConnectionChannelName);
return true;
} catch (RemotingException) {
// Someone else is already listening, so we need to abort
// them and try again.
using (var evt = GetNotifyEvent()) {
if (evt != null) {
evt.Set();
}
}
}
}
if (channel != null) {
ChannelServices.UnregisterChannel(channel);
channel = null;
}
if (notifyEvent != null) {
notifyEvent.Dispose();
notifyEvent = null;
}
return false;
}
private void read_events_thread() {
string prefix = use_global_ ? "Global\\" : "";
try {
memory_file_ = MemoryMappedFile.CreateNew(prefix + "DBWIN_BUFFER", 4096L);
bool created = false;
buffer_ready_ = new EventWaitHandle( false, EventResetMode.AutoReset, prefix + "DBWIN_BUFFER_READY", out created);
if (!created)
errors_.add("Can't create the DBWIN_BUFFER_READY event/" + use_global_);
if (created) {
data_ready_ = new EventWaitHandle(false, EventResetMode.AutoReset, prefix + "DBWIN_DATA_READY", out created);
if (!created)
errors_.add("Can't create the DBWIN_DATA_READY event/" + use_global_);
}
if (created) {
buffer_ready_.Set();
while (!disposed_) {
if (!data_ready_.WaitOne(1000))
continue;
using (var stream = memory_file_.CreateViewStream()) {
using (var reader = new BinaryReader(stream, Encoding.Default)) {
var process_id = (int)reader.ReadUInt32();
var raw = reader.ReadChars(4092);
var idx = Array.IndexOf(raw, '\0');
var msg = new string(raw, 0, idx);
find_process_id(process_id);
string process_name = pid_to_name_.ContainsKey(process_id) ? pid_to_name_[process_id] : "";
lock (this)
events_.Add(new debug_event {
unique_id = next_unique_id++, process_id = process_id, msg = msg, lo_process_name = process_name
});
}
}
buffer_ready_.Set();
}
}
} catch (Exception e) {
logger.Fatal("Can't read debug events " + e.Message);
errors_.add("Error reading debug events " + e.Message);
}
if ( memory_file_ != null)
memory_file_.Dispose();
if ( data_ready_ != null)
data_ready_.Dispose();
if ( buffer_ready_ != null)
buffer_ready_.Dispose();
}
public DoubleLaunchLocker(string signalId, string waitId, bool force = false, Action shuttingDown = null)
{
SignalId = signalId;
WaitId = waitId;
_force = force;
ShuttingDown = shuttingDown;
bool isNew;
_signalHandler = new EventWaitHandle(false, EventResetMode.AutoReset, signalId, out isNew);
if (!isNew)
{
Application.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;
bool terminate = false;
if (!force && !RequestConfirmation())
terminate = true;
if (!terminate)
{
_waitHandler = new EventWaitHandle(false, EventResetMode.AutoReset, waitId);
_signalHandler.Dispose();
_signalHandler = new EventWaitHandle(false, EventResetMode.ManualReset, signalId, out isNew);
if (!isNew)
{
_signalHandler.Set();
terminate = !_waitHandler.WaitOne(TIMEOUT);
}
}
if (terminate)
{
TryShutdown();
ForceShutdown();
}
else
Application.Current.ShutdownMode = ShutdownMode.OnLastWindowClose;
}
ThreadPool.QueueUserWorkItem(WaitingHandler, waitId);
}
public static void Start() {
if (_listenTask == null) {
lock (typeof (Monitor)) {
_cancellationTokenSource = new CancellationTokenSource();
bool wasCreated;
var ewhSec = new EventWaitHandleSecurity();
ewhSec.AddAccessRule(
new EventWaitHandleAccessRule(
new SecurityIdentifier(WellKnownSidType.WorldSid, null), EventWaitHandleRights.FullControl, AccessControlType.Allow));
var sessionAckEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "DBWIN_BUFFER_READY", out wasCreated, ewhSec);
var sessionReadyEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "DBWIN_DATA_READY", out wasCreated, ewhSec);
var globalAckEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "Global\\DBWIN_BUFFER_READY", out wasCreated, ewhSec);
var globalReadyEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "Global\\DBWIN_DATA_READY", out wasCreated, ewhSec);
var sd = new SECURITY_DESCRIPTOR();
var sa = new SECURITY_ATTRIBUTES();
// Initialize the security descriptor.
if (!Advapi32.InitializeSecurityDescriptor(ref sd, 1)) {
throw new ApplicationException(
string.Format("{0}. Last Win32 Error was {1}", "Failed to initializes the security descriptor.", Marshal.GetLastWin32Error()));
}
// Set information in a discretionary access control list
if (!Advapi32.SetSecurityDescriptorDacl(ref sd, true, IntPtr.Zero, false)) {
throw new ApplicationException(
string.Format("{0}. Last Win32 Error was {1}", "Failed to initializes the security descriptor", Marshal.GetLastWin32Error()));
}
// Create the event for slot 'DBWIN_BUFFER_READY'
sa.nLength = Marshal.SizeOf(sa);
sa.lpSecurityDescriptor = Marshal.AllocHGlobal(Marshal.SizeOf(sd));
Marshal.StructureToPtr(sd, sa.lpSecurityDescriptor, false);
// Get a handle to the readable shared memory at slot 'DBWIN_BUFFER'.
var sessionSharedFileHandle = Kernel32.CreateFileMapping(new IntPtr(-1), ref sa, PageProtection.ReadWrite, 0, 4096, "DBWIN_BUFFER");
if (sessionSharedFileHandle == IntPtr.Zero) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to create a file mapping to slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
// Create a view for this file mapping so we can access it
var sessionSharedMemoryHandle = Kernel32.MapViewOfFile(sessionSharedFileHandle, /*SECTION_MAP_READ*/ 0x0004, 0, 0, 4096);
if (sessionSharedMemoryHandle == IntPtr.Zero) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to create a mapping view for slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
// Get a handle to the readable shared memory at slot 'DBWIN_BUFFER'.
var globalSharedFileHandle = Kernel32.CreateFileMapping(new IntPtr(-1), ref sa, PageProtection.ReadWrite, 0, 4096, "Global\\DBWIN_BUFFER");
if (globalSharedFileHandle == IntPtr.Zero) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to create a file mapping to slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
// Create a view for this file mapping so we can access it
var globalSharedMemoryHandle = Kernel32.MapViewOfFile(globalSharedFileHandle, /*SECTION_MAP_READ*/ 0x0004, 0, 0, 4096);
if (globalSharedMemoryHandle == IntPtr.Zero) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to create a mapping view for slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
var queue = new Queue<Tuple<int, DateTime, string>>();
var dataAvailable = new ManualResetEvent(true);
_listenTask = Task.Factory.StartNew(
() => {
// Everything after the first DWORD is our debugging text
IntPtr sessionStringPointer;
IntPtr globalStringPointer;
if (Environment.Is64BitProcess) {
sessionStringPointer = new IntPtr(sessionSharedMemoryHandle.ToInt64() + Marshal.SizeOf(typeof (int)));
globalStringPointer = new IntPtr(globalSharedMemoryHandle.ToInt64() + Marshal.SizeOf(typeof (int)));
} else {
sessionStringPointer = new IntPtr(sessionSharedMemoryHandle.ToInt32() + Marshal.SizeOf(typeof (int)));
globalStringPointer = new IntPtr(globalSharedMemoryHandle.ToInt32() + Marshal.SizeOf(typeof (int)));
}
while (!_cancellationTokenSource.IsCancellationRequested) {
sessionAckEvent.Set();
globalAckEvent.Set();
try {
var i = WaitHandle.WaitAny(new[] {
sessionReadyEvent, globalReadyEvent, _cancellationTokenSource.Token.WaitHandle
});
var now = DateTime.Now;
if (i == 0) {
lock (queue) {
queue.Enqueue(new Tuple<int, DateTime, string>(Marshal.ReadInt32(sessionSharedMemoryHandle), now, Marshal.PtrToStringAnsi(sessionStringPointer)));
dataAvailable.Set();
}
}
if (i == 1) {
lock (queue) {
queue.Enqueue(new Tuple<int, DateTime, string>(Marshal.ReadInt32(globalSharedMemoryHandle), now, Marshal.PtrToStringAnsi(globalStringPointer)));
dataAvailable.Set();
}
}
} catch {
// it's over.
_cancellationTokenSource.Cancel();
}
}
_listenTask = null;
// cleanup after stopping.
globalAckEvent.Reset();
globalAckEvent.Dispose();
globalAckEvent = null;
sessionAckEvent.Reset();
sessionAckEvent.Dispose();
sessionAckEvent = null;
globalReadyEvent.Reset();
globalReadyEvent.Dispose();
globalReadyEvent = null;
sessionReadyEvent.Reset();
sessionReadyEvent.Dispose();
sessionReadyEvent = null;
// Close SharedFile
if (sessionSharedFileHandle != IntPtr.Zero) {
if (!Kernel32.CloseHandle(sessionSharedFileHandle)) {
throw new ApplicationException(
string.Format("{0}. Last Win32 Error was {1}", "Failed to close handle for 'SharedFile'", Marshal.GetLastWin32Error()));
}
sessionSharedFileHandle = IntPtr.Zero;
}
// Unmap SharedMem
if (sessionSharedMemoryHandle != IntPtr.Zero) {
if (!Kernel32.UnmapViewOfFile(sessionSharedMemoryHandle)) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to unmap view for slot 'DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
sessionSharedMemoryHandle = IntPtr.Zero;
}
// Close SharedFile
if (globalSharedFileHandle != IntPtr.Zero) {
if (!Kernel32.CloseHandle(globalSharedFileHandle)) {
throw new ApplicationException(
string.Format("{0}. Last Win32 Error was {1}", "Failed to close handle for 'SharedFile'", Marshal.GetLastWin32Error()));
}
globalSharedFileHandle = IntPtr.Zero;
}
// Unmap SharedMem
if (globalSharedMemoryHandle != IntPtr.Zero) {
if (!Kernel32.UnmapViewOfFile(globalSharedMemoryHandle)) {
throw new ApplicationException(
string.Format(
"{0}. Last Win32 Error was {1}", "Failed to unmap view for slot 'Global\\DBWIN_BUFFER'", Marshal.GetLastWin32Error()));
}
globalSharedMemoryHandle = IntPtr.Zero;
}
}, _cancellationTokenSource.Token);
Task.Factory.StartNew(() => {
// handle events on seperate task to minimize the work that is done blocking the handles
Tuple<int, DateTime, string> item = null;
while (WaitHandle.WaitAny(new[] {
dataAvailable, _cancellationTokenSource.Token.WaitHandle
}) == 0) {
lock (queue) {
if (queue.Count > 0) {
item = queue.Dequeue();
}
if (queue.Count == 0) {
dataAvailable.Reset();
}
}
if (item == null || OnOutputDebugString == null) {
continue;
}
try {
OnOutputDebugString(new OutputDebugStringEventArgs(item.Item1, item.Item2, item.Item3));
} catch {
// if it's taken, good, if not--well too bad!
}
}
}, _cancellationTokenSource.Token);
}
}
}
public override string ResolveToString()
{
if (!Parameters.Contains("url") || string.IsNullOrEmpty(Parameters["url"].ToString()))
throw new InvalidOperationException();
string url = Parameters["url"].ToString();
string resultString = null;
using (var wc = new WebClient())
{
var tlock = new EventWaitHandle(false, EventResetMode.ManualReset);
wc.DownloadProgressChanged += new DownloadProgressChangedEventHandler((sender, e) =>
{
// TODO: Add progress monitoring
});
wc.DownloadStringCompleted += new DownloadStringCompletedEventHandler((sender, e) =>
{
resultString = e.Result;
tlock.Set();
});
wc.DownloadStringAsync(new Uri(url));
tlock.WaitOne();
tlock.Dispose();
}
return resultString;
}
public void Dispose()
{
eventWaitHandle.Dispose();
}
private void RunTest()
{
Logger logger = eventLogControl.Logger;
MetaDictionary globals = new MetaDictionary();
EventWaitHandle endEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
try
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
using (TestDocument.TestGraphContainer testGraph = Document.CreateTestGraph(logger, globals))
{
testGraph.Graph.LogPacketEvent += new EventHandler<LogPacketEventArgs>(log_AddLogPacket);
testGraph.Graph.EditPacketEvent += new EventHandler<EditPacketEventArgs>(Graph_EditPacketEvent);
LogPacket[] packets = Document.GetInputPackets();
using (QueuedDataAdapter inputAdapter = new QueuedDataAdapter(tokenSource.Token))
{
foreach (LogPacket p in packets)
{
inputAdapter.Enqueue(p.Frame.CloneFrame());
}
inputAdapter.StopEnqueue();
testGraph.Graph.BindEndpoint(testGraph.Output.Uuid, new EventDataAdapter(endEvent));
testGraph.Graph.BindEndpoint(testGraph.Input.Uuid, inputAdapter);
IPipelineEndpoint inputEndpoint = testGraph.Input as IPipelineEndpoint;
inputEndpoint.Start();
// Sleep up to 100 seconds
if (!endEvent.WaitOne(100000))
{
logger.LogError("Test did not finish after 100 seconds");
tokenSource.Cancel();
}
}
}
}
catch (EndOfStreamException)
{
// End of stream
}
catch (ThreadAbortException)
{
}
catch (ObjectDisposedException)
{
}
finally
{
if(endEvent != null)
{
endEvent.Dispose();
}
}
}
