/// <summary> /// Creates a task that will complete when it receives a SIGINT, SIGTERM or SIGHUP signal. /// </summary> /// <returns></returns> private static Task WaitForUnixKillSignal() { var sigIntHandle = new UnixSignal(Signum.SIGINT); var sigTermHandle = new UnixSignal(Signum.SIGTERM); var sigHupHandle = new UnixSignal(Signum.SIGHUP); return(Task.Factory.StartNew(() => { int signal = UnixSignal.WaitAny(new[] { sigIntHandle, sigTermHandle, sigHupHandle }); if (signal == 0) { Log("Received kill signal (SIGINT)"); } else if (signal == 1) { Log("Received kill signal (SIGTERM)"); } else if (signal == 2) { Log("Received kill signal (SIGHUP)"); } else { Log("Received kill signal (unknown)"); } }, TaskCreationOptions.LongRunning)); }
static void InitSignalHandlers() { if ((Environment.OSVersion.Platform == PlatformID.Unix) || (Environment.OSVersion.Platform == PlatformID.MacOSX)) { // Register shutdown handlers #if LOG4NET _Logger.Info("Registering signal handlers"); #endif UnixSignal[] shutdown_signals = { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), }; Thread signal_thread = new Thread(() => { var index = UnixSignal.WaitAny(shutdown_signals); #if LOG4NET _Logger.Info("Caught signal " + shutdown_signals[index].Signum.ToString() + ", shutting down"); #endif Gtk.Application.Invoke(delegate { Quit(); }); }); signal_thread.IsBackground = true; signal_thread.Start(); } }
public void TestRaise() { Thread t1 = new Thread(delegate() { using (UnixSignal a = new UnixSignal(Signum.SIGINT)) { DateTime start = DateTime.Now; bool r = a.WaitOne(5000, false); DateTime end = DateTime.Now; Assert.AreEqual(a.Count, 1); Assert.AreEqual(r, true); if ((end - start) > new TimeSpan(0, 0, 5)) { throw new InvalidOperationException("Signal slept too long"); } } }); Thread t2 = new Thread(delegate() { Thread.Sleep(1000); Stdlib.raise(Signum.SIGINT); }); t1.Start(); t2.Start(); t1.Join(); t2.Join(); }
public void TestNoEmitAny() { using (UnixSignal u = new UnixSignal(Signum.SIGINT)) { int idx = UnixSignal.WaitAny(new UnixSignal[] { u }, 5100); Assert.AreEqual(idx, 5100); } }
private static void Main(string[] args) { var uri = "http://localhost:8900"; StaticConfiguration.DisableErrorTraces = false; using (var host = new NancyHost(new HostConfiguration { UrlReservations = new UrlReservations { CreateAutomatically = true } }, new Uri(uri))) { host.Start(); if (Type.GetType("Mono.Runtime") != null) { UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { Console.WriteLine(string.Format("I'm a runnin' on {0}", uri)); Console.ReadKey(); } host.Stop(); } }
public static void Main(string[] args) { BasicConfigurator.Configure(); var now = DateTime.UtcNow; var uri = "http://localhost:8888"; Log.Info(log, "Starting MyRouter on " + uri, DateTime.UtcNow); // initialize an instance of NancyHost var host = new NancyHost(new Uri(uri)); host.Start(); // start hosting // check if we're running on mono if (Type.GetType("Mono.Runtime") != null) { // on mono, processes will usually run as daemons - this allows you to listen // for termination signals (ctrl+c, shutdown, etc) and finalize correctly UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { System.Console.ReadLine(); } Log.Info(log, "Stopping Nancy", DateTime.UtcNow); host.Stop(); // stop hosting }
public static void Main() { AppConfig.Init(); using (var host = new NancyHost(new Uri(AppConfig.HostUri), new Bootstrapper(), new HostConfiguration { UrlReservations = new UrlReservations { CreateAutomatically = true } })) { host.Start(); Log.Write("Server started at " + AppConfig.HostUri); if (Type.GetType("Mono.Runtime") != null) { UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { while (Console.ReadKey().Key != ConsoleKey.Escape) { } } host.Stop(); } }
static void Main(string[] args) { #if DEBUG const string url = "http://+:8899"; #else const string url = "http://+:8888"; #endif Console.WriteLine($"Starting Nancy on {url} @ {DateTime.Now}"); using (WebApp.Start <Startup>(url)) { if (IsRunningOnMono()) { var terminationSignals = GetUnixTerminationSignals(); UnixSignal.WaitAny(terminationSignals); } else { Console.ReadLine(); } } Console.WriteLine($"Stopped Nancy on {url} @ {DateTime.Now}"); }
public void TestRaiseRTMINPlusOneSignal() { if (!TestHelper.CanUseRealTimeSignals()) { return; } /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum(i); UnixSignal signal; try { signal = new UnixSignal(rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } using (signal) { MultiThreadTest(signal, 5000, delegate() { Thread.Sleep(1000); Stdlib.raise(rts); }); } return; } Assert.IsTrue(false, "#1 No available RT signal"); }
public void TestCanRegisterRTSignalMultipleTimes() { if (!TestHelper.CanUseRealTimeSignals()) { return; } /*this number is a guestimate, but it's ok*/ for (int i = 1; i < 10; ++i) { RealTimeSignum rts = new RealTimeSignum(i); UnixSignal signal; try { signal = new UnixSignal(rts); } catch (ArgumentException) { /*skip the ones that are unavailable*/ continue; } try { using (UnixSignal signal2 = new UnixSignal(rts)) { //ok return; } } catch (ArgumentException) { /*skip the ones that are unavailable*/ Assert.IsTrue(false, "#1 Could not register second signal handler"); } } Assert.IsTrue(false, "#2 No available RT signal"); }
private void HandleSignals() { const int timeoutMs = 1000; while (!_stop) { UnixSignal[] handledSignals; lock (_handledSignalsLock) { handledSignals = _handledSignals.ToArray(); } var index = UnixSignal.WaitAny(handledSignals, TimeSpan.FromMilliseconds(timeoutMs)); if (index == timeoutMs) { continue; } if (_actions.TryGetValue(handledSignals[index].Signum, out List <Action> actions)) { foreach (var action in actions) { action.Invoke(); } } handledSignals[index].Reset(); } }
static void Main(string[] args) { var uri = "http://localhost:8888"; Logger.Info("Starting server on {0}", uri); var host = new NancyHost(new Uri(uri)); host.Start(); if (Type.GetType("Mono.Runtime") != null) { UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { Console.ReadLine(); } Logger.Info("Stopping server..."); host.Stop(); NLog.LogManager.Shutdown(); }
public void TestSeparation() { Thread t1 = new Thread(delegate() { using (UnixSignal a = new UnixSignal(Signum.SIGINT)) using (UnixSignal b = new UnixSignal(Signum.SIGTERM)) { var sw = Stopwatch.StartNew(); int idx = UnixSignal.WaitAny(new UnixSignal[] { a, b }, 5000); sw.Stop(); Assert.AreEqual(idx, 1); Assert.AreEqual(a.Count, 0); Assert.AreEqual(b.Count, 1); if (sw.Elapsed > new TimeSpan(0, 0, 5)) { throw new InvalidOperationException("Signal slept too long"); } } }); Thread t2 = new Thread(delegate() { Thread.Sleep(1000); Stdlib.raise(Signum.SIGTERM); }); t1.Start(); t2.Start(); t1.Join(); t2.Join(); }
public void TestRaise() { Thread t1 = new Thread(delegate() { using (UnixSignal a = new UnixSignal(Signum.SIGINT)) { var sw = Stopwatch.StartNew(); bool r = a.WaitOne(5000, false); sw.Stop(); Assert.AreEqual(a.Count, 1); Assert.AreEqual(r, true); if (sw.Elapsed > new TimeSpan(0, 0, 5)) { throw new InvalidOperationException("Signal slept too long"); } } }); Thread t2 = new Thread(delegate() { Thread.Sleep(1000); Stdlib.raise(Signum.SIGINT); }); t1.Start(); t2.Start(); t1.Join(); t2.Join(); }
static void Main() { ServiceStartup.Run(); UnixSignal[] signals = { 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; } } } ServiceStartup.Stop(); }
static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .WriteTo.Console(new RenderedCompactJsonFormatter()) .Enrich.FromLogContext() .CreateLogger(); // See https://support.microsoft.com/en-gb/help/821268/contention-poor-performance-and-deadlocks-when-you-make-calls-to-web-s ThreadPool.SetMaxThreads(100, 100); ThreadPool.SetMinThreads(50, 50); Parser.Default.ParseArguments <DeploymentPoolArgs>(args) .WithParsed(parsedArgs => { parsedArgs.Validate(); var spatialRefreshToken = Environment.GetEnvironmentVariable(SpatialRefreshTokenEnvironmentVariable) ?? throw new Exception( $"{SpatialRefreshTokenEnvironmentVariable} environment variable is required."); if (spatialRefreshToken == "") { throw new ArgumentException("Refresh token should not be empty"); } IAnalyticsSender analyticsSender = new AnalyticsSenderBuilder("deployment_pool") .WithCommandLineArgs(parsedArgs) .With(new LogExceptionStrategy(Log.Logger)) .Build(); var spatialDeploymentClient = DeploymentServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken)); var spatialSnapshotClient = SnapshotServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken)); var platformInvoker = new PlatformInvoker(parsedArgs, spatialDeploymentClient, spatialSnapshotClient, analyticsSender); var cancelTokenSource = new CancellationTokenSource(); var cancelToken = cancelTokenSource.Token; var metricsServer = new MetricServer(parsedArgs.MetricsPort).Start(); var dplPool = new DeploymentPool(parsedArgs, spatialDeploymentClient, platformInvoker, cancelToken, analyticsSender); var dplPoolTask = Task.Run(() => dplPool.Start()); var unixSignalTask = Task.Run(() => UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) })); Task.WaitAny(dplPoolTask, unixSignalTask); if (unixSignalTask.IsCompleted) { Log.Information($"Received UNIX signal {unixSignalTask.Result}"); Log.Information("Server shutting down..."); cancelTokenSource.Cancel(); metricsServer.StopAsync(); dplPoolTask.Wait(); Log.Information("Server stopped cleanly"); } else { /* The server task has completed; we can just exit. */ Log.Information($"The deployment pool has stopped itself or encountered an unhandled exception {dplPoolTask.Exception}"); } }); }
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(); } }
static void Main(string[] args) { var matcher = new Matcher(); var matcherTask = new Task(() => { matcher.Start(); }); var unixSignalTask = new Task <int>(() => { return(UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) })); }); matcherTask.Start(); Console.WriteLine("Matcher started up"); unixSignalTask.Start(); Task.WaitAny(matcherTask, unixSignalTask); if (unixSignalTask.IsCompleted) { Console.WriteLine($"Received UNIX signal {unixSignalTask.Result}"); Console.WriteLine("Matcher shutting down..."); matcher.Stop(); matcherTask.Wait(TimeSpan.FromSeconds(10)); Console.WriteLine("Matcher stopped cleanly"); } else { /* The matcher task has completed; we can just exit. */ Console.WriteLine("The matcher has stopped itself or encountered an unhandled exception."); } Environment.Exit(0); }
public static void Main(string[] args) { // See https://support.microsoft.com/en-gb/help/821268/contention-poor-performance-and-deadlocks-when-you-make-calls-to-web-s // Experimentation shows we need the ThreadPool to always spin up threads for good performance under load ThreadPool.GetMaxThreads(out var workerThreads, out var ioThreads); ThreadPool.SetMinThreads(workerThreads, ioThreads); Parser.Default.ParseArguments <PartyServerCommandLineArgs>(args) .WithParsed(parsedArgs => { parsedArgs.Validate(); var spatialRefreshToken = Secrets.GetEnvSecret(SpatialRefreshTokenEnvironmentVariable); PartyDataModel.Defaults.MinMembers = (uint)parsedArgs.DefaultMinMembers; PartyDataModel.Defaults.MaxMembers = (uint)parsedArgs.DefaultMaxMembers; Log.Logger = new LoggerConfiguration() .WriteTo.Console(new RenderedCompactJsonFormatter()) .Enrich.FromLogContext() .CreateLogger(); using (var server = GrpcBaseServer.Build(parsedArgs)) using (var memoryStoreManager = new RedisClientManager(parsedArgs.RedisConnectionString)) { Log.Information($"Successfully connected to Redis at {parsedArgs.RedisConnectionString}"); server.AddInterceptor(new PlayerIdentityTokenValidatingInterceptor( PlayerAuthServiceClient.Create(credentials: new PlatformRefreshTokenCredential(spatialRefreshToken)), memoryStoreManager.GetRawClient(Database.CACHE) )) .AddInterceptor(new ExceptionMappingInterceptor(new Dictionary <Type, StatusCode> { { typeof(EntryNotFoundException), StatusCode.NotFound }, { typeof(EntryAlreadyExistsException), StatusCode.AlreadyExists }, { typeof(TransactionAbortedException), StatusCode.Unavailable } })); server.AddService( PartyService.BindService(new PartyServiceImpl(memoryStoreManager))); server.AddService( InviteService.BindService(new InviteServiceImpl(memoryStoreManager))); var serverTask = Task.Run(() => server.Start()); var signalTask = Task.Run(() => UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) })); Task.WaitAny(serverTask, signalTask); if (signalTask.IsCompleted) { Log.Information($"Received UNIX signal {signalTask.Result}"); Log.Information("Server shutting down..."); server.Shutdown(); serverTask.Wait(); Log.Information("Server stopped cleanly"); } else { /* The server task has completed; we can just exit. */ Log.Information("The Party server has stopped itself or encountered an unhandled exception."); } } }); }
private static void SigTermHandler() { Console.WriteLine("(initializing SIGTERM handler)"); UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGTERM) }); TaskTimerFactory.ShutdownAll(); _host.Dispose(); }
static void Main(string[] args) { GamePlatform.Init(); if (GamePlatform.Startup()) { Console.WriteLine("Press any [Enter] to close the host."); // check if we're running on mono if (Utility.CheckIfRunningOnMono()) { // on mono, processes will usually run as daemons - this allows you to listen // for termination signals (ctrl+c, shutdown, etc) and finalize correctly UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { Console.ReadLine(); } } //AirFrog.LoggerMan.LogErr("Stopping AirFrog by hand or system signal."); GamePlatform.Stop(); }
public void TestRealTimeSignumProperty() { RealTimeSignum rts = new RealTimeSignum(0); UnixSignal signal1 = new UnixSignal(rts); Assert.That(signal1.RealTimeSignum, Is.EqualTo(rts)); }
public static void Run(Uri endpointUri, Type[] serviceTypes) { if (serviceTypes == null) { throw new ArgumentNullException(nameof(serviceTypes)); } using (var servicehost = new ServiceHost()) { servicehost.Start(endpointUri, serviceTypes); Console.WriteLine("Service host running on {0}...", endpointUri.ToString()); if (Is_running_on_Mono) { Console.WriteLine("Ctrl-C to stop service host"); UnixSignal.WaitAny(UnixTerminationSignals); } else { Console.WriteLine("ENTER to stop service host"); Console.ReadLine(); } Console.WriteLine("Stopping service host"); servicehost.Stop(); } }
public void TestSeparation() { Thread t1 = new Thread(delegate() { using (UnixSignal a = new UnixSignal(Signum.SIGINT)) using (UnixSignal b = new UnixSignal(Signum.SIGTERM)) { DateTime start = DateTime.Now; int idx = UnixSignal.WaitAny(new UnixSignal[] { a, b }, 5000); DateTime end = DateTime.Now; Assert.AreEqual(idx, 1); Assert.AreEqual(a.Count, 0); Assert.AreEqual(b.Count, 1); if ((end - start) > new TimeSpan(0, 0, 5)) { throw new InvalidOperationException("Signal slept too long"); } } }); Thread t2 = new Thread(delegate() { Thread.Sleep(1000); Stdlib.raise(Signum.SIGTERM); }); t1.Start(); t2.Start(); t1.Join(); t2.Join(); }
/// <summary> /// Set a handler for SIGINT, so they system can exit gracefully. /// </summary> public static void setSignalHandler <MeasurerT, PoseT, MeasurementT>( Manipulator <MeasurerT, PoseT, MeasurementT> manipulator) where PoseT : IPose <PoseT>, new() where MeasurementT : IMeasurement <MeasurementT>, new() where MeasurerT : IMeasurer <MeasurerT, PoseT, MeasurementT>, new() { UnixSignal sigint = new UnixSignal(Mono.Unix.Native.Signum.SIGINT); signalthread = new Thread(() => { while (true) { sigint.WaitOne(); if (manipulator != null && !manipulator.Abort) { manipulator.Abort = true; } else { Environment.Exit(1); } } }); signalthread.Start(); }
static Thread CreateWaitAnyThread(params UnixSignal[] usignals) { return(new Thread(delegate() { int idx = UnixSignal.WaitAny(usignals, 30000); Assert.AreEqual(idx >= 0 && idx < usignals.Length, true); })); }
private static void HookUnixCancelSignals() { // SetConsoleCtrlHandler not exposed on mono // Seems like a bit of a complex topic http://mono.1490590.n4.nabble.com/Control-C-handler-td1532196.html // Some hope http://stackoverflow.com/questions/6546509/detect-when-console-application-is-closing-killed // http://www.mono-project.com/docs/faq/technical/#operating-system-questions // Need to conditionally reference Mono.Posix for all this to work // https://github.com/ninjarobot/MonoConditionalReference // Catch SIGINT and SIGUSR1 UnixSignal[] signals = new UnixSignal [] { new UnixSignal (Signum.SIGINT), new UnixSignal (Signum.SIGUSR1), }; var token = new ProcessCancellationToken(); var signal_thread = new Thread(() => { while (true) { // Wait for a signal to be delivered int index = UnixSignal.WaitAny(signals, -1); var signal = signals[index].Signum; // Notify the main thread that a signal was received CancelRequested = true; } }); }
static void Main(string[] args) { var uri = "http://localhost:8888"; Logger.Info("Starting Nancy on " + uri); // initialize an instance of NancyHost var host = new NancyHost(new Uri(uri)); host.Start(); // check if we're running on mono if (Type.GetType("Mono.Runtime") != null) { // on mono, processes will usually run as daemons - this allows you to listen // for termination signals (ctrl+c, shutdown, etc) and finalize correctly UnixSignal.WaitAny(new[] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM), new UnixSignal(Signum.SIGQUIT), new UnixSignal(Signum.SIGHUP) }); } else { Console.ReadLine(); } Logger.Info("Stopping Nancy"); host.Stop(); }
private void StartShutdownSignalHandlerThread() { if (_ShutdownSignalHandlerThread == null) { _ShutdownSignalHandlerThread = new Thread(() => { try { var signals = new UnixSignal[] { new UnixSignal(Signum.SIGINT), }; while (true) { if (UnixSignal.WaitAny(signals, -1) != -1) { ProgramLifetime.MainView?.CloseView(); } } } catch (ThreadAbortException) { ; // these get rethrown automatically, I just don't want them logged } catch (Exception ex) { try { var log = Factory.ResolveSingleton <ILog>(); log.WriteLine("Caught exception in shutdown signal handler: {0}", ex); } catch { // Don't let exceptions bubble out of a background thread } } }); _ShutdownSignalHandlerThread.Start(); } }
public static int Main(string[] args) { var server = WebApp.Start($"http://+:5000", appBuilder => { appBuilder.Run(ctx => { ctx.Response.StatusCode = 200; return(ctx.Response.WriteAsync("<h1>٩(。•́‿•̀。)۶</h1>")); }); }); Console.WriteLine("Listening http://0.0.0.0:5000/"); Console.WriteLine("Press Ctrl+C, send INT or TERM signal to stop."); Console.Error.WriteLine("Hello from STDERR."); UnixSignal.WaitAny(new [] { new UnixSignal(Signum.SIGINT), new UnixSignal(Signum.SIGTERM) }, -1); Console.WriteLine("Stopping..."); server.Dispose(); return(0); }
static void Main(string[] args) { var strPort = Environment.GetEnvironmentVariable("PORT") ?? "8080"; var strUrl = string.Format("http://*:{0}", strPort); var options = new StartOptions(); options.Urls.Add(strUrl); using (WebApp.Start(options, builder => { ServiceContext.Instance.HangfireContext.Initialize(builder); builder.UseNancy(); })) { Console.WriteLine("Started Nancy on {0}...", strUrl); if (IsRunningOnMono()) { var terminationSignals = GetUnixTerminationSignals(); UnixSignal.WaitAny(terminationSignals); } else { Console.ReadKey(); } } }