static void Main(string[] args) { LogManager.LogFactory = new NLogFactory(); var appHost = new AppHost(); var appConfig = new TsonServiceConfig(args.Length > 0 ? args[0] : null, args.Length > 1 ? args[1] : null); appHost.Container.Register<ITsonServiceConfig>(appConfig); appHost.Init(); appHost.Start(appConfig.ServiceUrl); UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; // Wait for a unix signal for (bool exit = false; !exit;) { int id = UnixSignal.WaitAny(signals); if (id >= 0 && id < signals.Length) { if (signals[id].IsSet) exit = true; } } }
static void Main(string[] args) { var oledType = Util.ChooseOLEDType(); Console.WriteLine($"Running test with selected display [{oledType}]"); Console.WriteLine("Hit CTRL+C to stop"); var wr = new Wrapper(oledType); wr.SetTextColor(1); wr.SetTextSize(2); UnixSignal sigint = new UnixSignal(Mono.Unix.Native.Signum.SIGINT); while (!sigint.IsSet) { wr.ClearDisplay(); wr.SetCursor(0, 0); var str = $"{DateTime.Now.ToString("HH:mm.ss")}"; Console.WriteLine(str); wr.Print(str); wr.Display(); Thread.Sleep(1000); } }
public UnixSignal(Mono.Unix.Native.Signum signum) { this.signum = NativeConvert.FromSignum(signum); this.signal_info = UnixSignal.install(this.signum); if (this.signal_info == IntPtr.Zero) { throw new ArgumentException("Unable to handle signal", "signum"); } }
static void Main(string[] args) { //Set up IO - (TODO, allow to be set in config file) var RingerPower = new Raspberry.IO.GeneralPurpose.OutputPinConfiguration (Raspberry.IO.GeneralPurpose.ProcessorPin.Pin17); var RingerOscillator = new Raspberry.IO.GeneralPurpose.OutputPinConfiguration (Raspberry.IO.GeneralPurpose.ProcessorPin.Pin18); var HookSwitch = new Raspberry.IO.GeneralPurpose.InputPinConfiguration (Raspberry.IO.GeneralPurpose.ProcessorPin.Pin22) { Reversed = true }; var DialPulseSwitch = new Raspberry.IO.GeneralPurpose.InputPinConfiguration (Raspberry.IO.GeneralPurpose.ProcessorPin.Pin27); //Start Ringer and DialListener GPIO classes using (var ringer = new clsRinger (RingerPower, RingerOscillator)) { using (var dialListener = new clsDialHookListener(HookSwitch,DialPulseSwitch)) { //Simple bell test function. 0 = UK ring, 1 = USA Ring dialListener.NumberDialed += (uint NumberDialed) => { Console.WriteLine("Number Dialed:{0}",NumberDialed); if (NumberDialed == 0) { ringer.SetRingPattern (clsRinger.ringPattern_UK); ringer.StartRing (); } else if (NumberDialed == 9) { ringer.SetRingPattern (clsRinger.ringPattern_USA); ringer.StartRing (); } }; //Cancel the Ringer dialListener.HookSwitchChange += (bool OnHook, uint Pulse) => { if (!OnHook) ringer.StopRing (); }; UnixSignal[] signals = new UnixSignal [] { new UnixSignal (Mono.Unix.Native.Signum.SIGINT), new UnixSignal (Mono.Unix.Native.Signum.SIGUSR1), }; while (true) { int index = UnixSignal.WaitAny (signals, -1); //Wait for any Unix Signals Mono.Unix.Native.Signum signal = signals [index].Signum; Console.Write("SIGNAL:{0}",signal.ToString()); break; } ; } } Console.WriteLine ("**end**"); }
public override bool WaitOne(int millisecondsTimeout, bool exitContext) { this.AssertValid(); if (exitContext) { throw new InvalidOperationException("exitContext is not supported"); } return(UnixSignal.WaitAny(new UnixSignal[] { this }, millisecondsTimeout) == 0); }
// helper method to create a two-thread test static void MultiThreadTest (UnixSignal signal, int timeout, ThreadStart tstart) { Thread t1 = CreateWaitSignalThread (signal, timeout); Thread t2 = new Thread (tstart); t1.Start (); t2.Start (); t1.Join (); t2.Join (); }
static void WaitForUnixStopSignal() { UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) }; UnixSignal.WaitAny(signals); }
public void TestWaitAnyFailsWithMore64Signals() { UnixSignal s1 = new UnixSignal(Signum.SIGINT); UnixSignal[] signals = new UnixSignal[65]; for (int i=0; i<65; ++i) signals[i] = s1; Assert.That(UnixSignal.WaitAny(signals, new TimeSpan(0,0,1)), Is.EqualTo(-1)); }
public static int Main (string[] args) { using (ServiceHost host = new ServiceHost (typeof (HangmanService))) { var security = new SecurityMode (); host.AddServiceEndpoint ( typeof(IHangmanService), new WSHttpBinding (security, true), "http://localhost:8325/"); host.Open (); /* Console.WriteLine ("Type [CR] to stop ..."); Console.ReadKey (); */ /* Demon */ UnixSignal sigint = new UnixSignal (Signum.SIGINT); UnixSignal sigterm = new UnixSignal (Signum.SIGTERM); UnixSignal sighup = new UnixSignal (Signum.SIGHUP); UnixSignal sigusr2 = new UnixSignal (Signum.SIGUSR2); UnixSignal [] signals = new UnixSignal[] { sigint, sigterm, sighup, sigusr2 }; bool exit = false; while (!exit) { int id = UnixSignal.WaitAny (signals); if (id >= 0 && id < signals.Length) { if (sigint.IsSet || sigterm.IsSet) { sigint.Reset (); sigterm.Reset (); exit = true; } else if (sighup.IsSet) sighup.Reset (); else if (sigusr2.IsSet) sighup.Reset (); } } /* Demon */ host.Close (); } return 0; }
protected override void Dispose(bool disposing) { base.Dispose(disposing); if (this.signal_info == IntPtr.Zero) { return; } UnixSignal.uninstall(this.signal_info); this.signal_info = IntPtr.Zero; }
public static int WaitAny(UnixSignal[] signals, TimeSpan timeout) { long totalMilliseconds = (long)timeout.TotalMilliseconds; if (totalMilliseconds < (long)-1 || totalMilliseconds > (long)2147483647) { throw new ArgumentOutOfRangeException("timeout"); } return(UnixSignal.WaitAny(signals, (int)totalMilliseconds)); }
public static void SignalHandler() { var sig = new UnixSignal( Mono.Unix.Native.Signum.SIGUSR2 ); var sigs = new UnixSignal[] { sig }; do { UnixSignal.WaitAny( sigs, new TimeSpan(0,1,0) ); covertool.SaveData(); } while ( debugee != null && !debugee.HasExited ); }
static void InitSignals() { UnixSignal term = new UnixSignal (Mono.Unix.Native.Signum.SIGTERM); UnixSignal inter = new UnixSignal (Mono.Unix.Native.Signum.SIGINT); GLib.Timeout.Add (500, delegate { if (term.IsSet || inter.IsSet) Application.Quit (); return true; }); }
// helper method to create a thread waiting on a UnixSignal static Thread CreateWaitSignalThread (UnixSignal signal, int timeout) { Thread t1 = new Thread(delegate() { DateTime start = DateTime.Now; bool r = signal.WaitOne (timeout, false); DateTime end = DateTime.Now; Assert.AreEqual (signal.Count, 1); Assert.AreEqual (r, true); if ((end - start) > new TimeSpan (0, 0, timeout/1000)) throw new InvalidOperationException ("Signal slept too long"); }); return t1; }
protected virtual void LinuxHandler() { Log.Notice("Linux", sLConsole.GetString("Initializing Handler for SIGINT, SIGHUP")); var signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGHUP) }; int which = UnixSignal.WaitAny(signals, -1); Log.Debug("Linux", sLConsole.GetString("Got a {0} signal."), signals[which].Signum); Log.Notice("Linux", sLConsole.GetString("Handler Terminated.")); Action(); }
private void LinuxHandler() { Log.Notice("Linux", "Initializing Handler for SIGINT, SIGHUP"); var signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGHUP) }; int which = UnixSignal.WaitAny(signals, -1); Log.Debug("Linux", "Got a {0} signal!", signals[which].Signum); Log.Notice("Linux", "Handler Terminated."); MainClass.Shutdown(); }
public void TestNestedInvocation() { UnixSignal s = new UnixSignal(Signum.SIGINT); Thread a = new Thread(delegate() { bool r = s.WaitOne (1000, false); }); Thread b = new Thread(delegate() { bool r = s.WaitOne (500, false); }); a.Start(); b.Start(); a.Join(); b.Join(); }
public UnixExitSignal() { UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGUSR1), }; Task.Factory.StartNew(() => { int index = UnixSignal.WaitAny(signals, Timeout.Infinite); if (Signaled != null) Signaled(this, EventArgs.Empty); }); }
public UnixSignal(Mono.Unix.Native.RealTimeSignum rtsig) { this.signum = NativeConvert.FromRealTimeSignum(rtsig); this.signal_info = UnixSignal.install(this.signum); Errno lastError = Stdlib.GetLastError(); if (this.signal_info == IntPtr.Zero) { if (lastError != Errno.EADDRINUSE) { throw new ArgumentException("Unable to handle signal", "signum"); } throw new ArgumentException("Signal registered outside of Mono.Posix", "signum"); } }
internal static void Attach(Entry plugin) { if (Tools.RuntimePlatform != OTA.Misc.RuntimePlatform.Microsoft) { try { if (!_attached) { _attached = true; // Catch SIGINT, SIGUSR1 and SIGTERM UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGUSR1), new UnixSignal(Signum.SIGTERM) }; (signal_thread = new Thread(delegate () { System.Threading.Thread.CurrentThread.Name = "SIG"; while (!Terraria.Netplay.disconnect && _attached) { // Wait for a signal to be delivered var index = UnixSignal.WaitAny(signals, -1); var signal = signals[index].Signum; if (!Terraria.Netplay.disconnect && _attached) { _attached = false; OTA.Logging.ProgramLog.Log("Server received Exit Signal"); VanillaCommands.Exit(null, null); } } })).Start(); } OTA.Logging.ProgramLog.Log("Server can accept SIGTERM"); } catch { OTA.Logging.ProgramLog.Log("Failed to attatch SIGTERM listener"); } } }
public void TestConcurrentWaitOne() { UnixSignal s1 = new UnixSignal(Signum.SIGINT); UnixSignal s2 = new UnixSignal(Signum.SIGINT); Thread a = CreateWaitSignalThread(s1, 10000); Thread b = CreateWaitSignalThread(s2, 5000); Thread c = new Thread (delegate () { Thread.Sleep (1000); Stdlib.raise (Signum.SIGINT); }); a.Start(); b.Start(); c.Start(); a.Join(); b.Join(); c.Join(); Assert.That(s1.Count, Is.EqualTo(1), "Expected 1 signal raised"); Assert.That(s2.Count, Is.EqualTo(1), "Expected 1 signal raised"); }
/// <summary> /// Creates instance of program. /// </summary> private Program() { AssemblyName asm = Assembly.GetExecutingAssembly().GetName(); new Gnome.Program(asm.Name, asm.Version.ToString(), Gnome.Modules.UI, new string[0]); Gnome.Global.MasterClient().SaveYourself += this.OnSaveYourself; Gnome.Global.MasterClient().Die += this.OnDie; ThreadPool.QueueUserWorkItem((o) => { UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGINT) }; UnixSignal.WaitAny(signals); Gtk.Application.Invoke((s, args) => { this.OnSaveYourself(this, null); this.OnDie(this, null); }); }); Glippy.Application.Application.Initialize(); }
public static void Main(string[] args) { new AppHost(args.Length == 0).Init().Start("http://*:9832/"); "ServiceStack is listening".Print(); UnixSignal [] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; // Wait for a unix signal for (bool exit = false; !exit; ) { int id = UnixSignal.WaitAny(signals); if (id >= 0 && id < signals.Length) { if (signals[id].IsSet) exit = true; } } }
public static int WaitAny(UnixSignal[] signals, int millisecondsTimeout) { if (signals == null) { throw new ArgumentNullException("signals"); } if (millisecondsTimeout < -1) { throw new ArgumentOutOfRangeException("millisecondsTimeout"); } IntPtr[] signalInfo = new IntPtr[(int)signals.Length]; for (int i = 0; i < (int)signals.Length; i++) { signalInfo[i] = signals[i].signal_info; if (signalInfo[i] == IntPtr.Zero) { throw new InvalidOperationException("Disposed UnixSignal"); } } return(UnixSignal.WaitAny(signalInfo, (int)signalInfo.Length, millisecondsTimeout, () => (!Environment.HasShutdownStarted ? 0 : 1))); }
public SignalWatcher(Context context, Signum[] signals, Action<Signum> callback) { Signals = signals; unixSignals = new UnixSignal[signals.Length]; for (int i = 0; i < signals.Length; i++) { unixSignals[i] = new UnixSignal(signals[i]); } watcher = new AsyncWatcher<Signum>(context, (key) => { if (callback != null) { callback(key); } }); thread = new Thread((o) => { while (true) { var index = UnixSignal.WaitAny(unixSignals); watcher.Send(Signals[index]); } }); }
public static void Main(string[] args) { // Set default and see if Heroku is defining something for us... int port = 8080; var herokuPort = Environment.GetEnvironmentVariable ("PORT"); var mode = "web"; if(!String.IsNullOrEmpty(herokuPort)) { port = Convert.ToInt32 (herokuPort); } if (args.Length > 0) { mode = args [0]; } // bootstrap everything and start hosting... var url = "http://*:{0}/".Fmt(port); Console.WriteLine("Listening on: {0}".Fmt(url)); var appHost = new AppHost(mode); appHost.Init(); appHost.Start(url); UnixSignal[] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; // Wait for a unix signal for (bool exit = false; !exit; ) { int id = UnixSignal.WaitAny(signals); if (id >= 0 && id < signals.Length) { if (signals[id].IsSet) exit = true; } } }
public SignalWatcher(Loop loop, Signum[] signals, Action<Signum> callback) { Signals = signals; unixSignals = new UnixSignal[signals.Length]; for (int i = 0; i < signals.Length; i++) { unixSignals[i] = new UnixSignal((Mono.Unix.Native.Signum)signals[i]); } watcher = new AsyncWatcher<Signum>(loop); watcher.Callback += (key) => { if (callback != null) { callback(key); } }; thread = new Thread((o) => { while (true) { var index = UnixSignal.WaitAny(unixSignals); watcher.Send(Signals[index]); } }); }
public static void Main(string [] args) { if (args.Length == 0) { UnixSignal [] signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; RemotingConfiguration.Configure (ConfigurationFileName, false); ShowVerboseConfigurationInfo(ConfigurationFileName); // Wait for a unix signal to exit for (bool exit = false; !exit; ) { int id = UnixSignal.WaitAny(signals); if (id >= 0 && id < signals.Length) { if (signals[id].IsSet) exit = true; } } } else { ShowUsage(); } }
public static void SetupSignalHandlers (SignalHandler signal_handler) { UnixSignal[] signals = new UnixSignal [] { new UnixSignal (Mono.Unix.Native.Signum.SIGINT), new UnixSignal (Mono.Unix.Native.Signum.SIGTERM), new UnixSignal (Mono.Unix.Native.Signum.SIGUSR1), new UnixSignal (Mono.Unix.Native.Signum.SIGUSR2) }; // Ignore SIGPIPE // FIXME: Shouldn't this be done in every thread ? Mono.Unix.Native.Stdlib.SetSignalAction (Mono.Unix.Native.Signum.SIGPIPE, Mono.Unix.Native.SignalAction.Ignore); // Work around a mono feature/bug // https://bugzilla.novell.com/show_bug.cgi?id=381928 // When beagle crashes, mono will try to print a stack trace and then call abort() // The abort somehow calls back into beagle and causes a deadlock if (Environment.GetEnvironmentVariable ("BEAGLE_MONO_DEBUG_FLAG_IS_SET") == null) Mono.Unix.Native.Stdlib.SetSignalAction (Mono.Unix.Native.Signum.SIGABRT, Mono.Unix.Native.SignalAction.Default); Thread signal_thread = new Thread (delegate () { Log.Debug ("Starting signal handler thread"); int signal_handler_timeout = -1; while (! MainloopFinished) { int index = UnixSignal.WaitAny (signals, signal_handler_timeout); if (index > 3) continue; Mono.Unix.Native.Signum signal = signals [index].Signum; // Set shutdown flag to true so that other threads can stop initializing if (signal == Mono.Unix.Native.Signum.SIGINT || signal == Mono.Unix.Native.Signum.SIGTERM) { ShutdownRequested = true; signal_handler_timeout = 200; // 200 ms } if (signal_handler == null) continue; // Do all signal handling work in the main loop and not in the signal handler. GLib.Idle.Add (new GLib.IdleHandler (delegate () { signal_handler ((int) signal); return false; })); } Log.Debug ("Exiting signal handler thread"); }); signal_thread.Start (); }
public static unsafe int WaitAny (UnixSignal[] signals, int millisecondsTimeout) { if (signals == null) throw new ArgumentNullException ("signals"); if (millisecondsTimeout < -1) throw new ArgumentOutOfRangeException ("millisecondsTimeout"); IntPtr[] infos = new IntPtr [signals.Length]; for (int i = 0; i < signals.Length; ++i) { infos [i] = signals [i].signal_info; if (infos [i] == IntPtr.Zero) throw new InvalidOperationException ("Disposed UnixSignal"); } return WaitAny (infos, infos.Length, millisecondsTimeout, ShuttingDown); }
public static int WaitAny (UnixSignal[] signals, TimeSpan timeout) { long ms = (long) timeout.TotalMilliseconds; if (ms < -1 || ms > Int32.MaxValue) throw new ArgumentOutOfRangeException ("timeout"); return WaitAny (signals, (int) ms); }
public static int WaitAny (UnixSignal[] signals) { return WaitAny (signals, -1); }
public static int Main (string[] args) { // Load the configuration file stored in the // executable's resources. configmanager = new ConfigurationManager ( typeof(MainClass).Assembly, "ConfigurationManager.xml"); configmanager.LoadCommandLineArgs (args); // Show the help and exit. if ((bool)configmanager ["help"] || (bool)configmanager ["?"]) { ShowHelp (); return 0; } // Show the version and exit. if ((bool)configmanager ["version"]) { ShowVersion (); return 0; } string config = (string) configmanager ["config"]; if (config == null) { Console.WriteLine ("You must pass /config=<filename> option. See 'help' for more info"); return 1; } try { string config_file = (string)configmanager ["configfile"]; if (config_file != null) configmanager.LoadXmlConfig (config_file); } catch (ApplicationException e) { Console.WriteLine (e.Message); return 1; } catch (System.Xml.XmlException e) { Console.WriteLine ("Error reading XML configuration: {0}", e.Message); return 1; } try { string log_level = (string) configmanager ["loglevels"]; if (log_level != null) Logger.Level = (LogLevel) Enum.Parse (typeof(LogLevel), log_level); } catch { Console.WriteLine ("Failed to parse log levels."); Console.WriteLine ("Using default levels: {0}", Logger.Level); } // Enable console logging during Main (). Logger.WriteToConsole = true; try { string log_file = (string) configmanager ["logfile"]; if (log_file != null) Logger.Open (log_file); } catch (Exception e) { Logger.Write (LogLevel.Error, "Error opening log file: {0}", e.Message); Logger.Write (LogLevel.Error,"Events will not be logged."); } Logger.Write (LogLevel.Debug, Assembly.GetExecutingAssembly ().GetName ().Name); bool auto_map = false; //(bool) configmanager ["automappaths"]; string applications = (string) configmanager ["applications"]; string app_config_file; string app_config_dir; try { app_config_file = (string) configmanager ["appconfigfile"]; app_config_dir = (string) configmanager ["appconfigdir"]; } catch (ApplicationException e) { Logger.Write (LogLevel.Error, e.Message); return 1; } // server.MaxConnections = (ushort) // configmanager ["maxconns"]; // server.MaxRequests = (ushort) // configmanager ["maxreqs"]; // server.MultiplexConnections = (bool) // configmanager ["multiplex"]; // Logger.Write (LogLevel.Debug, "Max connections: {0}", // server.MaxConnections); // Logger.Write (LogLevel.Debug, "Max requests: {0}", // server.MaxRequests); // Logger.Write (LogLevel.Debug, "Multiplex connections: {0}", // server.MultiplexConnections); bool stopable = (bool)configmanager ["stopable"]; Logger.WriteToConsole = (bool)configmanager ["printlog"]; List<ConfigInfo> serverConfigs = ConfigUtils.GetConfigsFromFile (config, "server", typeof(AppServerConfig)); if (serverConfigs.Count != 1) { if (serverConfigs.Count == 0) { Console.WriteLine ("Could not find <server> node in file '{0}'", config); } else { Console.WriteLine ("Only one server is supported currently. Please remove redudant <server> node from file '{0}'", config); } return 1; } IApplicationServer srv = (IApplicationServer)Activator.CreateInstance (serverConfigs [0].Type); srv.Configure (serverConfigs [0].Config); List<ConfigInfo> listenerConfigs = ConfigUtils.GetConfigsFromFile (config, "listener", typeof(ListenerConfig)); if (listenerConfigs.Count != 1) { if (listenerConfigs.Count == 0) { Console.WriteLine ("Could not find <listener> node in file '{0}'", config); } else { Console.WriteLine ("Only one listener is supported currently. Please remove redudant <listener> node from file '{0}'", config); } return 1; } List<ConfigInfo> hostConfigs = ConfigUtils.GetConfigsFromFile (config, "apphost", typeof(AppHostConfig)); if (hostConfigs.Count == 0) { Console.WriteLine ("Can't find <apphost> node in file '{0}'", config); return 1; } IWebListener listener = (IWebListener)Activator.CreateInstance(listenerConfigs[0].Type); listener.Configure (listenerConfigs[0].Config, srv, listenerConfigs[0].ListenerTransport != null? listenerConfigs[0].ListenerTransport.Type: null, listenerConfigs[0].ListenerTransport != null? listenerConfigs[0].ListenerTransport.Config: null, listenerConfigs[0].AppHostTransport != null? listenerConfigs[0].AppHostTransport.Type: null, listenerConfigs[0].AppHostTransport != null? listenerConfigs[0].AppHostTransport.Config: null ); //read web applications. It must be done after server creation //because server can change the root path to web apps List<WebAppConfig> webapps = new List<WebAppConfig> (); if (config != null) { webapps.AddRange (ConfigUtils.GetApplicationsFromConfigFile (config)); } if (applications != null) { webapps.AddRange (ConfigUtils.GetApplicationsFromCommandLine (applications)); } if (app_config_file != null) { webapps.AddRange (ConfigUtils.GetApplicationsFromConfigFile (app_config_file)); } if (app_config_dir != null) { webapps.AddRange (ConfigUtils.GetApplicationsFromConfigDirectory (app_config_dir)); } if (webapps.Count==0 && !auto_map) { Logger.Write (LogLevel.Error, "There are no applications defined, and path mapping is disabled."); Logger.Write (LogLevel.Error, "Define an application using /applications, /appconfigfile, /appconfigdir"); /* Logger.Write (LogLevel.Error, "or by enabling application mapping with /automappaths=True."); */ return 1; } foreach (WebAppConfig appConfig in webapps) { srv.CreateApplicationHost ( hostConfigs[0].Type, hostConfigs[0].Config, appConfig, listener.Transport, listener.AppHostTransportType, listenerConfigs[0].AppHostTransport != null ? listenerConfigs[0].AppHostTransport.Config: null); } if (listener.Listen () != 0) { Logger.Write (LogLevel.Error, "Could not start server"); return 1; } configmanager = null; if (stopable) { Console.WriteLine ("Hit Return to stop the server."); Console.ReadLine (); } else { UnixSignal[] signals = new UnixSignal[] { new UnixSignal (Signum.SIGINT), new UnixSignal (Signum.SIGTERM), }; // Wait for a unix signal for (bool exit = false; !exit;) { int id = UnixSignal.WaitAny (signals); if (id >= 0 && id < signals.Length) { if (signals [id].IsSet) exit = true; } } } listener.Shutdown (); return 0; }
public void TestConcurrentWaitOneSameInstance() { UnixSignal s1 = new UnixSignal(Signum.SIGINT); Thread a = CreateWaitSignalThread(s1, 10000); Thread b = CreateWaitSignalThread(s1, 10000); Thread c = new Thread (delegate () { Thread.Sleep (500); Stdlib.raise (Signum.SIGINT); }); a.Start(); b.Start(); c.Start(); a.Join(); b.Join(); c.Join(); }
/// <summary> /// Shutdown handler for UNIX systems, terminates WaveBox gracefully. /// </summary> private void ShutdownUnix() { // When on UNIX platform, register the following signals: // SIGINT -> Ctrl+C // SIGTERM -> kill or killall UnixSignal[] unixSignals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; // Block until one of the aforementioned signals is issued, then continue shutdown UnixSignal.WaitAny(unixSignals, -1); // Trigger common shutdown function once unblocked this.OnStop(); }
public static void SetupSignalHandlers(SignalHandler signalHandler) { UnixSignal[] signals = new UnixSignal[] { new UnixSignal (Mono.Unix.Native.Signum.SIGINT), new UnixSignal (Mono.Unix.Native.Signum.SIGTERM), new UnixSignal (Mono.Unix.Native.Signum.SIGHUP), }; // Ignore SIGPIPE Mono.Unix.Native.Stdlib.SetSignalAction(Mono.Unix.Native.Signum.SIGPIPE, Mono.Unix.Native.SignalAction.Ignore); var signalThread = new Thread(delegate() { var signalHandlerTimeout = -1; while (!_shutdownRequested) { var index = UnixSignal.WaitAny(signals, -1); if (index > 2) continue; if (signalHandler == null) continue; _shutdownRequested = true; signalHandler(); } }); signalThread.Start(); }
public static int WaitAny(UnixSignal[] signals) { return(UnixSignal.WaitAny(signals, -1)); }