def signal_quit(self, signum, frame):
     log.info("")
     log.info("proxy process pid %s got signal %s, exiting", os.getpid(), SIGNAMES.get(signum, signum))
     self.exit = True
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.stop(SIGNAMES.get(signum, signum))
 def signal_quit(self, signum, frame):
     log.info("")
     log.info("proxy process pid %s got signal %s, exiting", os.getpid(), SIGNAMES.get(signum, signum))
     self.exit = True
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.stop(SIGNAMES.get(signum, signum))
Beispiel #3
0
 def signal_quit(self, signum, _frame=None):
     log.info("")
     log.info("proxy process pid %s got signal %s, exiting", os.getpid(), SIGNAMES.get(signum, signum))
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.stop(None, SIGNAMES.get(signum, signum))
     #from now on, we can't rely on the main loop:
     register_SIGUSR_signals()
Beispiel #4
0
 def signal_quit(self, signum, _frame=None):
     log.info("")
     log.info("proxy process pid %s got signal %s, exiting", os.getpid(),
              SIGNAMES.get(signum, signum))
     QueueScheduler.stop(self)
     self.message_queue.put(None, False)
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.stop(None, SIGNAMES.get(signum, signum))
Beispiel #5
0
 def handle_app_signal(self, signum, _frame=None):
     sys.stderr.write("\ngot signal %s, exiting\n" %
                      SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     signal.signal(signal.SIGINT, self.handle_deadly_signal)
     signal.signal(signal.SIGTERM, self.handle_deadly_signal)
     self.signal_cleanup()
     self.timeout_add(0, self.signal_disconnect_and_quit, 128 + signum,
                      "exit on signal %s" % SIGNAMES.get(signum, signum))
Beispiel #6
0
 def app_signal(signum, frame):
     sys.stderr.write("\ngot signal %s, exiting\n" %
                      SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.timeout_add(
         0, self.disconnect_and_quit, 128 + signum,
         "exit on signal %s" % SIGNAMES.get(signum, signum))
Beispiel #7
0
 def app_signal(signum, frame):
     sys.stderr.write("\ngot signal %s, exiting\n" % SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.signal_cleanup()
     self.timeout_add(0, self.signal_disconnect_and_quit, 128 + signum, "exit on signal %s" % SIGNAMES.get(signum, signum))
Beispiel #8
0
 def show_signal():
     app.show()
     app.client.cleanup()
     glib.timeout_add(
         1000, app.set_info_text,
         "got signal %s" % SIGNAMES.get(signum, signum))
     glib.timeout_add(1000, app.set_info_color, True)
Beispiel #9
0
 def signal_quit(self, signum, frame):
     log.info("")
     log.info("got signal %s, exiting", SIGNAMES.get(signum, signum))
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.idle_add(self.clean_quit, True)
     self.idle_add(sys.exit, 128 + signum)
Beispiel #10
0
 def signal_quit(self, signum, frame):
     log.info("")
     log.info("got signal %s, exiting", SIGNAMES.get(signum, signum))
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.idle_add(self.clean_quit)
     self.idle_add(sys.exit, 128 + signum)
Beispiel #11
0
 def deadly_signal(sig, frame):
     log.warn("got deadly signal %s", SIGNAMES.get(sig, sig))
     glib.idle_add(ss.stop)
     glib.idle_add(glib_mainloop.quit)
     def force_quit(sig, frame):
         sys.exit()
     signal.signal(signal.SIGINT, force_quit)
     signal.signal(signal.SIGTERM, force_quit)
Beispiel #12
0
 def deadly_signal(sig, frame):
     log.warn("got deadly signal %s", SIGNAMES.get(sig, sig))
     glib.idle_add(ss.stop)
     glib.idle_add(glib_mainloop.quit)
     def force_quit(sig, frame):
         sys.exit()
     signal.signal(signal.SIGINT, force_quit)
     signal.signal(signal.SIGTERM, force_quit)
Beispiel #13
0
 def os_signal(signum, _frame=None):
     try:
         sys.stderr.write("\n")
         sys.stderr.flush()
         log.info("client got signal %s", SIGNAMES.get(signum, signum))
     except Exception:
         pass
     self.handle_app_signal(signum)
Beispiel #14
0
 def signal_quit(self, signum, frame):
     sys.stdout.write("\n")
     sys.stdout.flush()
     self._closing = True
     log.info("got signal %s, exiting", SIGNAMES.get(signum, signum))
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.idle_add(self.clean_quit)
     self.idle_add(sys.exit, 128 + signum)
Beispiel #15
0
 def handle_signal(signum):
     app.show()
     client = app.client
     if client:
         client.cleanup()
     else:
         Gtk.main_quit()
     GLib.timeout_add(1000, app.set_info_text, "got signal %s" % SIGNAMES.get(signum, signum))
     GLib.timeout_add(1000, app.set_info_color, True)
Beispiel #16
0
 def signal_quit(self, signum, frame):
     sys.stdout.write("\n")
     sys.stdout.flush()
     self._closing = True
     log.info("got signal %s, exiting", SIGNAMES.get(signum, signum))
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.idle_add(self.clean_quit)
     self.idle_add(sys.exit, 128+signum)
Beispiel #17
0
 def handle_signal(signum):
     try:
         sys.stderr.write("\n")
         sys.stderr.flush()
         get_util_logger().info("got signal %s",
                                SIGNAMES.get(signum, signum))
     except (IOError, OSError):
         pass
     callback(signum)
Beispiel #18
0
 def handle_app_signal(self, signum, _frame=None):
     try:
         log.info("exiting")
     except Exception:
         pass
     signal.signal(signal.SIGINT, self.handle_deadly_signal)
     signal.signal(signal.SIGTERM, self.handle_deadly_signal)
     self.signal_cleanup()
     reason = "exit on signal %s" % SIGNAMES.get(signum, signum)
     self.timeout_add(0, self.signal_disconnect_and_quit, 128 + signum, reason)
Beispiel #19
0
 def app_signal(signum, frame):
     print("")
     log("got signal %s" % SIGNAMES.get(signum, signum))
     def show_signal():
         app.show()
         app.client.cleanup()
         glib.timeout_add(1000, app.set_info_text, "got signal %s" % SIGNAMES.get(signum, signum))
         glib.timeout_add(1000, app.set_info_color, True)
     #call from UI thread:
     glib.idle_add(show_signal)
Beispiel #20
0
def deadly_signal(signum, _frame):
    info("got deadly signal %s, exiting\n" % SIGNAMES.get(signum, signum))
    run_cleanups()
    # This works fine in tests, but for some reason if I use it here, then I
    # get bizarre behavior where the signal handler runs, and then I get a
    # KeyboardException (?!?), and the KeyboardException is handled normally
    # and exits the program (causing the cleanup handlers to be run again):
    #signal.signal(signum, signal.SIG_DFL)
    #kill(os.getpid(), signum)
    os._exit(128 + signum)
Beispiel #21
0
 def handle_signal(self, sig):
     """ This is for OS signals SIGINT and SIGTERM """
     #next time, just stop:
     register_os_signals(self.signal_stop)
     signame = SIGNAMES.get(sig, sig)
     log("handle_signal(%s) calling stop from main thread", signame)
     self.send("signal", signame)
     self.timeout_add(0, self.cleanup)
     #give time for the network layer to send the signal message
     self.timeout_add(150, self.stop)
Beispiel #22
0
 def app_signal(signum, _frame):
     print("")
     log("got signal %s" % SIGNAMES.get(signum, signum))
     def show_signal():
         app.show()
         app.client.cleanup()
         glib.timeout_add(1000, app.set_info_text, "got signal %s" % SIGNAMES.get(signum, signum))
         glib.timeout_add(1000, app.set_info_color, True)
     #call from UI thread:
     glib.idle_add(show_signal)
Beispiel #23
0
def deadly_signal(signum, frame):
    sys.stdout.write("got deadly signal %s, exiting\n" % SIGNAMES.get(signum, signum))
    sys.stdout.flush()
    run_cleanups()
    # This works fine in tests, but for some reason if I use it here, then I
    # get bizarre behavior where the signal handler runs, and then I get a
    # KeyboardException (?!?), and the KeyboardException is handled normally
    # and exits the program (causing the cleanup handlers to be run again):
    #signal.signal(signum, signal.SIG_DFL)
    #kill(os.getpid(), signum)
    os._exit(128 + signum)
Beispiel #24
0
 def handle_signal(self, sig, frame):
     """ This is for OS signals SIGINT and SIGTERM """
     #next time, just stop:
     signal.signal(signal.SIGINT, self.signal_stop)
     signal.signal(signal.SIGTERM, self.signal_stop)
     signame = SIGNAMES.get(sig, sig)
     log("handle_signal(%s, %s) calling stop from main thread", signame, frame)
     self.send("signal", signame)
     self.cleanup()
     #give time for the network layer to send the signal message
     gobject.timeout_add(150, self.stop)
Beispiel #25
0
 def handle_signal(self, sig, frame):
     """ This is for OS signals SIGINT and SIGTERM """
     #next time, just stop:
     signal.signal(signal.SIGINT, self.signal_stop)
     signal.signal(signal.SIGTERM, self.signal_stop)
     signame = SIGNAMES.get(sig, sig)
     log("handle_signal(%s, %s) calling stop from main thread", signame,
         frame)
     self.send("signal", signame)
     self.cleanup()
     #give time for the network layer to send the signal message
     gobject.timeout_add(150, self.stop)
Beispiel #26
0
 def handle_signal(signum):
     try:
         sys.stderr.write("\n")
         sys.stderr.flush()
         cstr = ""
         if commandtype:
             cstr = commandtype + " "
         get_util_logger().info("%sgot signal %s", cstr,
                                SIGNAMES.get(signum, signum))
     except OSError:
         pass
     callback(signum)
     return True
Beispiel #27
0
 def handle_signal(self, sig, frame):
     """ This is for OS signals SIGINT and SIGTERM """
     #next time, just stop:
     signal.signal(signal.SIGINT, self.signal_stop)
     signal.signal(signal.SIGTERM, self.signal_stop)
     signame = SIGNAMES.get(sig, sig)
     try:
         log("handle_signal(%s, %s) calling stop from main thread", signame, frame)
     except:
         pass        #may fail if we were doing IO logging when the signal was received
     self.send("signal", signame)
     self.timeout_add(0, self.cleanup)
     #give time for the network layer to send the signal message
     self.timeout_add(150, self.stop)
Beispiel #28
0
 def handle_signal(self, sig, frame):
     """ This is for OS signals SIGINT and SIGTERM """
     #next time, just stop:
     signal.signal(signal.SIGINT, self.signal_stop)
     signal.signal(signal.SIGTERM, self.signal_stop)
     signame = SIGNAMES.get(sig, sig)
     try:
         log("handle_signal(%s, %s) calling stop from main thread", signame, frame)
     except:
         pass        #may fail if we were doing IO logging when the signal was received
     self.send("signal", signame)
     self.timeout_add(0, self.cleanup)
     #give time for the network layer to send the signal message
     self.timeout_add(150, self.stop)
Beispiel #29
0
def register_os_signal(callback, commandtype="", signum=signal.SIGINT):
    from gi.repository import GLib  #pylint: disable=import-outside-toplevel
    signame = SIGNAMES.get(signum, str(signum))

    def write_signal():
        if commandtype is None:
            return
        try:
            sys.stderr.write("\n")
            sys.stderr.flush()
            cstr = ""
            if commandtype:
                cstr = commandtype + " "
            get_util_logger().info("%sgot signal %s", cstr, signame)
        except OSError:
            pass

    def do_handle_signal():
        callback(signum)

    if POSIX:
        #replace the previous definition if we had one:
        global _glib_unix_signals
        current = _glib_unix_signals.get(signum, None)
        if current:
            GLib.source_remove(current)

        def handle_signal(_signum):
            write_signal()
            do_handle_signal()
            return True

        source_id = GLib.unix_signal_add(GLib.PRIORITY_HIGH, signum,
                                         handle_signal, signum)
        _glib_unix_signals[signum] = source_id
    else:

        def os_signal(_signum, _frame):
            write_signal()
            GLib.idle_add(do_handle_signal)

        signal.signal(signum, os_signal)
Beispiel #30
0
 def signal_stop(self, sig):
     """ This time we really want to exit without waiting """
     signame = SIGNAMES.get(sig, sig)
     log("signal_stop(%s) calling stop", signame)
     self.stop()
Beispiel #31
0
 def handle_signal(self, signum, frame=None):
     log("handle_signal(%s, %s)", SIGNAMES.get(signum, signum), frame)
     self.exit_code = 128-(signum or 0)
     GLib.idle_add(self.exit)
Beispiel #32
0
 def app_signal(signum, frame):
     print("")
     log.info("got signal %s", SIGNAMES.get(signum, signum))
     app.quit()
Beispiel #33
0
 def handle_deadly_signal(self, signum, _frame=None):
     sys.stderr.write("\ngot deadly signal %s, exiting\n" %
                      SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     self.cleanup()
     force_quit(128 + signum)
Beispiel #34
0
 def deadly_signal(signum, frame):
     sys.stderr.write("\ngot deadly signal %s, exiting\n" % SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     self.cleanup()
     os._exit(128 + signum)
Beispiel #35
0
 def app_signal(signum, _frame):
     print("")
     log.info("got signal %s", SIGNAMES.get(signum, signum))
     app.quit()
Beispiel #36
0
 def show_signal():
     app.show()
     app.client.cleanup()
     glib.timeout_add(1000, app.set_info_text, "got signal %s" % SIGNAMES.get(signum, signum))
     glib.timeout_add(1000, app.set_info_color, True)
Beispiel #37
0
 def deadly_signal(sig, frame):
     log.warn("got deadly signal %s", SIGNAMES.get(sig, sig))
     gobject.idle_add(ss.stop)
     gobject.idle_add(gobject_mainloop.quit)
Beispiel #38
0
 def signal_stop(self, sig, frame):
     """ This time we really want to exit without waiting """
     signame = SIGNAMES.get(sig, sig)
     log("signal_stop(%s, %s) calling stop", signame, frame)
     self.stop()
Beispiel #39
0
 def app_signal(signum, frame):
     sys.stderr.write("\ngot signal %s, exiting\n" % SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     signal.signal(signal.SIGINT, deadly_signal)
     signal.signal(signal.SIGTERM, deadly_signal)
     self.timeout_add(0, self.quit, 128 + signum)
Beispiel #40
0
 def deadly_signal(signum, frame):
     sys.stderr.write("\ngot deadly signal %s, exiting\n" %
                      SIGNAMES.get(signum, signum))
     sys.stderr.flush()
     self.cleanup()
     os._exit(128 + signum)
Beispiel #41
0
 def deadly_signal(sig, frame):
     log.warn("got deadly signal %s", SIGNAMES.get(sig, sig))
     gobject.idle_add(ss.stop)
     gobject.idle_add(gobject_mainloop.quit)