/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2016-03-12 23:42:38 UTC
  • Revision ID: teddy@recompile.se-20160312234238-xdszntu18cfwife9
Server: Use python-gi instead of old python-gobject

The python-gobject module is old, deprecated, and replaced with the
python-gi (GObject Introspection) module; use that instead.

* debian/control (Source: mandos/Build-Depends-Indep): Change
  "python-gi | python-gobject" to "python-gi".
* mandos: Import "GLib" instead of "GObject"; change all users.
* mandos-monitor: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
79
79
 
80
80
import dbus
81
81
import dbus.service
82
 
try:
83
 
    from gi.repository import GObject
84
 
except ImportError:
85
 
    import gobject as GObject
 
82
from gi.repository import GLib
86
83
from dbus.mainloop.glib import DBusGMainLoop
87
84
import ctypes
88
85
import ctypes.util
757
754
    checker:    subprocess.Popen(); a running checker process used
758
755
                                    to see if the client lives.
759
756
                                    'None' if no process is running.
760
 
    checker_callback_tag: a GObject event source tag, or None
 
757
    checker_callback_tag: a GLib event source tag, or None
761
758
    checker_command: string; External command which is run to check
762
759
                     if client lives.  %() expansions are done at
763
760
                     runtime with vars(self) as dict, so that for
764
761
                     instance %(name)s can be used in the command.
765
 
    checker_initiator_tag: a GObject event source tag, or None
 
762
    checker_initiator_tag: a GLib event source tag, or None
766
763
    created:    datetime.datetime(); (UTC) object creation
767
764
    client_structure: Object describing what attributes a client has
768
765
                      and is used for storing the client at exit
769
766
    current_checker_command: string; current running checker_command
770
 
    disable_initiator_tag: a GObject event source tag, or None
 
767
    disable_initiator_tag: a GLib event source tag, or None
771
768
    enabled:    bool()
772
769
    fingerprint: string (40 or 32 hexadecimal digits); used to
773
770
                 uniquely identify the client
929
926
        if not quiet:
930
927
            logger.info("Disabling client %s", self.name)
931
928
        if getattr(self, "disable_initiator_tag", None) is not None:
932
 
            GObject.source_remove(self.disable_initiator_tag)
 
929
            GLib.source_remove(self.disable_initiator_tag)
933
930
            self.disable_initiator_tag = None
934
931
        self.expires = None
935
932
        if getattr(self, "checker_initiator_tag", None) is not None:
936
 
            GObject.source_remove(self.checker_initiator_tag)
 
933
            GLib.source_remove(self.checker_initiator_tag)
937
934
            self.checker_initiator_tag = None
938
935
        self.stop_checker()
939
936
        self.enabled = False
940
937
        if not quiet:
941
938
            self.send_changedstate()
942
 
        # Do not run this again if called by a GObject.timeout_add
 
939
        # Do not run this again if called by a GLib.timeout_add
943
940
        return False
944
941
    
945
942
    def __del__(self):
949
946
        # Schedule a new checker to be started an 'interval' from now,
950
947
        # and every interval from then on.
951
948
        if self.checker_initiator_tag is not None:
952
 
            GObject.source_remove(self.checker_initiator_tag)
953
 
        self.checker_initiator_tag = GObject.timeout_add(
 
949
            GLib.source_remove(self.checker_initiator_tag)
 
950
        self.checker_initiator_tag = GLib.timeout_add(
954
951
            int(self.interval.total_seconds() * 1000),
955
952
            self.start_checker)
956
953
        # Schedule a disable() when 'timeout' has passed
957
954
        if self.disable_initiator_tag is not None:
958
 
            GObject.source_remove(self.disable_initiator_tag)
959
 
        self.disable_initiator_tag = GObject.timeout_add(
 
955
            GLib.source_remove(self.disable_initiator_tag)
 
956
        self.disable_initiator_tag = GLib.timeout_add(
960
957
            int(self.timeout.total_seconds() * 1000), self.disable)
961
958
        # Also start a new checker *right now*.
962
959
        self.start_checker()
998
995
        if timeout is None:
999
996
            timeout = self.timeout
1000
997
        if self.disable_initiator_tag is not None:
1001
 
            GObject.source_remove(self.disable_initiator_tag)
 
998
            GLib.source_remove(self.disable_initiator_tag)
1002
999
            self.disable_initiator_tag = None
1003
1000
        if getattr(self, "enabled", False):
1004
 
            self.disable_initiator_tag = GObject.timeout_add(
 
1001
            self.disable_initiator_tag = GLib.timeout_add(
1005
1002
                int(timeout.total_seconds() * 1000), self.disable)
1006
1003
            self.expires = datetime.datetime.utcnow() + timeout
1007
1004
    
1062
1059
                args = (pipe[1], subprocess.call, command),
1063
1060
                kwargs = popen_args)
1064
1061
            self.checker.start()
1065
 
            self.checker_callback_tag = GObject.io_add_watch(
1066
 
                pipe[0].fileno(), GObject.IO_IN,
 
1062
            self.checker_callback_tag = GLib.io_add_watch(
 
1063
                pipe[0].fileno(), GLib.IO_IN,
1067
1064
                self.checker_callback, pipe[0], command)
1068
 
        # Re-run this periodically if run by GObject.timeout_add
 
1065
        # Re-run this periodically if run by GLib.timeout_add
1069
1066
        return True
1070
1067
    
1071
1068
    def stop_checker(self):
1072
1069
        """Force the checker process, if any, to stop."""
1073
1070
        if self.checker_callback_tag:
1074
 
            GObject.source_remove(self.checker_callback_tag)
 
1071
            GLib.source_remove(self.checker_callback_tag)
1075
1072
            self.checker_callback_tag = None
1076
1073
        if getattr(self, "checker", None) is None:
1077
1074
            return
1832
1829
    
1833
1830
    def approve(self, value=True):
1834
1831
        self.approved = value
1835
 
        GObject.timeout_add(int(self.approval_duration.total_seconds()
1836
 
                                * 1000), self._reset_approved)
 
1832
        GLib.timeout_add(int(self.approval_duration.total_seconds()
 
1833
                             * 1000), self._reset_approved)
1837
1834
        self.send_changedstate()
1838
1835
    
1839
1836
    ## D-Bus methods, signals & properties
2049
2046
                if (getattr(self, "disable_initiator_tag", None)
2050
2047
                    is None):
2051
2048
                    return
2052
 
                GObject.source_remove(self.disable_initiator_tag)
2053
 
                self.disable_initiator_tag = GObject.timeout_add(
 
2049
                GLib.source_remove(self.disable_initiator_tag)
 
2050
                self.disable_initiator_tag = GLib.timeout_add(
2054
2051
                    int((self.expires - now).total_seconds() * 1000),
2055
2052
                    self.disable)
2056
2053
    
2076
2073
            return
2077
2074
        if self.enabled:
2078
2075
            # Reschedule checker run
2079
 
            GObject.source_remove(self.checker_initiator_tag)
2080
 
            self.checker_initiator_tag = GObject.timeout_add(
 
2076
            GLib.source_remove(self.checker_initiator_tag)
 
2077
            self.checker_initiator_tag = GLib.timeout_add(
2081
2078
                value, self.start_checker)
2082
2079
            self.start_checker() # Start one now, too
2083
2080
    
2487
2484
        gnutls_priority GnuTLS priority string
2488
2485
        use_dbus:       Boolean; to emit D-Bus signals or not
2489
2486
    
2490
 
    Assumes a GObject.MainLoop event loop.
 
2487
    Assumes a GLib.MainLoop event loop.
2491
2488
    """
2492
2489
    
2493
2490
    def __init__(self, server_address, RequestHandlerClass,
2518
2515
    
2519
2516
    def add_pipe(self, parent_pipe, proc):
2520
2517
        # Call "handle_ipc" for both data and EOF events
2521
 
        GObject.io_add_watch(
 
2518
        GLib.io_add_watch(
2522
2519
            parent_pipe.fileno(),
2523
 
            GObject.IO_IN | GObject.IO_HUP,
 
2520
            GLib.IO_IN | GLib.IO_HUP,
2524
2521
            functools.partial(self.handle_ipc,
2525
2522
                              parent_pipe = parent_pipe,
2526
2523
                              proc = proc))
2530
2527
                   proc = None,
2531
2528
                   client_object=None):
2532
2529
        # error, or the other end of multiprocessing.Pipe has closed
2533
 
        if condition & (GObject.IO_ERR | GObject.IO_HUP):
 
2530
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
2534
2531
            # Wait for other process to exit
2535
2532
            proc.join()
2536
2533
            return False
2557
2554
                parent_pipe.send(False)
2558
2555
                return False
2559
2556
            
2560
 
            GObject.io_add_watch(
 
2557
            GLib.io_add_watch(
2561
2558
                parent_pipe.fileno(),
2562
 
                GObject.IO_IN | GObject.IO_HUP,
 
2559
                GLib.IO_IN | GLib.IO_HUP,
2563
2560
                functools.partial(self.handle_ipc,
2564
2561
                                  parent_pipe = parent_pipe,
2565
2562
                                  proc = proc,
2995
2992
        # Close all input and output, do double fork, etc.
2996
2993
        daemon()
2997
2994
    
2998
 
    # multiprocessing will use threads, so before we use GObject we
2999
 
    # need to inform GObject that threads will be used.
3000
 
    GObject.threads_init()
 
2995
    # multiprocessing will use threads, so before we use GLib we need
 
2996
    # to inform GLib that threads will be used.
 
2997
    GLib.threads_init()
3001
2998
    
3002
2999
    global main_loop
3003
3000
    # From the Avahi example code
3004
3001
    DBusGMainLoop(set_as_default=True)
3005
 
    main_loop = GObject.MainLoop()
 
3002
    main_loop = GLib.MainLoop()
3006
3003
    bus = dbus.SystemBus()
3007
3004
    # End of Avahi example code
3008
3005
    if use_dbus:
3421
3418
                sys.exit(1)
3422
3419
            # End of Avahi example code
3423
3420
        
3424
 
        GObject.io_add_watch(tcp_server.fileno(), GObject.IO_IN,
3425
 
                             lambda *args, **kwargs:
3426
 
                             (tcp_server.handle_request
3427
 
                              (*args[2:], **kwargs) or True))
 
3421
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
 
3422
                          lambda *args, **kwargs:
 
3423
                          (tcp_server.handle_request
 
3424
                           (*args[2:], **kwargs) or True))
3428
3425
        
3429
3426
        logger.debug("Starting main loop")
3430
3427
        main_loop.run()