public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { Assert.Equal(EnlistmentOutcome.Committed, _expectedOutcome); _outcomeReceived?.Set(); singlePhaseEnlistment.Done(); }
public void SetReset() { using (AutoResetEvent are = new AutoResetEvent(false)) { Assert.False(are.WaitOne(0)); are.Set(); Assert.True(are.WaitOne(0)); Assert.False(are.WaitOne(0)); are.Set(); are.Reset(); Assert.False(are.WaitOne(0)); } }
public bool PosTest1() { bool retVal = true; AutoResetEvent are; TestLibrary.TestFramework.BeginScenario("PosTest1: AutoResetEvent.Set()"); try { // false means that the initial state should be not signaled are = new AutoResetEvent(false); // set the signal if (!are.Set()) { TestLibrary.TestFramework.LogError("001", "AutoResetEvent.Set() failed"); retVal = false; } // verify that the autoreset event is signaled // if it is not signaled the following call will block for ever TestLibrary.TestFramework.LogInformation("Calling AutoResetEvent.WaitOne()... if the event is not signaled it will hang"); are.WaitOne(); } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e); retVal = false; } return retVal; }
internal void Terminate() { terminate = true; try { callDispatcherRunEvent?.Set(); } catch (ObjectDisposedException) { } if (Dispatcher is not null && !Dispatcher.HasShutdownStarted && !Dispatcher.HasShutdownFinished) { Dispatcher.BeginInvokeShutdown(); } }
private static void HandleCharacter(Match match, HttpListenerResponse response) { // here we are running in a thread different from the main thread int pid = Convert.ToInt32(match.Groups[1].Value); string responseString = ""; // event used to wait the answer from the main thread. AutoResetEvent autoEvent = new AutoResetEvent(false); // var to store the character we are looking for Character character = null; // this bool is to check character is valid ... explanation below bool found = false; // we queue an 'action' to be executed in the main thread MainGameObject.QueueOnMainThread(()=>{ // here we are in the main thread (see Update() in MainGameObject.cs) // retrieve the character character = MainGameObject.Instance().CharacterByID(pid); // if the character is null set found to false // have to do this because cannot call "character==null" elsewhere than the main thread // do not know why (yet?) // so if found this "trick" found = (character!=null?true:false); // set the event to "unlock" the thread autoEvent.Set(); }); // wait for the end of the 'action' executed in the main thread autoEvent.WaitOne(); // generate the HTTP answer if (found==false) { responseString = "<html><body>character: not found (" + pid + ")</body></html>"; } else { responseString = "<html><body>"; responseString += "<img src='data:image/jpg;base64," + character.imageB64 + "'></img></br>"; responseString += "name: " + character.name + "</br>"; responseString += "life: " + character.life + "</br>"; responseString += "streght " + character.streght + "</br>"; responseString += "dexterity " + character.dexterity + "</br>"; responseString += "consitution " + character.consitution + "</br>"; responseString += "intelligence " + character.intelligence + "</br>"; responseString += "</body></html>"; } byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString); // Get a response stream and write the response to it. response.ContentLength64 = buffer.Length; System.IO.Stream output = response.OutputStream; output.Write(buffer,0,buffer.Length); // You must close the output stream. output.Close(); }
public void Go() { // find all the upcoming UK horse races (EventTypeId 7) var marketFilter = new MarketFilter(); marketFilter.EventTypeIds = new HashSet<string>() { "7" }; marketFilter.MarketStartTime = new TimeRange() { From = DateTime.Now, To = DateTime.Now.AddDays(2) }; marketFilter.MarketTypeCodes = new HashSet<String>() { "WIN" }; Console.WriteLine("BetfairClient.ListEvents()"); var events = _client.ListEvents(marketFilter).Result; if (events.HasError) throw new ApplicationException(); var firstEvent = events.Response.First(); Console.WriteLine("First Event {0} {1}", firstEvent.Event.Id, firstEvent.Event.Name); var marketCatalogues = _client.ListMarketCatalogue( BFHelpers.HorseRaceFilter(), BFHelpers.HorseRaceProjection(), MarketSort.FIRST_TO_START, 25).Result.Response; marketCatalogues.ForEach(c => { _markets.Enqueue(c); Console.WriteLine(c.MarketName); }); Console.WriteLine(); while (_markets.Count > 0) { AutoResetEvent waitHandle = new AutoResetEvent(false); MarketCatalogue marketCatalogue; _markets.TryDequeue(out marketCatalogue); var marketSubscription = _streamingClient.SubscribeMarket(marketCatalogue.MarketId) .SubscribeOn(Scheduler.Default) .Subscribe( tick => { Console.WriteLine(BFHelpers.MarketSnapConsole(tick, marketCatalogue.Runners)); }, () => { Console.WriteLine("Market finished"); waitHandle.Set(); }); waitHandle.WaitOne(); marketSubscription.Dispose(); } }
public static AutoResetEvent WatchForEvents(FileSystemWatcher watcher, WatcherChangeTypes actions) { AutoResetEvent eventOccurred = new AutoResetEvent(false); if (0 != (actions & WatcherChangeTypes.Changed)) { watcher.Changed += (o, e) => { Assert.Equal(WatcherChangeTypes.Changed, e.ChangeType); eventOccurred.Set(); }; } if (0 != (actions & WatcherChangeTypes.Created)) { watcher.Created += (o, e) => { Assert.Equal(WatcherChangeTypes.Created, e.ChangeType); eventOccurred.Set(); }; } if (0 != (actions & WatcherChangeTypes.Deleted)) { watcher.Deleted += (o, e) => { Assert.Equal(WatcherChangeTypes.Deleted, e.ChangeType); eventOccurred.Set(); }; } if (0 != (actions & WatcherChangeTypes.Renamed)) { watcher.Renamed += (o, e) => { Assert.Equal(WatcherChangeTypes.Renamed, e.ChangeType); eventOccurred.Set(); }; } return eventOccurred; }
public void NonRepeatingTimer_ThatHasAlreadyFired_CanChangeAndFireAgain() { AutoResetEvent are = new AutoResetEvent(false); TimerCallback tc = new TimerCallback((object o) => are.Set()); using (var t = new Timer(tc, null, 1, Timeout.Infinite)) { Assert.True(are.WaitOne(MaxPositiveTimeoutInMs), "Should have received first timer event"); Assert.False(are.WaitOne(500), "Should not have received a second timer event"); t.Change(10, Timeout.Infinite); Assert.True(are.WaitOne(MaxPositiveTimeoutInMs), "Should have received a second timer event after changing it"); } }
public void Timer_Fires_After_DueTime_Ellapses() { AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { are.Set(); }), null, TimeSpan.FromMilliseconds(250), TimeSpan.FromMilliseconds(Timeout.Infinite) /* not relevant */)) { Assert.True(are.WaitOne(TimeSpan.FromMilliseconds(MaxPositiveTimeoutInMs))); } }
public void Running_Timer_CanBeFinalizedAndStopsFiring() { AutoResetEvent are = new AutoResetEvent(false); TimerCallback tc = new TimerCallback((object o) => are.Set()); var t = new Timer(tc, null, 1, 500); Assert.True(are.WaitOne(MaxPositiveTimeoutInMs), "Failed to get first timer fire"); t = null; // Remove our refence so the timer can be GC'd GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); Assert.False(are.WaitOne(500), "Should not have received a timer fire after it was collected"); }
public void Prepare(PreparingEnlistment preparingEnlistment) { WasPreparedCalled = true; switch (_phase1Vote) { case Phase1Vote.Prepared: { if (_volatileEnlistDuringPrepare) { TestEnlistment newVol = new TestEnlistment(_phase1Vote, _expectedOutcome); try { _txToEnlist.EnlistVolatile(newVol, EnlistmentOptions.None); Assert.True(_expectEnlistToSucceed); } catch (Exception) { Assert.False(_expectEnlistToSucceed); } } preparingEnlistment.Prepared(); break; } case Phase1Vote.ForceRollback: { _outcomeReceived?.Set(); preparingEnlistment.ForceRollback(); break; } case Phase1Vote.Done: { _outcomeReceived?.Set(); preparingEnlistment.Done(); break; } } }
public void Timer_Fires_AndPassesNullStateThroughCallback() { AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { Assert.Null(s); are.Set(); }), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(Timeout.Infinite) /* not relevant */)) { Assert.True(are.WaitOne(TimeSpan.FromMilliseconds(MaxPositiveTimeoutInMs))); } }
public void Timer_Change_BeforeDueTime_ChangesWhenTimerWillFire() { AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { are.Set(); }), null, TimeSpan.FromSeconds(500), TimeSpan.FromMilliseconds(50))) { Assert.False(are.WaitOne(TimeSpan.FromMilliseconds(100)), "The reset event should not have been set yet"); t.Change(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(-1)); Assert.True(are.WaitOne(TimeSpan.FromMilliseconds(TimerFiringTests.MaxPositiveTimeoutInMs)), "Should have received a timer event after this new duration"); } }
public int Run() { Stopwatch sw = new Stopwatch(); AutoResetEvent are = new AutoResetEvent(false); sw.Start(); bool ret = are.WaitOne(1000);//,false); sw.Stop(); //We should never get signaled if(ret) { Console.WriteLine("AutoResetEvent should never be signalled."); return -1; } if(sw.ElapsedMilliseconds < 900) { Console.WriteLine("It should take at least 900 milliseconds to call bool ret = are.WaitOne(1000,false);."); Console.WriteLine("sw.ElapsedMilliseconds = " + sw.ElapsedMilliseconds); return -2; } are.Set(); if(!are.WaitOne(0))//,false)) { Console.WriteLine("Signalled event should always return true on call to !are.WaitOne(0,false)."); return -3; } sw.Reset(); sw.Start(); ret = are.WaitOne(1000);//,false); sw.Stop(); //We should never get signaled if(ret) { Console.WriteLine("AutoResetEvent should never be signalled after is is AutoReset."); return -4; } if(sw.ElapsedMilliseconds < 900) { Console.WriteLine("It should take at least 900 milliseconds to call bool ret = are.WaitOne(1000,false);."); Console.WriteLine("sw.ElapsedMilliseconds = " + sw.ElapsedMilliseconds); return -5; } return 100; }
public void Timer_Fires_After_DueTime_AndOn_Period() { int count = 0; AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { if (Interlocked.Increment(ref count) >= 2) { are.Set(); } }), null, TimeSpan.FromMilliseconds(250), TimeSpan.FromMilliseconds(50))) { Assert.True(are.WaitOne(TimeSpan.FromMilliseconds(MaxPositiveTimeoutInMs))); } }
public void Timer_FiresOnlyOnce_OnDueTime_With_InfinitePeriod() { int count = 0; AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { if (Interlocked.Increment(ref count) >= 2) { are.Set(); } }), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(Timeout.Infinite) /* not relevant */)) { Assert.False(are.WaitOne(TimeSpan.FromMilliseconds(250 /*enough for 2 fires + buffer*/))); } }
public void Timer_Fires_After_DueTime_AndOn_Period() { int count = 0; AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { count++; if (count >= 2) { are.Set(); } }), null, TimeSpan.FromMilliseconds(250), TimeSpan.FromMilliseconds(50))) { Assert.True(are.WaitOne(TimeSpan.FromMilliseconds(2000))); } }
public void Timer_FiresOnlyOnce_OnDueTime_With_InfinitePeriod() { int count = 0; AutoResetEvent are = new AutoResetEvent(false); using (var t = new Timer(new TimerCallback((object s) => { count++; if (count >= 2) { are.Set(); } }), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(Timeout.Infinite) /* not relevant */)) { Assert.False(are.WaitOne(TimeSpan.FromSeconds(1))); } }
public static void FileSystemWatcher_InternalBufferSize_File() { using (var file = Utility.CreateTestFile()) using (var watcher = new FileSystemWatcher(".")) { watcher.Filter = Path.GetFileName(file.Path); ManualResetEvent unblockHandler = new ManualResetEvent(false); watcher.Changed += (o, e) => { // block the handling thread unblockHandler.WaitOne(); }; AutoResetEvent eventOccured = new AutoResetEvent(false); watcher.Error += (o, e) => { eventOccured.Set(); }; watcher.EnableRaisingEvents = true; // See note in FileSystemWatcher_Error_File int originalInternalBufferOperationCapacity = watcher.InternalBufferSize / (16 + 2 * (file.Path.Length + 1)); for (int i = 1; i < originalInternalBufferOperationCapacity * 2; i++) { File.SetLastWriteTime(file.Path, DateTime.Now + TimeSpan.FromSeconds(i)); } unblockHandler.Set(); Utility.ExpectEvent(eventOccured, "error"); // Update InternalBufferSize to accomadate the data watcher.InternalBufferSize = watcher.InternalBufferSize * 2; unblockHandler.Reset(); // Send the same number of events. for (int i = 1; i < originalInternalBufferOperationCapacity * 2; i++) { File.SetLastWriteTime(file.Path, DateTime.Now + TimeSpan.FromSeconds(i)); } unblockHandler.Set(); // This time we should not see an error Utility.ExpectNoEvent(eventOccured, "error"); } }
protected override void Run() { MessageBox.Show("CustomSilentBA just starting..."); try { var done = new AutoResetEvent(false); DetectPackageComplete += (s, e) => { //Debug.Assert(false); //Presence or absence of MyProductPackageId product will be a deciding factor //for initializing BA for Install or Uninstall. if (e.PackageId == "MyProductPackageId") { if (e.State == PackageState.Absent) this.Engine.Plan(LaunchAction.Install); else if (e.State == PackageState.Present) this.Engine.Plan(LaunchAction.Uninstall); } }; PlanComplete += (s, e) => { if (e.Status >= 0) this.Engine.Apply(IntPtr.Zero); }; ApplyComplete += (s, e) => { done.Set(); }; Engine.Detect(); done.WaitOne(); } catch (Exception e) { MessageBox.Show(e.ToString()); } Engine.Quit(0); }
public static int Main(String[] args) { var psi = new ProcessStartInfo(); psi.FileName = "cmd.exe"; // psi.Arguments = String.Join(" ", args); psi.Arguments = "/C cmd.exe /K 2>&1"; psi.WorkingDirectory = Directory.GetCurrentDirectory(); psi.UseShellExecute = false; psi.RedirectStandardInput = true; psi.RedirectStandardOutput = true; // NB: when you don't redirect standard error, it gets merged into standard output // psi.RedirectStandardError = true; var p = new Process(); p.StartInfo = psi; p.Exited += (o, e) => Environment.Exit(p.ExitCode); if (p.Start()) { var stdout = new StandardOutputReader(p); // var stderr = new StandardErrorReader(p); while (!p.HasExited) { WaitHandle.WaitAll(new []{stdout.Blocked}); // WaitHandle.WaitAll(new []{stdout.Blocked, stderr.Blocked}); var flag = new AutoResetEvent(false); var waiter = new Thread(() => { WaitHandle.WaitAny(new []{stdout.Unblocked}); flag.Set(); }); // var waiter = new Thread(() => { WaitHandle.WaitAny(new []{stdout.Unblocked, stderr.Unblocked}); flag.Set(); }); var writer = new Thread(() => { var command = Console.ReadLine(); HandleCommand(p, command); }); waiter.Start(); writer.Start(); flag.WaitOne(); } return p.ExitCode; } else { return -1; } }
/// <inheritdoc/> protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { Clear(); _disposeTokenSource.Cancel(); _delaySignal?.Set(); (_cache as IDisposable)?.Dispose(); _disposeTokenSource.Dispose(); _delaySignal?.Dispose(); } _delaySignal = null; _disposed = true; } }
private void StartReceiving() { while (_messageEventQueue.TryDequeue(out _)) { // do nothing } _exitReceiving = new AutoResetEvent(false); _receivePong = new AutoResetEvent(false); var frameStream = new WebSocketFrameStream(_stream); Task.Run(async() => { while (_readyState == WebSocketState.Open) { try { var frame = await frameStream.ReadFrameAsync(this).ConfigureAwait(false); if (frame == null) { return; } var result = await ProcessReceivedFrame(frame).ConfigureAwait(false); if (!result || _readyState == WebSocketState.Closed) { _exitReceiving?.Set(); return; } _ = Task.Run(Message); } catch (Exception ex) { Fatal("An exception has occurred while receiving.", ex); } } }); }
public void TestWaitOneSingleThreaded() { bool x; e1 = new AutoResetEvent(false); x = e1.WaitOne(10,false); AssertEquals("WaitOne(unset)", x, false); e1.Set(); x = e1.WaitOne(10,false); AssertEquals("WaitOne(set)", x, true); // It should be reset now. x = e1.WaitOne(10,false); AssertEquals("WaitOne(set)", x, false); }
public static void CheckForMensagensAsync(Action<List<Mensagem>> onMensagens) { var queued = ThreadPool.QueueUserWorkItem( new WaitCallback(parm => { var msgs = new List<Mensagem>(); var wait = new AutoResetEvent(false); using (var subscriber = _mensagens.Subscribe(msg => { msgs.Add(msg); wait.Set(); })) { // espera maxima para uma nova mensagem wait.WaitOne(TimeSpan.FromSeconds(MaxTimetoutSegundos)); } ((Action<List<Mensagem>>)parm)(msgs); }), onMensagens ); if (!queued) onMensagens(new List<Mensagem>()); }
public void PingPong() { using (AutoResetEvent are1 = new AutoResetEvent(true), are2 = new AutoResetEvent(false)) { const int Iters = 10; Task.WaitAll( Task.Factory.StartNew(() => { for (int i = 0; i < Iters; i++) { Assert.True(are1.WaitOne(FailedWaitTimeout)); are2.Set(); } }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default), Task.Factory.StartNew(() => { for (int i = 0; i < Iters; i++) { Assert.True(are2.WaitOne(FailedWaitTimeout)); are1.Set(); } }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)); } }
public StandardStreamReader(Process p, StreamReader stream) { this.Stream = stream; var lk = new Object(); EventWaitHandle finishedReading = new AutoResetEvent(false); var reads = 0; var reader = new Thread(() => { try { while (!p.HasExited) { const int cnt = 1; var buf = new char[cnt]; var n = TryRead(buf, 0, cnt); finishedReading.Set(); if (n == 0) break; lock (lk) { reads++; } AfterChunkRead(new String(buf, 0, n)); } } catch { var old = finishedReading; finishedReading = new ManualResetEvent(true); old.Set(); } }); var poller = new Thread(() => { while (!p.HasExited) { var success = finishedReading.WaitOne(50); if (!success) { Blocked.Set(); Unblocked.Reset(); finishedReading.WaitOne(); Unblocked.Set(); Blocked.Reset(); } } }); reader.Start(); poller.Start(); }
private void ProcEvents() { bool bDone = false; int hr; bool sp; int i = 0; IntPtr ip = IntPtr.Zero; while (!bDone) { while (m_Q.Count == 0) { Thread.Sleep(1); } EventParams ep = (EventParams)m_Q.Dequeue(); switch (ep.ec) { case EventCmd.Init: Config2(); break; case EventCmd.Run: m_mc.Run(); break; case EventCmd.Event: Debug.WriteLine(ep.EventID); if (ep.EventID == SBEEvent.StreamDescEvent) { if (!m_bWorked) { DVRStreamDesc sd = new DVRStreamDesc(); ip = IntPtr.Zero; sp = false; i = 0; hr = m_ge.GetEvent(ep.EventID, ep.Param1, ep.Param2, ep.Param3, ep.Param4, out sp, ref i, ip); Thread.Sleep(1); ip = Marshal.AllocCoTaskMem(i); try { sp = false; hr = m_ge.GetEvent(ep.EventID, ep.Param1, ep.Param2, ep.Param3, ep.Param4, out sp, ref i, ip); Marshal.PtrToStructure(ip, sd); m_bWorked = hr == 0 && sd.guidFormatType == sd.MediaType.formatType && sd.guidFormatType != Guid.Empty; } finally { Marshal.FreeCoTaskMem(ip); } } break; } break; case EventCmd.Exit: bDone = true; break; } m_re.Set(); } }
private void ProcessPongFrame() { _receivePong?.Set(); "Received a pong.".Trace(nameof(ProcessPongFrame)); }
public static int Main (string[] args) { Console.WriteLine ("Touch.Unit Simple Server"); Console.WriteLine ("Copyright 2011, Xamarin Inc. All rights reserved."); bool help = false; bool verbose = false; string address = null; string port = null; string log_path = "."; string log_file = null; string launchdev = null; string launchsim = null; bool autoexit = false; string device_name = String.Empty; string device_type = String.Empty; TimeSpan? timeout = null; TimeSpan? startup_timeout = null; var mtouch_arguments = new List<string> (); var os = new OptionSet () { { "h|?|help", "Display help", v => help = true }, { "verbose", "Display verbose output", v => verbose = true }, { "ip", "IP address to listen (default: Any)", v => address = v }, { "port", "TCP port to listen (default: Any)", v => port = v }, { "logpath", "Path to save the log files (default: .)", v => log_path = v }, { "logfile=", "Filename to save the log to (default: automatically generated)", v => log_file = v }, { "launchdev=", "Run the specified app on a device (specify using bundle identifier)", v => launchdev = v }, { "launchsim=", "Run the specified app on the simulator (specify using path to *.app directory)", v => launchsim = v }, { "autoexit", "Exit the server once a test run has completed (default: false)", v => autoexit = true }, { "devname=", "Specify the device to connect to", v => device_name = v}, { "device=", "Specifies the device type to launch the simulator", v => device_type = v }, { "timeout=", "Specifies a timeout (in minutes), after which the simulator app will be killed (ignored for device runs)", v => timeout = TimeSpan.FromMinutes (double.Parse (v)) }, { "startup-timeout=", "Specifies a timeout (in seconds) for the simulator app to connect to Touch.Server (ignored for device runs)", v => startup_timeout = TimeSpan.FromSeconds (double.Parse (v)) }, { "mtouch-argument=", "Specifies an extra mtouch argument when launching the application", v => mtouch_arguments.Add (v) }, }; try { os.Parse (args); if (help) ShowHelp (os); var listener = new SimpleListener (); IPAddress ip; if (String.IsNullOrEmpty (address) || !IPAddress.TryParse (address, out ip)) listener.Address = IPAddress.Any; ushort p; if (UInt16.TryParse (port, out p)) listener.Port = p; listener.LogPath = log_path ?? "."; listener.LogFile = log_file; listener.AutoExit = autoexit; listener.Initialize (); string mt_root = Environment.GetEnvironmentVariable ("MONOTOUCH_ROOT"); if (String.IsNullOrEmpty (mt_root)) mt_root = "/Developer/MonoTouch"; string mtouch = Path.Combine (mt_root, "bin", "mtouch"); if (!File.Exists (mtouch)) mtouch = Path.Combine (mt_root, "usr", "bin", "mtouch"); Process proc = null; if (launchdev != null) { ThreadPool.QueueUserWorkItem ((v) => { { proc = new Process (); StringBuilder output = new StringBuilder (); StringBuilder procArgs = new StringBuilder (); string sdk_root = Environment.GetEnvironmentVariable ("XCODE_DEVELOPER_ROOT"); if (!String.IsNullOrEmpty (sdk_root)) procArgs.Append ("--sdkroot ").Append (sdk_root); procArgs.Append (" --launchdev "); procArgs.Append (Quote (launchdev)); if (!String.IsNullOrEmpty (device_name)) procArgs.Append (" --devname=").Append (Quote (device_name)); procArgs.Append (" -argument=-connection-mode -argument=none"); procArgs.Append (" -argument=-app-arg:-autostart"); procArgs.Append (" -argument=-app-arg:-autoexit"); procArgs.Append (" -argument=-app-arg:-enablenetwork"); procArgs.AppendFormat (" -argument=-app-arg:-hostport:{0}", listener.Port); procArgs.Append (" -argument=-app-arg:-hostname:"); foreach (var arg in mtouch_arguments) procArgs.Append (" ").Append (arg); var ipAddresses = System.Net.Dns.GetHostEntry (System.Net.Dns.GetHostName ()).AddressList; for (int i = 0; i < ipAddresses.Length; i++) { if (i > 0) procArgs.Append (','); procArgs.Append (ipAddresses [i].ToString ()); } proc.StartInfo.FileName = mtouch; proc.StartInfo.Arguments = procArgs.ToString (); proc.StartInfo.UseShellExecute = false; proc.StartInfo.RedirectStandardOutput = true; proc.StartInfo.RedirectStandardError = true; proc.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs e) { lock (output) { output.Append ("[mtouch stderr] "); output.AppendLine (e.Data); } }; proc.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e) { lock (output) { output.Append ("[mtouch stdout] "); output.AppendLine (e.Data); } }; proc.Start (); proc.BeginErrorReadLine (); proc.BeginOutputReadLine (); proc.WaitForExit (); if (proc.ExitCode != 0) listener.Cancel (); Console.WriteLine (output.ToString ()); } }); } var lastErrorDataReceived = new AutoResetEvent (true); var lastOutDataReceived = new AutoResetEvent (true); if (launchsim != null) { lastErrorDataReceived.Reset (); lastOutDataReceived.Reset (); ThreadPool.QueueUserWorkItem ((v) => { { proc = new Process (); int pid = 0; StringBuilder output = new StringBuilder (); StringBuilder procArgs = new StringBuilder (); string sdk_root = Environment.GetEnvironmentVariable ("XCODE_DEVELOPER_ROOT"); if (!String.IsNullOrEmpty (sdk_root)) procArgs.Append ("--sdkroot ").Append (sdk_root); procArgs.Append (" --launchsim "); procArgs.Append (Quote (launchsim)); if (!string.IsNullOrEmpty (device_type)) procArgs.Append (" --device ").Append (device_type); procArgs.Append (" -argument=-connection-mode -argument=none"); procArgs.Append (" -argument=-app-arg:-autostart"); procArgs.Append (" -argument=-app-arg:-autoexit"); procArgs.Append (" -argument=-app-arg:-enablenetwork"); procArgs.Append (" -argument=-app-arg:-hostname:127.0.0.1"); procArgs.AppendFormat (" -argument=-app-arg:-hostport:{0}", listener.Port); foreach (var arg in mtouch_arguments) procArgs.Append (" ").Append (arg); proc.StartInfo.FileName = mtouch; proc.StartInfo.Arguments = procArgs.ToString (); proc.StartInfo.UseShellExecute = false; proc.StartInfo.RedirectStandardError = true; proc.StartInfo.RedirectStandardOutput = true; proc.StartInfo.RedirectStandardInput = true; proc.ErrorDataReceived += delegate(object sender, DataReceivedEventArgs e) { if (e.Data == null) { Console.WriteLine ("[mtouch stderr EOS]"); lastErrorDataReceived.Set (); return; } Console.WriteLine ("[mtouch stderr {0}] {1}", DateTime.Now.ToLongTimeString (), e.Data); }; proc.OutputDataReceived += delegate(object sender, DataReceivedEventArgs e) { if (e.Data == null){ Console.WriteLine ("[mtouch stdout EOS]"); lastOutDataReceived.Set (); return; } Console.WriteLine ("[mtouch stdout {0}] {1}", DateTime.Now.ToLongTimeString (), e.Data); if (e.Data.StartsWith ("Application launched. PID = ")) { var pidstr = e.Data.Substring ("Application launched. PID = ".Length); if (!int.TryParse (pidstr, out pid)) { Console.WriteLine ("Could not parse pid: {0}", pidstr); } else if (startup_timeout.HasValue) { ThreadPool.QueueUserWorkItem ((v2) => { if (!listener.WaitForConnection (startup_timeout.Value)) KillPid (proc, pid, 1000, startup_timeout.Value, "Startup"); }); } } }; if (verbose) Console.WriteLine ("{0} {1}", proc.StartInfo.FileName, proc.StartInfo.Arguments); proc.Start (); proc.BeginErrorReadLine (); proc.BeginOutputReadLine (); if (timeout.HasValue) { if (!proc.WaitForExit ((int) timeout.Value.TotalMilliseconds)) { if (pid != 0) { KillPid (proc, pid, 5000, timeout.Value, "Completion"); } else { proc.StandardInput.WriteLine (); // this kills as well, but we won't be able to send SIGQUIT to get a stack trace. } if (!proc.WaitForExit (5000 /* wait another 5 seconds for mtouch to finish as well */)) Console.WriteLine ("mtouch didn't complete within 5s of killing the simulator app. Touch.Server will exit anyway."); } } else { proc.WaitForExit (); } listener.Cancel (); } }); } var result = listener.Start (); if (proc != null && !proc.WaitForExit (10000 /* wait another 10 seconds for mtouch to finish as well */)) Console.WriteLine ("mtouch didn't complete within 10s of the simulator app exiting. Touch.Server will exit anyway."); // Wait up to 2 seconds to receive the last of the error/output data. This will only be received *after* // mtouch has exited. lastErrorDataReceived.WaitOne (2000); lastOutDataReceived.WaitOne (2000); return result; } catch (OptionException oe) { Console.WriteLine ("{0} for options '{1}'", oe.Message, oe.OptionName); return 1; } catch (Exception ex) { Console.WriteLine (ex); return 1; } }
public static void WaitNotificationTest() { ThreadTestHelpers.RunTestInBackgroundThread(() => { var tsc = new TestSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(tsc); Assert.Same(tsc, SynchronizationContext.Current); var e = new ManualResetEvent(false); tsc.WaitAction = () => e.Set(); Assert.False(tsc.IsWaitNotificationRequired()); Assert.False(e.WaitOne(0)); tsc.SetWaitNotificationRequired(); Assert.True(tsc.IsWaitNotificationRequired()); Assert.True(e.WaitOne(0)); var mres = new ManualResetEventSlim(); tsc.WaitAction = () => mres.Set(); mres.Reset(); mres.CheckedWait(); e.Reset(); tsc.WaitAction = () => e.Set(); SynchronizationContext.SetSynchronizationContext(new TestSynchronizationContext()); Assert.False(e.WaitOne(0)); SynchronizationContext.SetSynchronizationContext(tsc); Assert.True(e.WaitOne(0)); e.Reset(); e.CheckedWait(); e.Reset(); var lockObj = new object(); var lockAcquiredFromBackground = new AutoResetEvent(false); Action waitForThread; Thread t = ThreadTestHelpers.CreateGuardedThread(out waitForThread, () => { lock (lockObj) { lockAcquiredFromBackground.Set(); e.CheckedWait(); } }); t.IsBackground = true; t.Start(); lockAcquiredFromBackground.CheckedWait(); Assert.True(Monitor.TryEnter(lockObj, ThreadTestHelpers.UnexpectedTimeoutMilliseconds)); Monitor.Exit(lockObj); waitForThread(); e.Reset(); var m = new Mutex(); t = ThreadTestHelpers.CreateGuardedThread(out waitForThread, () => { m.CheckedWait(); try { lockAcquiredFromBackground.Set(); e.CheckedWait(); } finally { m.ReleaseMutex(); } }); t.IsBackground = true; t.Start(); lockAcquiredFromBackground.CheckedWait(); m.CheckedWait(); m.ReleaseMutex(); waitForThread(); }); }
public static void QueueRegisterPositiveAndFlowTest() { var asyncLocal = new AsyncLocal<int>(); asyncLocal.Value = 1; var obj = new object(); var registerWaitEvent = new AutoResetEvent(false); var threadDone = new AutoResetEvent(false); RegisteredWaitHandle registeredWaitHandle = null; Exception backgroundEx = null; int backgroundAsyncLocalValue = 0; Action<bool, Action> commonBackgroundTest = (isRegisteredWaitCallback, test) => { try { if (isRegisteredWaitCallback) { RegisteredWaitHandle toUnregister = registeredWaitHandle; registeredWaitHandle = null; Assert.True(toUnregister.Unregister(threadDone)); } test(); backgroundAsyncLocalValue = asyncLocal.Value; } catch (Exception ex) { backgroundEx = ex; } finally { if (!isRegisteredWaitCallback) { threadDone.Set(); } } }; Action<bool> waitForBackgroundWork = isWaitForRegisteredWaitCallback => { if (isWaitForRegisteredWaitCallback) { registerWaitEvent.Set(); } threadDone.CheckedWait(); if (backgroundEx != null) { throw new AggregateException(backgroundEx); } }; ThreadPool.QueueUserWorkItem( state => { commonBackgroundTest(false, () => { Assert.Same(obj, state); }); }, obj); waitForBackgroundWork(false); Assert.Equal(1, backgroundAsyncLocalValue); ThreadPool.UnsafeQueueUserWorkItem( state => { commonBackgroundTest(false, () => { Assert.Same(obj, state); }); }, obj); waitForBackgroundWork(false); Assert.Equal(0, backgroundAsyncLocalValue); registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject( registerWaitEvent, (state, timedOut) => { commonBackgroundTest(true, () => { Assert.Same(obj, state); Assert.False(timedOut); }); }, obj, UnexpectedTimeoutMilliseconds, false); waitForBackgroundWork(true); Assert.Equal(1, backgroundAsyncLocalValue); registeredWaitHandle = ThreadPool.UnsafeRegisterWaitForSingleObject( registerWaitEvent, (state, timedOut) => { commonBackgroundTest(true, () => { Assert.Same(obj, state); Assert.False(timedOut); }); }, obj, UnexpectedTimeoutMilliseconds, false); waitForBackgroundWork(true); Assert.Equal(0, backgroundAsyncLocalValue); }
public static IEnumerable <T> LookAhead <T>(Func <IEnumerable <T> > values, CancellationToken cancelToken) { // setup task completion sources to read results of look ahead using (var resultWriteEvent = new AutoResetEvent(false)) using (var resultReadEvent = new AutoResetEvent(false)) using (var internalCancelToken = new CancellationTokenSource()) { var results = new ConcurrentQueue <T>(); var resultReadIndex = new[] { -1 }; var targetIndex = new[] { 0 }; var resultsCount = 0; var finalCount = -1; var readTimes = new List <DateTime>(); readTimes.Add(DateTime.UtcNow); var exceptions = new ConcurrentBag <Exception>(); var lookAheadThread = new Thread(() => { try { // look-ahead loop var indexLocal = 0; var valuesLocal = values(); foreach (var value in valuesLocal) { // cooperative loop if (internalCancelToken.IsCancellationRequested || (cancelToken != null && cancelToken.IsCancellationRequested)) { return; } // store the result and notify results.Enqueue(value); resultsCount++; resultWriteEvent.Set(); // make sure look-ahead doesn't go too far ahead, based on calculated index above while (indexLocal > targetIndex[0]) { // cooperative loop if (internalCancelToken.IsCancellationRequested || (cancelToken != null && cancelToken.IsCancellationRequested)) { return; } // wait for a result to be read resultReadEvent.WaitOne(TimeSpan.FromMilliseconds(10)); } indexLocal++; } // notify done finalCount = resultsCount; resultWriteEvent.Set(); } catch (Exception e) { // notify the enumerator loop of any exceptions exceptions.Add(e); resultWriteEvent.Set(); } }); lookAheadThread.Name = "LookAhead.{0}".Format2(typeof(T)); lookAheadThread.Start(); try { // enumerate the results var i = 0; while (finalCount == -1 || i < finalCount) { // cooperative loop if (cancelToken != null) { cancelToken.ThrowIfCancellationRequested(); } // unblock loook-ahead and wait for current result to be come available resultReadEvent.Set(); while (i >= resultsCount && (finalCount == -1 || i < finalCount) && exceptions.Count == 0) { // cooperative loop if (cancelToken != null) { cancelToken.ThrowIfCancellationRequested(); } resultWriteEvent.WaitOne(TimeSpan.FromMilliseconds(10)); } // check if any exceptions occurred in the look-ahead loop if (exceptions.Count > 0) { throw new AggregateException(exceptions); } // check if enumration is finished if (finalCount != -1 && i >= finalCount) { break; } // retrieve current result and clear reference T result; if (!results.TryDequeue(out result)) { throw new Exception(); } // update current index and unblock look-ahead resultReadIndex[0] = i; resultReadEvent.Set(); i++; // store time the result was read readTimes.Add(DateTime.UtcNow); while (readTimes.Count > 500) { readTimes.RemoveAt(0); } // calculate how far to look-ahead based on how quickly the results are being read var firstReadTime = readTimes[0]; var readPerMillisecond = (float)(readTimes.Count / (DateTime.UtcNow - firstReadTime).TotalMilliseconds); if (float.IsNaN(readPerMillisecond)) { readPerMillisecond = 0; } targetIndex[0] = resultReadIndex[0] + 1 + (int)(readPerMillisecond * 1000); // look ahead 1000 milliseconds // yield result yield return(result); } } finally { // ensure look-ahead thread is cleaned up internalCancelToken.Cancel(); lookAheadThread.Join(); } } }
private static void OnExit(object sender, ConsoleCancelEventArgs args) { Closing.Set(); }
private void btnAbort_Click(object sender, EventArgs e) { btnAbort.Enabled = false; m_evtCancel.Set(); m_evtGlobalCancel.Set(); }
public void Exit() { notEntered.Set(); }
public virtual void Cleanup() { _areStartStop.Set(); }
public async Task EventDispatcher_EventsCoalesced2() { var waitDispatched = new AutoResetEvent(false); var executor = new MockJavaScriptExecutor { OnCallFunctionReturnFlushedQueue = (p0, p1, p2) => { waitDispatched.Set(); return(EmptyResponse); }, OnFlushQueue = () => EmptyResponse, OnInvokeCallbackAndReturnFlushedQueue = (_, __) => EmptyResponse }; var context = await CreateContextAsync(executor); var dispatcher = new EventDispatcher(context); await DispatcherHelpers.RunOnDispatcherAsync(dispatcher.OnResume); var winner = default(int); var disposed = new AutoResetEvent(false); var firstEvent = new TestEvent(42, TimeSpan.MaxValue, "foo", 1, () => winner = 1, () => disposed.Set()); var secondEvent = new TestEvent(42, TimeSpan.Zero, "foo", 1, () => winner = 2, () => disposed.Set()); using (BlockJavaScriptThread(context)) { dispatcher.DispatchEvent(firstEvent); dispatcher.DispatchEvent(secondEvent); // First event is disposed after coalesce Assert.IsTrue(disposed.WaitOne()); } Assert.IsTrue(waitDispatched.WaitOne()); Assert.AreEqual(1, winner); Assert.IsFalse(waitDispatched.WaitOne(500)); // Second event is disposed after dispatch Assert.IsTrue(disposed.WaitOne()); await DispatcherHelpers.RunOnDispatcherAsync(context.Dispose); }
private void synthesizer_SpeakCompleted(object sender, SpeakCompletedEventArgs e) { speakCompletedEvent.Set(); }
public void MustExecuteAsynchronously() { var configuration = new Mock <IFeatureConfiguration>(); var sync = new AutoResetEvent(false); var threadId = Thread.CurrentThread.ManagedThreadId; configuration.Setup(c => c.GetStatus()).Callback(() => { threadId = Thread.CurrentThread.ManagedThreadId; sync.Set(); }); sut.Observe(configuration.Object, FeatureConfigurationStatus.Disabled); sut.Start(); sync.WaitOne(); sut.Reset(); Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, threadId); }
private void CloseButton_Click(object sender, EventArgs e) { _resetEvent.Set(); ClearAndClose(); }
private static SimpleJavaResponse Run_Java_Executable(string Arguments) { // Using string builders to collect the standard output and error StringBuilder output = new StringBuilder(); StringBuilder error = new StringBuilder(); int exitCode = -1; // Perform all this work within using tag to encourage disposing of the process and events using (Process startSolrProcess = new Process()) using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false)) using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false)) { startSolrProcess.StartInfo.FileName = Java_Executable; startSolrProcess.StartInfo.Arguments = Arguments; startSolrProcess.StartInfo.UseShellExecute = false; startSolrProcess.StartInfo.RedirectStandardOutput = true; startSolrProcess.StartInfo.RedirectStandardError = true; startSolrProcess.StartInfo.CreateNoWindow = true; // Add a function to handle asynchronous reading of the standard output startSolrProcess.OutputDataReceived += (sender, e) => { if (e.Data == null) { outputWaitHandle.Set(); } else { output.AppendLine(" " + e.Data); } }; // Add a function to handle asynchronous reading of the standard error startSolrProcess.ErrorDataReceived += (sender, e) => { if (e.Data == null) { errorWaitHandle.Set(); } else { error.AppendLine(" " + e.Data); } }; // Start the process startSolrProcess.Start(); // Start the asyncronous reading of the standard input and standard output startSolrProcess.BeginOutputReadLine(); startSolrProcess.BeginErrorReadLine(); // Wait for the process to copmlete if (startSolrProcess.WaitForExit(2000)) { // Give the output readers slightly more time to finish any reading if (outputWaitHandle.WaitOne(100) && errorWaitHandle.WaitOne(100)) { // Successfully ended and process completed. Check process exit code here. exitCode = startSolrProcess.ExitCode; } } else { // Timed out. startSolrProcess.Close(); } // Ensure the output and error read events are not fired again try { startSolrProcess.CancelOutputRead(); } catch { } try { startSolrProcess.CancelErrorRead(); } catch { } } return(new SimpleJavaResponse(exitCode, (output + Environment.NewLine + error).Trim())); }
public void Dispose() { _disposeEvent.Set(); _thread.Join(); }
} // AddHookChannelUri // // end of IChannelReceiverHook implementation // // // Server helpers // // Thread for listening void Listen() { bool bOkToListen = false; try { _tcpListener.Start(); bOkToListen = true; } catch (Exception e) { _startListeningException = e; } _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket InternalRemotingServices.RemotingTrace("Waiting to Accept the Socket on Port: " + _port); // // Wait for an incoming socket // Socket socket; while (bOkToListen) { InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true"); try { socket = _tcpListener.AcceptSocket(); if (socket == null) { throw new RemotingException( String.Format( CoreChannel.GetResourceString("Remoting_Socket_Accept"), Marshal.GetLastWin32Error().ToString())); } else { // disable nagle delay socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1); // set linger option LingerOption lingerOption = new LingerOption(true, 3); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption); HttpServerSocketHandler streamManager = new HttpServerSocketHandler(socket, CoreChannel.RequestQueue); streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest); streamManager.BeginReadMessage(); } } catch (Exception e) { if (!_bListening) { // We called Stop() on the tcp listener, so gracefully exit. bOkToListen = false; } else { // we want the exception to show up as unhandled since this // is an unexpected failure. if (!(e is SocketException)) { //throw; } } } } // while (bOkToListen) }
public static void Go() { // Construct an AutoResetEvent (initially false) AutoResetEvent are = new AutoResetEvent(false); // Tell the thread pool to wait on the AutoResetEvent RegisteredWaitHandle rwh = ThreadPool.RegisterWaitForSingleObject( are, // Wait on this AutoResetEvent EventOperation, // When available, call the EventOperation method null, // Pass null to EventOperation 5000, // Wait 5 seconds for the event to become true false); // Call EventOperation everytime the event is true // Start our loop Char operation = (Char)0; while (operation != 'Q') { Console.WriteLine("S=Signal, Q=Quit?"); operation = Char.ToUpper(Console.ReadKey(true).KeyChar); if (operation == 'S') are.Set(); // User want to set the event } // Tell the thread pool to stop waiting on the event rwh.Unregister(null); }
/// <summary> /// Initialize the cache. /// </summary> internal void Initialize() { if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null) { _cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion); bool isReadOnly = _cacheManager.IsReadOnly; HashSet <Hash128> invalidEntries = null; if (isReadOnly) { Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)"); } else { invalidEntries = new HashSet <Hash128>(); } ReadOnlySpan <Hash128> guestProgramList = _cacheManager.GetGuestProgramList(); _progressReportEvent.Reset(); _shaderCount = 0; ShaderCacheStateChanged?.Invoke(true); ThreadPool.QueueUserWorkItem(ProgressLogger, guestProgramList.Length); for (int programIndex = 0; programIndex < guestProgramList.Length; programIndex++) { Hash128 key = guestProgramList[programIndex]; byte[] hostProgramBinary = _cacheManager.GetHostProgramByHash(ref key); bool hasHostCache = hostProgramBinary != null; IProgram hostProgram = null; // If the program sources aren't in the cache, compile from saved guest program. byte[] guestProgram = _cacheManager.GetGuestProgramByHash(ref key); if (guestProgram == null) { Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)"); // Should not happen, but if someone messed with the cache it's better to catch it. invalidEntries?.Add(key); continue; } ReadOnlySpan <byte> guestProgramReadOnlySpan = guestProgram; ReadOnlySpan <GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader); if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute) { Debug.Assert(cachedShaderEntries.Length == 1); GuestShaderCacheEntry entry = cachedShaderEntries[0]; HostShaderCacheEntry[] hostShaderEntries = null; // Try loading host shader binary. if (hasHostCache) { hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan); hostProgramBinary = hostProgramBinarySpan.ToArray(); hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary); } bool isHostProgramValid = hostProgram != null; ShaderProgram program; ShaderProgramInfo shaderProgramInfo; // Reconstruct code holder. if (isHostProgramValid) { program = new ShaderProgram(entry.Header.Stage, ""); shaderProgramInfo = hostShaderEntries[0].ToShaderProgramInfo(); } else { IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors); program = Translator.CreateContext(0, gpuAccessor, DefaultFlags | TranslationFlags.Compute).Translate(out shaderProgramInfo); } ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code); // If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again. if (hostProgram == null) { Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest..."); // Compile shader and create program as the shader program binary got invalidated. shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code); hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null); // As the host program was invalidated, save the new entry in the cache. hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader }); if (!isReadOnly) { if (hasHostCache) { _cacheManager.ReplaceHostProgram(ref key, hostProgramBinary); } else { Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)"); _cacheManager.AddHostProgram(ref key, hostProgramBinary); } } } _cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader)); } else { Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages); ShaderCodeHolder[] shaders = new ShaderCodeHolder[cachedShaderEntries.Length]; List <ShaderProgram> shaderPrograms = new List <ShaderProgram>(); TransformFeedbackDescriptor[] tfd = CacheHelper.ReadTransformFeedbackInformation(ref guestProgramReadOnlySpan, fileHeader); TranslationFlags flags = DefaultFlags; if (tfd != null) { flags = TranslationFlags.Feedback; } TranslationCounts counts = new TranslationCounts(); HostShaderCacheEntry[] hostShaderEntries = null; // Try loading host shader binary. if (hasHostCache) { hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan); hostProgramBinary = hostProgramBinarySpan.ToArray(); hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary); } bool isHostProgramValid = hostProgram != null; // Reconstruct code holder. for (int i = 0; i < cachedShaderEntries.Length; i++) { GuestShaderCacheEntry entry = cachedShaderEntries[i]; if (entry == null) { continue; } ShaderProgram program; if (entry.Header.SizeA != 0) { ShaderProgramInfo shaderProgramInfo; if (isHostProgramValid) { program = new ShaderProgram(entry.Header.Stage, ""); shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo(); } else { IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors); TranslatorContext translatorContext = Translator.CreateContext(0, gpuAccessor, flags, counts); TranslatorContext translatorContext2 = Translator.CreateContext((ulong)entry.Header.Size, gpuAccessor, flags | TranslationFlags.VertexA, counts); program = translatorContext.Translate(out shaderProgramInfo, translatorContext2); } // NOTE: Vertex B comes first in the shader cache. byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size).ToArray(); byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray(); shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2); } else { ShaderProgramInfo shaderProgramInfo; if (isHostProgramValid) { program = new ShaderProgram(entry.Header.Stage, ""); shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo(); } else { IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors); program = Translator.CreateContext(0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo); } shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code); } shaderPrograms.Add(program); } // If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again. if (!isHostProgramValid) { Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest..."); List <IShader> hostShaders = new List <IShader>(); // Compile shaders and create program as the shader program binary got invalidated. for (int stage = 0; stage < Constants.ShaderStages; stage++) { ShaderProgram program = shaders[stage]?.Program; if (program == null) { continue; } IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code); shaders[stage].HostShader = hostShader; hostShaders.Add(hostShader); } hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd); // As the host program was invalidated, save the new entry in the cache. hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders); if (!isReadOnly) { if (hasHostCache) { _cacheManager.ReplaceHostProgram(ref key, hostProgramBinary); } else { Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)"); _cacheManager.AddHostProgram(ref key, hostProgramBinary); } } } _gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders)); } _shaderCount = programIndex; } if (!isReadOnly) { // Remove entries that are broken in the cache _cacheManager.RemoveManifestEntries(invalidEntries); _cacheManager.FlushToArchive(); _cacheManager.Synchronize(); } _progressReportEvent.Set(); ShaderCacheStateChanged?.Invoke(false); Logger.Info?.Print(LogClass.Gpu, $"Shader cache loaded {_shaderCount} entries."); } }
public static void FileSystemWatcher_Error_File() { using (var file = Utility.CreateTestFile()) using (var watcher = new FileSystemWatcher(".")) { watcher.Filter = Path.GetFileName(file.Path); ManualResetEvent unblockHandler = new ManualResetEvent(false); watcher.Changed += (o, e) => { // block the handling thread unblockHandler.WaitOne(); }; AutoResetEvent eventOccurred = new AutoResetEvent(false); watcher.Error += (o, e) => { eventOccurred.Set(); }; watcher.EnableRaisingEvents = true; // FSW works by calling ReadDirectoryChanges aynchronously, processing the changes // in the callback and invoking event handlers from the callback serially. // After it processes all events for a particular callback it calls ReadDirectoryChanges // to queue another overlapped operation. // PER MSDN: // When you first call ReadDirectoryChangesW, the system allocates a buffer to store change // information. This buffer is associated with the directory handle until it is closed and // its size does not change during its lifetime. Directory changes that occur between calls // to this function are added to the buffer and then returned with the next call. If the // buffer overflows, the entire contents of the buffer are discarded, the lpBytesReturned // parameter contains zero, and the ReadDirectoryChangesW function fails with the error // code ERROR_NOTIFY_ENUM_DIR. // We can force the error by increasing the amount of time between calls to ReadDirectoryChangesW // By blocking in an event handler, we allow the main thread of our test to generate a ton // of change events and overflow the OS's buffer. // We could copy the result of the operation and immediately call ReadDirectoryChangesW to // limit the amount of time where we rely on the OS's buffer. The downside of doing so // is it can allow memory to grow out of control. // FSW tries to mitigate this by exposing InternalBufferSize. The OS uses this when allocating // it's internal buffer (up to some limit). Our docs say that limit is 64KB but testing on Win8.1 // indicates that it is much higher than this: I could grow the buffer up to 128 MB and still see // that it had an effect. The size needed per operation is determined by the struct layout of // FILE_NOTIFY_INFORMATION. This works out to 16 + 2 * (filePath.Length + 1) bytes, where filePath // is the path to changed file relative to the path passed into ReadDirectoryChanges. // At some point we might decide to improve how FSW handles this at which point we'll need // a better test for Error (perhaps just a mock), but for now there is some value in forcing this limit. int internalBufferOperationCapacity = watcher.InternalBufferSize / (12 + 2 * (file.Path.Length + 1)); // generate enough file change events to overflow the buffer // 4x is an approximation that should force the overflow. for (int i = 1; i < internalBufferOperationCapacity * 4; i++) { File.SetLastWriteTime(file.Path, DateTime.Now + TimeSpan.FromSeconds(i)); } unblockHandler.Set(); Utility.ExpectEvent(eventOccurred, "error"); } }
private static WavechartBox show(String title, bool hold, params Tuple <Signal, int>[] series) { WavechartBox form = null; Thread formThread = null; AutoResetEvent stopWaitHandle = new AutoResetEvent(false); formThread = new Thread(() => { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Show control in a form form = new WavechartBox(); form.Text = title; form.formThread = formThread; if (!String.IsNullOrEmpty(title)) { form.zedGraphControl.GraphPane.Title.IsVisible = true; form.zedGraphControl.GraphPane.Title.Text = title; } var sequence = new ColorSequenceCollection(series.Length); for (int i = 0; i < series.Length; i++) { var signal = series[i].Item1; int channel = series[i].Item2; ComplexSignal complex = signal as ComplexSignal; if (complex != null && complex.Status != ComplexSignalStatus.Normal) { double[] spectrum = Accord.Audio.Tools.GetPowerSpectrum(complex.GetChannel(channel)); double[] frequencies = Accord.Audio.Tools.GetFrequencyVector(signal.Length, signal.SampleRate); form.series.Add(new LineItem(i.ToString(), frequencies, spectrum, sequence.GetColor(i), SymbolType.None)); form.zedGraphControl.GraphPane.XAxis.Title.Text = "Frequency"; form.zedGraphControl.GraphPane.YAxis.Title.Text = "Power"; } else { double[] values; if (signal.Channels == 1) { values = signal.ToDouble(); } else { ExtractChannel extract = new ExtractChannel(channel); values = extract.Apply(signal).ToDouble(); } form.series.Add(new LineItem(i.ToString(), Vector.Range(0, signal.Length).ToDouble(), values, sequence.GetColor(i), SymbolType.None)); form.zedGraphControl.GraphPane.XAxis.Title.Text = "Time"; form.zedGraphControl.GraphPane.YAxis.Title.Text = "Amplitude"; } } form.zedGraphControl.GraphPane.AxisChange(); stopWaitHandle.Set(); Application.Run(form); }); formThread.SetApartmentState(ApartmentState.STA); formThread.Start(); stopWaitHandle.WaitOne(); if (!hold) { formThread.Join(); } return(form); }
/// <summary> /// /// </summary> /// <param name="filename"></param> /// <param name="arguments"></param> /// <param name="timeout"></param> /// <param name="strStatus"></param> /// <returns></returns> public static int StartProcess(string filename, string arguments, Int32 timeout, ref string strStatus) { int intExitCode = 0; using (Process process = new Process()) { process.StartInfo.FileName = filename; process.StartInfo.Arguments = arguments; process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; StringBuilder output = new StringBuilder(); StringBuilder error = new StringBuilder(); using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false)) using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false)) { process.OutputDataReceived += (sender, e) => { if (e.Data == null) { outputWaitHandle.Set(); } else { output.AppendLine(e.Data); } }; process.ErrorDataReceived += (sender, e) => { if (e.Data == null) { errorWaitHandle.Set(); } else { error.AppendLine(e.Data); } }; process.Start(); process.BeginOutputReadLine(); process.BeginErrorReadLine(); if (process.WaitForExit(timeout) && outputWaitHandle.WaitOne(timeout) && errorWaitHandle.WaitOne(timeout)) { // Process completed. Check process.ExitCode here. intExitCode = process.ExitCode; } else { // Timed out. intExitCode = -2; } strStatus = output.ToString() + "\n" + error.ToString(); strStatus = strStatus.Trim(); } } return intExitCode; }
public void Dispose() { m_Disposing = true; m_Signal.Set(); }
public void SendEvent() { sendEvent.Set(); }
public static void ConvertHtmlToPdf(PdfDocument document, PdfConvertEnvironment environment, PdfOutput woutput) { if (environment == null) { environment = Environment; } if (document.Html != null) { document.Url = "-"; } String outputPdfFilePath; bool delete; if (woutput.OutputFilePath != null) { outputPdfFilePath = woutput.OutputFilePath; delete = false; } else { outputPdfFilePath = Path.Combine(environment.TempFolderPath, String.Format("{0}.pdf", Guid.NewGuid())); delete = true; } if (!File.Exists(environment.WkHtmlToPdfPath)) { throw new PdfConvertException(String.Format("File '{0}' not found. Check if wkhtmltopdf application is installed.", environment.WkHtmlToPdfPath)); } StringBuilder paramsBuilder = new StringBuilder(); paramsBuilder.Append("--page-size A4 "); if (!string.IsNullOrEmpty(document.HeaderUrl)) { paramsBuilder.AppendFormat("--header-html {0} ", document.HeaderUrl); paramsBuilder.Append("--margin-top 25 "); paramsBuilder.Append("--header-spacing 5 "); } if (!string.IsNullOrEmpty(document.FooterUrl)) { paramsBuilder.AppendFormat("--footer-html {0} ", document.FooterUrl); paramsBuilder.Append("--margin-bottom 25 "); paramsBuilder.Append("--footer-spacing 5 "); } if (!string.IsNullOrEmpty(document.HeaderLeft)) { paramsBuilder.AppendFormat("--header-left \"{0}\" ", document.HeaderLeft); } if (!string.IsNullOrEmpty(document.HeaderCenter)) { paramsBuilder.AppendFormat("--header-center \"{0}\" ", document.HeaderCenter); } if (!string.IsNullOrEmpty(document.HeaderRight)) { paramsBuilder.AppendFormat("--header-right \"{0}\" ", document.HeaderRight); } if (!string.IsNullOrEmpty(document.FooterLeft)) { paramsBuilder.AppendFormat("--footer-left \"{0}\" ", document.FooterLeft); } if (!string.IsNullOrEmpty(document.FooterCenter)) { paramsBuilder.AppendFormat("--footer-center \"{0}\" ", document.FooterCenter); } if (!string.IsNullOrEmpty(document.FooterRight)) { paramsBuilder.AppendFormat("--footer-right \"{0}\" ", document.FooterRight); } if (document.ExtraParams != null) { foreach (var extraParam in document.ExtraParams) { paramsBuilder.AppendFormat("--{0} {1} ", extraParam.Key, extraParam.Value); } } if (document.Cookies != null) { foreach (var cookie in document.Cookies) { paramsBuilder.AppendFormat("--cookie {0} {1} ", cookie.Key, cookie.Value); } } paramsBuilder.AppendFormat("\"{0}\" \"{1}\"", document.Url, outputPdfFilePath); try { StringBuilder output = new StringBuilder(); StringBuilder error = new StringBuilder(); using (Process process = new Process()) { process.StartInfo.FileName = environment.WkHtmlToPdfPath; process.StartInfo.Arguments = paramsBuilder.ToString(); process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.StartInfo.RedirectStandardInput = true; using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false)) using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false)) { DataReceivedEventHandler outputHandler = (sender, e) => { if (e.Data == null) { outputWaitHandle.Set(); } else { output.AppendLine(e.Data); } }; DataReceivedEventHandler errorHandler = (sender, e) => { if (e.Data == null) { errorWaitHandle.Set(); } else { error.AppendLine(e.Data); } }; process.OutputDataReceived += outputHandler; process.ErrorDataReceived += errorHandler; try { process.Start(); process.BeginOutputReadLine(); process.BeginErrorReadLine(); if (document.Html != null) { using (var stream = process.StandardInput) { byte[] buffer = Encoding.UTF8.GetBytes(document.Html); stream.BaseStream.Write(buffer, 0, buffer.Length); stream.WriteLine(); } } if (process.WaitForExit(environment.Timeout) && outputWaitHandle.WaitOne(environment.Timeout) && errorWaitHandle.WaitOne(environment.Timeout)) { if (process.ExitCode != 0 && !File.Exists(outputPdfFilePath)) { throw new PdfConvertException(String.Format("Html to PDF conversion of '{0}' failed. Wkhtmltopdf output: \r\n{1}", document.Url, error)); } } else { if (!process.HasExited) { process.Kill(); } throw new PdfConvertTimeoutException(); } } finally { process.OutputDataReceived -= outputHandler; process.ErrorDataReceived -= errorHandler; } } } if (woutput.OutputStream != null) { using (Stream fs = new FileStream(outputPdfFilePath, FileMode.Open)) { byte[] buffer = new byte[32 * 1024]; int read; while ((read = fs.Read(buffer, 0, buffer.Length)) > 0) { woutput.OutputStream.Write(buffer, 0, read); } } } if (woutput.OutputCallback != null) { byte[] pdfFileBytes = File.ReadAllBytes(outputPdfFilePath); woutput.OutputCallback(document, pdfFileBytes); } } finally { if (delete && File.Exists(outputPdfFilePath)) { File.Delete(outputPdfFilePath); } } }
public static void Main() { // TODO:// replace with your app details and Betfair username/password BetfairClient client = new BetfairClient(Exchange.UK); client.Login( "nur1euro", "niedero", "nur1euro"); // find all the upcoming UK horse races (EventTypeId 7) var marketFilter = new MarketFilter(); marketFilter.EventTypeIds = new HashSet<string>() { "7" }; marketFilter.MarketStartTime = new TimeRange() { From = DateTime.Now, To = DateTime.Now.AddDays(1) }; marketFilter.MarketTypeCodes = new HashSet<String>() { "WIN" }; var eventTypes = client.ListEventTypes(marketFilter); Console.WriteLine("BetfairClient.ListTimeRanges()"); var timeRanges = client.ListTimeRanges(marketFilter, TimeGranularity.HOURS).Result; if (timeRanges.HasError) throw new ApplicationException(); var marketCatalogues = client.ListMarketCatalogue( BFUtil.HorseRaceFilter("GB"), BFUtil.HorseRaceProjection(), MarketSort.FIRST_TO_START, 100).Result.Response; marketCatalogues.ForEach(c => { //Markets.Enqueue(c); List<String> marketIdList = new List<string>(); marketIdList.Add(c.MarketId); OrderProjection orderProjection = OrderProjection.ALL; MatchProjection matchProjection = MatchProjection.NO_ROLLUP; var marketBook = client.ListMarketBook( marketIdList, BFUtil.HorseRacePriceProjection(), orderProjection, matchProjection ).Result.Response; Console.WriteLine(BFUtil.checkMarket(c, marketBook[0])); //Console.WriteLine(c.MarketName); }); Console.WriteLine(); var marketListener = MarketListener.Create(client, BFUtil.HorseRacePriceProjection(), 1); //while (Markets.Count > 0) //{ AutoResetEvent waitHandle = new AutoResetEvent(false); MarketCatalogue marketCatalogue; Markets.TryDequeue(out marketCatalogue); var marketSubscription = marketListener.SubscribeMarketBook(marketCatalogue.MarketId) .SubscribeOn(Scheduler.Default) .Subscribe( tick => { Console.WriteLine(BFUtil.MarketBookConsole(marketCatalogue, tick, marketCatalogue.Runners)); }, () => { Console.WriteLine("Market finished"); waitHandle.Set(); }); waitHandle.WaitOne(); marketSubscription.Dispose(); //} Console.WriteLine("done."); Console.ReadLine(); }
public void Stop() { m_stop = true; m_event.Set(); }
/// <summary> /// /// </summary> /// <param name="e"></param> public void AddReq(CacheEntry e) { //lock (queue) queue.Enqueue(e); ev.Set(); }
private string ExtractTextFromAudio(string targetFile, int delayInMilliseconds) { var output = new StringBuilder(); var path = Path.Combine(Configuration.DataDirectory, "pocketsphinx"); var fileName = Path.Combine(path, "bin", "Release", "Win32", "pocketsphinx_continuous.exe"); var hmm = Path.Combine(path, "model", "en-us", "en-us"); var lm = Path.Combine(path, "model", "en-us", "en-us.lm.bin"); var dict = Path.Combine(path, "model", "en-us", "cmudict-en-us.dict"); var pocketPhinxParams = $"-infile \"{targetFile}\" -hmm \"{hmm}\" -lm \"{lm}\" -dict \"{dict}\" -time yes"; // > \"{_resultFile}\""; var process = new Process { StartInfo = new ProcessStartInfo(fileName, pocketPhinxParams) { CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden } }; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.StartInfo.UseShellExecute = false; using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false)) using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false)) { process.OutputDataReceived += (sender, e) => { if (_abort) { return; } if (e.Data == null) { outputWaitHandle.Set(); } else { output.AppendLine(e.Data); var seconds = GetLastTimeStampInSeconds(e.Data); if (seconds > 0) { _backgroundWorker.ReportProgress(seconds); } _backgroundWorker.ReportProgress(LogOutput, e.Data); } }; process.ErrorDataReceived += (sender, e) => { if (_abort) { return; } if (e.Data == null) { errorWaitHandle.Set(); } else { _backgroundWorker.ReportProgress(LogInfo, e.Data); } }; process.Start(); process.BeginOutputReadLine(); process.BeginErrorReadLine(); var killed = false; while (!process.HasExited) { Application.DoEvents(); Thread.Sleep(50); if (_abort && !killed) { process.Kill(); killed = true; } } } return output.ToString(); }
internal void SetIoc(DataPipe pipe) { ClientTcpReceiver tcpReceiver = (ClientTcpReceiver)pipe[0]; tcpReceiver.AddChannel(this); lock ( ConnectionLock ) { if (!Client.Searcher.Contains(this)) { return; } Client.Searcher.Remove(this); SID = 0; ioc = tcpReceiver; lock (ioc.ChannelSID) { // Console.WriteLine(ioc.ChannelSID.Count) ; // Channel already known if (ioc.ChannelSID.ContainsKey(ChannelName)) { SID = ioc.ChannelSID[ChannelName]; // Console.WriteLine("Here") ; Channel chan = ioc.ConnectedChannels.FirstOrDefault( row => row.ChannelName == ChannelName && row.ChannelDataCount != 0 ); if (chan != null) { this.ChannelDataCount = chan.ChannelDataCount; this.channelDefinedType = chan.channelDefinedType; this.ChannelDataCount = chan.ChannelDataCount; this.channelDefinedType = chan.ChannelDefinedType; Status = ChannelStatus.CONNECTED; ConnectionEvent.Set(); } } } } if (SID != 0) { // Console.WriteLine("SID " + SID + " STATUS CHANGED") ; StatusChanged?.Invoke(this, Status); return; } if (Client.Configuration.DebugTiming) { lock ( ElapsedTimings ) { if (!ElapsedTimings.ContainsKey("IocConnection")) { ElapsedTimings.Add( "IocConnection", Stopwatch.Elapsed ); } } } // We need to create the channel int padding; if (ChannelName.Length % 8 == 0) { padding = 8; } else { padding = ( 8 - (ChannelName.Length % 8) ); } DataPacket packet = DataPacket.Create( 16 + ChannelName.Length + padding ); packet.Command = (ushort)CommandID.CA_PROTO_CREATE_CHAN; packet.DataType = 0; packet.DataCount = 0; packet.Parameter1 = cid; packet.Parameter2 = (uint)CAConstants.CA_MINOR_PROTOCOL_REVISION; packet.SetDataAsString(ChannelName); if (ioc != null) { ioc.Send(packet); } else { Disconnect(); return; } lock ( ElapsedTimings ) { if (!ElapsedTimings.ContainsKey("SendCreateChannel")) { ElapsedTimings.Add( "SendCreateChannel", Stopwatch.Elapsed ); } } }
public static void BasicLockTest() { var trwl = new TestReaderWriterLock(); TestLockCookie tlc; var threadReady = new AutoResetEvent(false); var continueThread = new AutoResetEvent(false); Action checkForThreadErrors, waitForThread; Thread t = ThreadTestHelpers.CreateGuardedThread(out checkForThreadErrors, out waitForThread, () => { TestLockCookie tlc2; Action switchToMainThread = () => { threadReady.Set(); continueThread.CheckedWait(); }; switchToMainThread(); // Multiple readers from multiple threads { trwl.AcquireReaderLock(); trwl.AcquireReaderLock(); switchToMainThread(); trwl.ReleaseReaderLock(); switchToMainThread(); trwl.ReleaseReaderLock(); switchToMainThread(); trwl.AcquireReaderLock(); trwl.ReleaseReaderLock(); switchToMainThread(); } // What can be done when a read lock is held { trwl.AcquireReaderLock(); switchToMainThread(); // Any thread can take a read lock trwl.AcquireReaderLock(); trwl.ReleaseReaderLock(); switchToMainThread(); // No thread can take a write lock trwl.AcquireWriterLock(TimeoutExceptionHResult); trwl.AcquireReaderLock(); trwl.UpgradeToWriterLock(TimeoutExceptionHResult); trwl.ReleaseReaderLock(); switchToMainThread(); trwl.ReleaseReaderLock(); switchToMainThread(); // Owning thread releases read lock when upgrading trwl.AcquireWriterLock(); trwl.ReleaseWriterLock(); switchToMainThread(); // Owning thread cannot upgrade if there are other readers or writers trwl.AcquireReaderLock(); switchToMainThread(); trwl.ReleaseReaderLock(); trwl.AcquireWriterLock(); switchToMainThread(); trwl.ReleaseWriterLock(); switchToMainThread(); } // What can be done when a write lock is held { // Write lock acquired through AcquireWriteLock is exclusive trwl.AcquireWriterLock(); switchToMainThread(); trwl.ReleaseWriterLock(); switchToMainThread(); // Write lock acquired through upgrading is also exclusive trwl.AcquireReaderLock(); tlc2 = trwl.UpgradeToWriterLock(); switchToMainThread(); trwl.DowngradeFromWriterLock(tlc2); trwl.ReleaseReaderLock(); switchToMainThread(); // Write lock acquired through restore is also exclusive trwl.AcquireWriterLock(); tlc = trwl.ReleaseLock(); trwl.RestoreLock(tlc); switchToMainThread(); trwl.ReleaseWriterLock(); switchToMainThread(); } }); t.IsBackground = true; t.Start(); Action beginSwitchToBackgroundThread = () => continueThread.Set(); Action endSwitchToBackgroundThread = () => { try { threadReady.CheckedWait(); } finally { checkForThreadErrors(); } }; Action switchToBackgroundThread = () => { beginSwitchToBackgroundThread(); endSwitchToBackgroundThread(); }; endSwitchToBackgroundThread(); // Multiple readers from muliple threads { trwl.AcquireReaderLock(); trwl.AcquireReaderLock(); switchToBackgroundThread(); // AcquireReaderLock * 2 trwl.ReleaseReaderLock(); switchToBackgroundThread(); // ReleaseReaderLock // Release/restore the read lock while a read lock is held by another thread tlc = trwl.ReleaseLock(); trwl.RestoreLock(tlc); switchToBackgroundThread(); // ReleaseReaderLock // Downgrade to read lock allows another thread to acquire read lock tlc = trwl.UpgradeToWriterLock(); trwl.DowngradeFromWriterLock(tlc); switchToBackgroundThread(); // AcquireReaderLock, ReleaseReaderLock trwl.ReleaseReaderLock(); } // What can be done when a read lock is held { switchToBackgroundThread(); // AcquireReaderLock { // Any thread can take a read lock trwl.AcquireReaderLock(); trwl.ReleaseReaderLock(); switchToBackgroundThread(); // same as above // No thread can take a write lock trwl.AcquireWriterLock(TimeoutExceptionHResult); trwl.AcquireReaderLock(); trwl.UpgradeToWriterLock(TimeoutExceptionHResult); switchToBackgroundThread(); // same as above trwl.ReleaseReaderLock(); // Other threads cannot upgrade to a write lock, but the owning thread can trwl.AcquireReaderLock(); trwl.UpgradeToWriterLock(TimeoutExceptionHResult); trwl.ReleaseReaderLock(); } switchToBackgroundThread(); // ReleaseReaderLock // Owning thread releases read lock when upgrading trwl.AcquireReaderLock(); beginSwitchToBackgroundThread(); // AcquireWriterLock: background thread gets blocked trwl.UpgradeToWriterLock(); // unblocks background thread: ReleaseWriterLock trwl.ReleaseWriterLock(); endSwitchToBackgroundThread(); // Owning thread cannot upgrade if there are other readers or writers trwl.AcquireReaderLock(); switchToBackgroundThread(); // AcquireReaderLock trwl.UpgradeToWriterLock(TimeoutExceptionHResult); trwl.ReleaseReaderLock(); switchToBackgroundThread(); // ReleaseReaderLock, AcquireWriterLock trwl.UpgradeToWriterLock(TimeoutExceptionHResult); switchToBackgroundThread(); // ReleaseWriterLock } // What can be done when a write lock is held { trwl.AcquireWriterLock(); TestLockCookie restoreToWriteLockTlc = trwl.ReleaseLock(); Action verifyCannotAcquireLock = () => { trwl.AcquireReaderLock(TimeoutExceptionHResult); trwl.AcquireWriterLock(TimeoutExceptionHResult); trwl.UpgradeToWriterLock(TimeoutExceptionHResult); }; Action verifyCanAcquireLock = () => { trwl.AcquireReaderLock(); tlc = trwl.UpgradeToWriterLock(); trwl.DowngradeFromWriterLock(tlc); trwl.ReleaseReaderLock(); trwl.AcquireWriterLock(); trwl.ReleaseWriterLock(); trwl.RestoreLock(restoreToWriteLockTlc.Clone()); trwl.ReleaseWriterLock(); }; // Write lock acquired through AcquireWriteLock is exclusive switchToBackgroundThread(); // AcquireWriterLock verifyCannotAcquireLock(); switchToBackgroundThread(); // ReleaseWriterLock verifyCanAcquireLock(); // Write lock acquired through upgrading is also exclusive switchToBackgroundThread(); // AcquireReaderLock, UpgradeToWriterLock verifyCannotAcquireLock(); switchToBackgroundThread(); // DowngradeFromWriterLock, ReleaseReaderLock verifyCanAcquireLock(); // Write lock acquired through restore is also exclusive switchToBackgroundThread(); // AcquireWriterLock, ReleaseLock, RestoreLock verifyCannotAcquireLock(); switchToBackgroundThread(); // ReleaseWriterLock verifyCanAcquireLock(); } beginSwitchToBackgroundThread(); waitForThread(); trwl.Dispose(); }
public static async Task <String> GetCLIOutputAsync(string solutionDir) { String strAppPath = GetAssemblyLocalPathFrom(typeof(MainPanelCommand)); String strFilePath = Path.Combine(strAppPath, "Resources"); String pathToCli = Path.Combine(strFilePath, "jfrog.exe"); await OutputLog.ShowMessageAsync("Path for the JFrog CLI: " + pathToCli); //Create process Process pProcess = new System.Diagnostics.Process(); // strCommand is path and file name of command to run pProcess.StartInfo.FileName = pathToCli; // strCommandParameters are parameters to pass to program // Here we will run the nuget command for the cli pProcess.StartInfo.Arguments = "rt nuget-deps-tree"; pProcess.StartInfo.UseShellExecute = false; pProcess.StartInfo.CreateNoWindow = true; // Set output of program to be written to process output stream pProcess.StartInfo.RedirectStandardOutput = true; pProcess.StartInfo.RedirectStandardError = true; pProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; pProcess.StartInfo.WorkingDirectory = solutionDir; StringBuilder strOutput = new StringBuilder(); StringBuilder error = new StringBuilder(); // Saving the response from the CLI to a StringBuilder. using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false)) using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false)) { // Get program output // The json returned from the CLI pProcess.OutputDataReceived += (sender, e) => { if (e.Data == null) { outputWaitHandle.Set(); } else { strOutput.AppendLine(e.Data); } }; pProcess.ErrorDataReceived += (sender, e) => { if (e.Data == null) { errorWaitHandle.Set(); } else { error.AppendLine(e.Data); } }; // Start the process pProcess.Start(); pProcess.BeginOutputReadLine(); pProcess.BeginErrorReadLine(); pProcess.WaitForExit(); // Wait for the entire output to be written if (outputWaitHandle.WaitOne(2) && errorWaitHandle.WaitOne(2)) { // Process completed. Check process.ExitCode here. if (pProcess.ExitCode != 0) { string message = "Failed to get CLI output. Exit code: " + pProcess.ExitCode + " Returned error:" + error.ToString(); throw new IOException(message); } if (!string.IsNullOrEmpty(error.ToString())) { await OutputLog.ShowMessageAsync(error.ToString()); } // Returning the output from the CLI that is the json itself. return(strOutput.ToString()); } else { // Timed out. await OutputLog.ShowMessageAsync("Process timeout"); throw new IOException("Process timeout, please run the following command from the solution directory and send us the output:" + pathToCli + " rt ndt"); } } }
public void Enqueue(Action action) { actions.Enqueue(action); messageArrived.Set(); }