static Stdlib()
{
Stdlib._SIG_DFL = Stdlib.GetDefaultSignal();
Stdlib._SIG_ERR = Stdlib.GetErrorSignal();
Stdlib._SIG_IGN = Stdlib.GetIgnoreSignal();
Stdlib.SIG_DFL = new SignalHandler(Stdlib._DefaultHandler);
Stdlib.SIG_ERR = new SignalHandler(Stdlib._ErrorHandler);
Stdlib.SIG_IGN = new SignalHandler(Stdlib._IgnoreHandler);
Stdlib._IOFBF = Stdlib.GetFullyBuffered();
Stdlib._IOLBF = Stdlib.GetLineBuffered();
Stdlib._IONBF = Stdlib.GetNonBuffered();
Stdlib.BUFSIZ = Stdlib.GetBufferSize();
Stdlib.EOF = Stdlib.GetEOF();
Stdlib.FOPEN_MAX = Stdlib.GetFopenMax();
Stdlib.FILENAME_MAX = Stdlib.GetFilenameMax();
Stdlib.L_tmpnam = Stdlib.GetTmpnamLength();
Stdlib.stderr = Stdlib.GetStandardError();
Stdlib.stdin = Stdlib.GetStandardInput();
Stdlib.stdout = Stdlib.GetStandardOutput();
Stdlib.TMP_MAX = Stdlib.GetTmpMax();
Stdlib.tmpnam_lock = new object();
Stdlib.EXIT_FAILURE = Stdlib.GetExitFailure();
Stdlib.EXIT_SUCCESS = Stdlib.GetExitSuccess();
Stdlib.MB_CUR_MAX = Stdlib.GetMbCurMax();
Stdlib.RAND_MAX = Stdlib.GetRandMax();
Stdlib.strerror_lock = new object();
Array values = Enum.GetValues(typeof(Signum));
Stdlib.registered_signals = new SignalHandler[(int)values.GetValue(values.Length - 1)];
}
public IAsyncDisposable RegisterSignalHandler(
ObjectPath path,
string interfaceName,
string member,
SignalHandler handler
)
{
var dictionaryEntry = path + "\0" + interfaceName + "\0" + member;
var newHandler = signalHandlers.AddOrUpdate(
dictionaryEntry,
handler,
(_, existingHandler) => existingHandler + handler
);
var match = $"type='signal',interface='{interfaceName}',member={member},path='{path}'";
var addMatchTask = Task.CompletedTask;
if (newHandler == handler)
{
// AddOrUpdate added a new key
addMatchTask = orgFreedesktopDbus.AddMatchAsync(match, default);
}
return(new signalHandle(
this,
dictionaryEntry,
match,
addMatchTask,
handler
));
}
static void Main()
{
bool onlyInstance;
Mutex mtx = new Mutex(true, "ConsoleHost", out onlyInstance);
if (!onlyInstance)
{
Console.WriteLine(@"Служба уже запущена! Нажмите любую клавишу...");
Console.ReadLine();
return;
}
_signalHandler += HandleConsoleSignal;
ConsoleHelper.SetSignalHandler(_signalHandler, true);
InitializeNotifyIcon();
LogText("Это серверная консоль слежения за Импортом ");
var myServiceHost = new ServiceHost(typeof(ImpStatusService));
myServiceHost.Open();
foreach (Uri address in myServiceHost.BaseAddresses)
{
LogText("Работает сервис " + address);
}
Console.WriteLine();
Console.WriteLine(@"Лог работы:");
Application.Run();
myServiceHost.Close();
}
public void Signal()
{
SignalTest st = new SignalTest();
// Insert handler
SignalHandler oh = Stdlib.signal(Signum.SIGURG,
new SignalHandler(st.Handler));
st.signalReceived = ~NativeConvert.FromSignum(Signum.SIGURG);
// Send signal
Stdlib.raise(Signum.SIGURG);
Assert.IsTrue(
NativeConvert.ToSignum(st.signalReceived) == Signum.SIGURG,
"#IH: Signal handler not invoked for SIGURG");
// Reset old signal
Stdlib.signal(Signum.SIGURG, oh);
st.signalReceived = NativeConvert.FromSignum(Signum.SIGUSR1);
Stdlib.raise(Signum.SIGURG);
Assert.IsFalse(NativeConvert.ToSignum(st.signalReceived) == Signum.SIGURG,
"#IH: Signal Handler invoked when it should have been removed!");
}
private void OnCarSensorBthMessageReceived(CarSensorBthMessage message)
{
var lineslst = new List <string>();
var line = message.Sensor;
if (!string.IsNullOrEmpty(line) && line.Length >= 10)
{
lineslst.Add(line);
}
var cmd = line.GetCommand();
if (cmd != null && cmd.Equals(SensorCommand, StringComparison.OrdinalIgnoreCase))
{
return;
}
var lines = lineslst.ToArray().SelectMany(SpiltCommand).ToArray();
if (lines.Length > 2)
{
var carSignalInfo = SensorParser.Parse(lines);
SignalHandler.Execute(carSignalInfo);
if (Settings.AngleSource == AngleSource.Gyroscope)
{
carSignalInfo.BearingAngle = carSignalInfo.AngleZ + 180;
}
OnCarSignalRecevied(carSignalInfo);
}
}
public GreaterThen(SignalHandler signal, double compareValue, AlgerbraOperator nextOperator)
: base(signal, nextOperator)
{
this._compareValue = compareValue;
this._triggerInputs = TriggerInput.OnlyValue;
base.SignalHandlersUsedByTrigger.Add(signal);
}
public void StartCore()
{
try
{
while (true)
{
var rawItems = ReadCommands().ToArray();
if (rawItems.Length == 0)
{
continue;
}
var lines = rawItems.SelectMany(SpiltCommand).ToArray();
if (lines.Length > 2)
{
var carSignalInfo = SensorParser.Parse(lines);
SignalHandler.Execute(carSignalInfo);
if (Settings.AngleSource == AngleSource.Gyroscope)
{
carSignalInfo.BearingAngle = carSignalInfo.AngleZ + 180;
}
OnCarSignalRecevied(carSignalInfo);
LogCommands(rawItems);
}
}
}
catch (Exception exp)
{
Logger.Error("BluetoothStartCore", exp.Message);
}
}
private void ReadSignal(object state)
{
if (_isRunning)
{
return;
}
_isRunning = true;
try
{
//重新设置到最开始
if (SignalReader.BaseStream.Position == SignalReader.BaseStream.Length)
{
SignalReader.BaseStream.Seek(0, SeekOrigin.Begin);
}
var line = SignalReader.ReadLine();
var carSingal = line.FromJson <CarSignalInfo>();
carSingal.RecordTime = carSingal.Gps.UtcTime = carSingal.Gps.LocalTime = carSingal.Gps.RecordTime = carSingal.Sensor.RecordTime = DateTime.Now;
if (carSingal != null)
{
//处理信号
SignalHandler.Execute(carSingal);
OnCarSignalRecevied(carSingal);
}
}
catch (Exception ex)
{
Logger.ErrorFormat("读取车载传感器发生异常：{0}", ex.StackTrace, ex);
}
finally
{
_isRunning = false;
}
}
public static SignalHandler signal(Signum signum, SignalHandler handler)
{
int _sig = NativeConvert.FromSignum(signum);
Delegate[] handlers = handler.GetInvocationList();
for (int i = 0; i < handlers.Length; ++i)
{
Marshal.Prelink(handlers [i].Method);
}
IntPtr r;
if (handler == SIG_DFL)
{
r = sys_signal(_sig, _SIG_DFL);
}
else if (handler == SIG_ERR)
{
r = sys_signal(_sig, _SIG_ERR);
}
else if (handler == SIG_IGN)
{
r = sys_signal(_sig, _SIG_IGN);
}
else
{
r = sys_signal(_sig, handler);
}
return(TranslateHandler(r));
}
internal protected async Task <IDisposable> WatchVoidSignalAsync(string iface, string member, Action <Exception> error, Action action)
{
var synchronizationContext = _connection.CaptureSynchronizationContext();
var wrappedDisposable = new WrappedDisposable(synchronizationContext);
SignalHandler handler = (msg, ex) =>
{
if (ex != null)
{
if (error == null)
{
return;
}
wrappedDisposable.Call(error, ex, disposes: true);
return;
}
if (!SenderMatches(msg))
{
return;
}
wrappedDisposable.Call(action);
};
wrappedDisposable.Disposable = await _connection.WatchSignalAsync(ObjectPath, iface, member, handler);
return(wrappedDisposable);
}
private void HandleSignal(Message msg)
{
var sender = msg.Header.Sender ?? string.Empty;
var rule = new SignalMatchRule(@interface: msg.Header.Interface,
member: msg.Header.Member,
path: msg.Header.Path.Value,
sender: sender);
SignalHandler signalHandler = null;
lock (_gate)
{
if (_signalHandlers.TryGetValue(rule, out SignalHandler handler))
{
signalHandler = handler;
}
}
if (signalHandler != null)
{
try
{
signalHandler(msg);
}
catch (Exception e)
{
throw new InvalidOperationException("Signal handler for " + msg.Header.Interface + "." + msg.Header.Member + " threw an exception", e);
}
}
}
public WaitForSignal(SignalManager.Container container, Predicate <T> predicate)
{
Assert.NotNull(container, nameof(container));
handler = container.OnSignal <T>(Callback);
this.predicate = predicate;
}
public GreaterThen(SignalHandler signal, double compareValue, AlgerbraOperator nextOperator)
: base(signal, nextOperator)
{
this._compareValue = compareValue;
this._triggerInputs = TriggerInput.OnlyValue;
base.SignalHandlersUsedByTrigger.Add(signal);
}
public void StartCore(object a)
{
try
{
var rawItems = ReadCommands().ToArray();
if (rawItems.Count() == 0)
{
return;
}
var lines = rawItems.SelectMany(SpiltCommand).ToArray();
if (lines.Length > 2)
{
var carSignalInfo = SensorParser.Parse(lines);
SignalHandler.Execute(carSignalInfo);
//TOOD:由于模拟Gps数据没有数据,所以给一个默认20的速度！
carSignalInfo.Sensor.SpeedInKmh = 20;
carSignalInfo.SpeedInKmh = 20;
carSignalInfo.BearingAngle = carSignalInfo.AngleZ + 180;
OnCarSignalRecevied(carSignalInfo);
}
if (lines.Length <= 2)
{
}
}
catch (Exception exp)
{
string ex = exp.Message;
}
}
public GreaterThen(SignalHandler signal, SignalHandler compareSignal, AlgerbraOperator nextOperator)
: base(signal, nextOperator)
{
this._compareSignal = compareSignal;
this._triggerInputs = TriggerInput.OnlySignal;
base.SignalHandlersUsedByTrigger.Add(signal);
base.SignalHandlersUsedByTrigger.Add(compareSignal);
}
// TODO: Look into toggle refs
protected void ConnectSignal <T>(SignalHandler <T> callback, string signal_name)
where T : SignalArgs, new()
{
/*Closure.ClosureFromDelegate*/
Closure signal_callback = new Closure <T>(callback, this, signal_name);
signals.Add(signal_callback);
}
public SigActionData(SignalHandler handler)
{
this.handler = handler;
flags = 0;
restorer = null;
mask = 0;
mask2 = 0;
}
public GreaterThen(SignalHandler signal, SignalHandler compareSignal, AlgerbraOperator nextOperator)
: base(signal, nextOperator)
{
this._compareSignal = compareSignal;
this._triggerInputs = TriggerInput.OnlySignal;
base.SignalHandlersUsedByTrigger.Add(signal);
base.SignalHandlersUsedByTrigger.Add(compareSignal);
}
public void register(SignalHandler handler)
{
_handler = handler;
_destroyed = false;
try
{
//
// Signal handling in Mono is provided in the Mono.Unix.Native namespace.
// We use reflection to do the equivalent of the following:
//
// Stdlib.signal(Signum.SIGHUP, delegate);
// Stdlib.signal(Signum.SIGINT, delegate);
// Stdlib.signal(Signum.SIGTERM, delegate);
//
// We don't use conditional compilation so that the Ice assembly can be
// used without change on Windows and Mono.
//
Assembly a = Assembly.Load(
"Mono.Posix, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756");
Type sigs = a.GetType("Mono.Unix.Native.Signum");
object SIGHUP = Enum.Parse(sigs, "SIGHUP");
object SIGINT = Enum.Parse(sigs, "SIGINT");
object SIGTERM = Enum.Parse(sigs, "SIGTERM");
Type stdlib = a.GetType("Mono.Unix.Native.Stdlib");
MethodInfo method = stdlib.GetMethod("signal", BindingFlags.Static | BindingFlags.Public);
Type delType = a.GetType("Mono.Unix.Native.SignalHandler");
Delegate del = Delegate.CreateDelegate(delType, this, "callback");
object[] args = new object[2];
args[0] = SIGHUP;
args[1] = del;
method.Invoke(null, args);
args[0] = SIGINT;
args[1] = del;
method.Invoke(null, args);
args[0] = SIGTERM;
args[1] = del;
method.Invoke(null, args);
//
// Doing certain activities within Mono's signal dispatch thread
// can cause the VM to crash, so we use a separate thread to invoke
// the handler.
//
_thread = new Thread(new ThreadStart(run));
_thread.IsBackground = true;
_thread.Name = "Ice.Application.SignalThread";
_thread.Start();
}
catch (System.DllNotFoundException)
{
//
// The class Mono.Unix.Native.Stdlib requires libMonoPosixHelper.so. Mono raises
// DllNotFoundException if it cannot be found in the shared library search path.
//
Util.getProcessLogger().warning("unable to initialize signals");
}
}
public void register(SignalHandler handler)
{
_handler = handler;
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs args)
{
args.Cancel = true;
_handler(0);
};
}
public void register(SignalHandler handler)
{
_handler = handler;
_callback = new CtrlCEventHandler(callback);
bool rc = SafeNativeMethods.SetConsoleCtrlHandler(_callback, true);
Debug.Assert(rc);
}
public ICollection <Delegate> GetSubscriptors <SignalType>(SignalHandler <SignalType> signalHandler) where SignalType : ISignal
{
if (!signalHandlers.ContainsKey(typeof(SignalType)))
{
return(null);
}
return(signalHandlers[typeof(SignalType)]);
}
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 EPDataFlowEmitter1Stream1TargetUnwind(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
EngineImportService engineImportService)
: base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService)
{
}
static void OnUserSignal()
{
byte[] stackstrace = new byte[8192];
int stackTraceLen = SignalHandler.ReadStackTrace(stackstrace, stackstrace.Length);
var stackTraceStr = System.Text.Encoding.UTF8.GetString(stackstrace, 0, stackTraceLen);
Debug.LogError(stackTraceStr);
shouldStopDeadLock = 1;
}
protected SystemSignalHandler(Signals signal)
{
this.signal = signal;
signum = GetSignum(signal);
#if MONO
signalHandler = new SignalHandler(OnSignal);
#else
signalHandler = new EventHandler(OnSignal);
#endif
}
void SignalMarshaller(IntPtr raw_closure, IntPtr return_val, uint n_param_vals, IntPtr param_values, IntPtr invocation_hint, IntPtr marshal_data)
{
// Call SignalHandler
SignalHandler <TArgs> handler = (SignalHandler <TArgs>) this.callback;
if (handler != null)
{
// TODO: Populate TArgs with GValues
TArgs args = new TArgs();
handler(this.obj, args);
}
}
static void Main()
{
_signalHandler += CloseApplication;
ConsoleHelper.SetSignalHandler(_signalHandler, true);
string ip = ConfigurationManager.AppSettings.Get("Ip");
int port = Int32.Parse(ConfigurationManager.AppSettings.Get("Port"));
_client = new Client(ip, port);
Console.WriteLine("Write room name");
_client.SendMessageToServer();
}
public EPDataFlowEmitter1Stream1TargetPassAlongWStream(
int operatorNum,
DataFlowSignalManager signalManager,
SignalHandler signalHandler,
EPDataFlowEmitterExceptionHandler exceptionHandler,
ObjectBindingPair target,
int streamNum,
EngineImportService engineImportService)
: base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService)
{
_streamNum = streamNum;
}
protected EPDataFlowEmitter1Stream1TargetBase(int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target)
{
OperatorNum = operatorNum;
SignalManager = signalManager;
SignalHandler = signalHandler;
ExceptionHandler = exceptionHandler;
var fastClass = FastClass.Create(target.Target.GetType());
_fastMethod = fastClass.GetMethod(target.Binding.ConsumingBindingDesc.Method);
TargetObject = target.Target;
}
public static IReadOnlyList <IntPtr> BindHandler(Action <SignalTypeEnum> handler, params SignalTypeEnum[] signals)
{
var signalHandler = new SignalHandler(i => handler((SignalTypeEnum)i));
var result = new List <IntPtr>(signals.Length);
foreach (var signal in signals)
{
result.Add(bindSignalHandler((int)signal, signalHandler));
}
return(result);
}
public Client(string name, IPEndPoint iPEndPoint, Socket socket, Dictionary <IPEndPoint, string> connectedClients,
IStringMethods stringMethods, IUserMethods userMethods)
{
signalHandler += HandleConsoleSignal;
SetSignalHandler(signalHandler, true);
this.name = name;
ConnectedClients = connectedClients;
this.iPEndPoint = iPEndPoint;
this.socket = socket;
this.userMethods = userMethods;
this.stringMethods = stringMethods;
}
private static void AddHandler(DrawNode node, ISignal signal, Action handler)
{
if (handler == null)
return;
SignalHandler element;
if (!Handlers.TryGetValue(node, out element))
{
element = new SignalHandler();
Handlers.Add(node, element);
}
element.AddHandler(signal, handler);
}
private static void Main()
{
XmlConfigurator.Configure();
Log.Info("start");
try
{
_signalHandler += HandleConsoleSignal;
ConsoleHelper.SetSignalHandler(_signalHandler, true);
var errors = Configurator.Config();
_atm = CashMachine.Deserialize(ConfigurationManager.AppSettings["SerializationAtm"]) ??
new CashMachine(new GreedyAlgorithm());
_statistics = Statistics.Statistics.Deserialize(ConfigurationManager.AppSettings["SerializationStatistics"]) ??
new Statistics.Statistics();
AtmEvent.InsertCassettesEvent += _statistics.InsertCassettes;
AtmEvent.WithdrawMoneyEvent += _statistics.WithdrawMoney;
AtmEvent.RemoveCassettesEvent += _statistics.RemoveCassettes;
var commandPerfomer = new Commands.CommandPerfomer(_atm, errors, _statistics);
Console.WriteLine(ConsoleLanguagePack.MainMessage);
while (true)
{
var input = Console.ReadLine();
Log.Debug(input);
if (string.IsNullOrEmpty(input))
{
continue;
}
if (ConsoleLanguagePack.ExitFlags.Contains(input))
{
break;
}
if (!commandPerfomer.TryPerform(input))
{
Console.WriteLine(ConsoleLanguagePack.CommandNotFound);
}
}
_atm.Serialize(ConfigurationManager.AppSettings["SerializationAtm"]);
_statistics.Serialize(ConfigurationManager.AppSettings["SerializationStatistics"]);
}
catch (Exception ex)
{
Log.Fatal(ex);
}
Log.Info("end");
}
public void SubscribeToUnixSignals()
{
var handler = new SignalHandler(UnixSignalHandler);
#pragma warning disable 612,618
Stdlib.signal(Signum.SIGTERM, handler);
Stdlib.signal(Signum.SIGINT, handler);
Stdlib.signal(Signum.SIGHUP, handler);
Stdlib.signal(Signum.SIGKILL, handler);
Stdlib.signal(Signum.SIGTSTP, handler);
Stdlib.signal(Signum.SIGSEGV, handler);
Stdlib.signal(Signum.SIGFPE, handler);
Stdlib.signal(Signum.SIGABRT, handler);
Stdlib.signal(Signum.SIGILL, handler);
Stdlib.signal(Signum.SIGSTOP, handler);
Stdlib.signal(Signum.SIGQUIT, handler);
#pragma warning restore 612,618
}
public void AddSubscriber(InPort p)
{
m_subscribers += p.AcceptSignal;
}
/**
* Unregister a signal handler.
*
* Remove the signal handler that was registered with the given parameters.
*
* @param handler The signal handler method.
* @param member The interface/member of the signal.
* @param srcPath The object path of the emitter of the signal or NULL for all paths.
* @return QStatus.OK
*/
public QStatus UnregisterSignalHandler(SignalHandler handler,
InterfaceDescription.Member member, string srcPath)
{
QStatus ret = QStatus.OS_ERROR;
if (_signalHandlerDelegateRefHolder.ContainsKey(handler))
{
ret = alljoyn_busattachment_unregistersignalhandler(_busAttachment,
Marshal.GetFunctionPointerForDelegate(_signalHandlerDelegateRefHolder[handler]),
member._member, srcPath);
_signalHandlerDelegateRefHolder.Remove(handler);
}
return ret;
}
public static void Connect(GLib.Object o, string name,
bool after, SignalHandler handler)
{
Connect (o, name, after, (Delegate) handler);
}
private static IntPtr sys_signal (int signum, SignalHandler handler)
{
throw new System.NotImplementedException();
}
public void register(SignalHandler handler)
{
_handler = handler;
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs args)
{
args.Cancel = true;
_handler(0);
};
}
public static void RegisterHandler(Signum signal,
SignalHandler handler)
{
handlers[signal] = handler;
SigActionData data = new SigActionData (new SignalHandler (InternalHandler));
sigaction ((int) signal, ref data, IntPtr.Zero);
}
public void register(SignalHandler handler)
{
//
// Signals aren't supported in managed code on Windows.
//
}
public static SignalHandler signal (Signum signum, SignalHandler handler)
{
int _sig = UnixConvert.FromSignum (signum);
IntPtr r;
if (handler == SIG_DFL)
r = sys_signal (_sig, _SIG_DFL);
else if (handler == SIG_ERR)
r = sys_signal (_sig, _SIG_ERR);
else if (handler == SIG_IGN)
r = sys_signal (_sig, _SIG_IGN);
else
r = sys_signal (_sig, handler);
return TranslateHandler (r);
}
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();
}
private static extern IntPtr sys_signal (int signum, SignalHandler handler);
public void Disconnect (string signal, SignalHandler handler) {
DynamicSignal.Disconnect (this, signal, handler);
}
public void register(SignalHandler handler)
{
_handler = handler;
_destroyed = false;
try
{
//
// Signal handling in Mono is provided in the Mono.Unix.Native namespace.
// We use reflection to do the equivalent of the following:
//
// Stdlib.signal(Signum.SIGHUP, delegate);
// Stdlib.signal(Signum.SIGINT, delegate);
// Stdlib.signal(Signum.SIGTERM, delegate);
//
// We don't use conditional compilation so that the Ice assembly can be
// used without change on Windows and Mono.
//
Assembly a = Assembly.Load(
"Mono.Posix, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756");
Type sigs = a.GetType("Mono.Unix.Native.Signum");
object SIGHUP = Enum.Parse(sigs, "SIGHUP");
object SIGINT = Enum.Parse(sigs, "SIGINT");
object SIGTERM = Enum.Parse(sigs, "SIGTERM");
Type stdlib = a.GetType("Mono.Unix.Native.Stdlib");
MethodInfo method = stdlib.GetMethod("signal", BindingFlags.Static | BindingFlags.Public);
Type delType = a.GetType("Mono.Unix.Native.SignalHandler");
Delegate del = Delegate.CreateDelegate(delType, this, "callback");
object[] args = new object[2];
args[0] = SIGHUP;
args[1] = del;
method.Invoke(null, args);
args[0] = SIGINT;
args[1] = del;
method.Invoke(null, args);
args[0] = SIGTERM;
args[1] = del;
method.Invoke(null, args);
//
// Doing certain activities within Mono's signal dispatch thread
// can cause the VM to crash, so we use a separate thread to invoke
// the handler.
//
_thread = new Thread(new ThreadStart(run));
_thread.IsBackground = true;
_thread.Name = "Ice.Application.SignalThread";
_thread.Start();
}
catch(System.DllNotFoundException)
{
//
// The class Mono.Unix.Native.Stdlib requires libMonoPosixHelper.so. Mono raises
// DllNotFoundException if it cannot be found in the shared library search path.
//
Util.getProcessLogger().warning("unable to initialize signals");
}
}
public void RemoveSubscriber(InPort p)
{
m_subscribers -= p.AcceptSignal;
}
public void register(SignalHandler handler)
{
_handler = handler;
_callback = new CtrlCEventHandler(callback);
bool rc = NativeMethods.SetConsoleCtrlHandler(_callback, true);
Debug.Assert(rc);
}
/**
* Register a signal handler.
*
* Signals are forwarded to the signalHandler if sender, interface, member and path
* qualifiers are ALL met.
*
* @param handler The signal handler method.
* @param member The interface/member of the signal.
* @param srcPath The object path of the emitter of the signal or NULL for all paths.
* @return QStatus.OK
*/
public QStatus RegisterSignalHandler(SignalHandler handler,
InterfaceDescription.Member member, string srcPath)
{
InternalSignalHandler internalSignalHandler = (IntPtr m, IntPtr s, IntPtr msg) =>
{
SignalHandler h = handler;
h(new InterfaceDescription.Member(m), Marshal.PtrToStringAnsi(s), new Message(msg));
};
_signalHandlerDelegateRefHolder.Add(handler, internalSignalHandler);
QStatus ret = alljoyn_busattachment_registersignalhandler(_busAttachment,
Marshal.GetFunctionPointerForDelegate(internalSignalHandler),
member._member, srcPath);
return ret;
}
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 void Connect(GLib.Object o, string name, SignalHandler handler)
{
Connect (o, name, false, (Delegate) handler);
}
