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));
}
