DBus mit Python

Der Dämon

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

     #!/usr/bin/env python3
     import dbus
     from dbus.service import BusName
     from dbus.mainloop.glib import DBusGMainLoop
     from gi.repository import GObject


     class DemoException(dbus.DBusException):
         _dbus_error_name = 'de.pinyto.daemonException'


     class BackofficeInterface(dbus.service.Object):

         @dbus.service.method("de.pinyto.daemon.backoffice",
                              in_signature='s', out_signature='as')
         def HelloWorld(self, hello_message):
             print(str(hello_message))
             return ["Hello", " from example-service.py", "with unique name",
                     session_bus.get_unique_name()]

         @dbus.service.method("de.pinyto.daemon.backoffice",
                              in_signature='', out_signature='')
         def RaiseException(self):
             raise DemoException('The RaiseException method does what you might '
                                 'expect')

         @dbus.service.method("de.pinyto.daemon.backoffice",
                              in_signature='', out_signature='(ss)')
         def GetTuple(self):
             return ("Hello Tuple", " from pinytod.py")

         @dbus.service.method("de.pinyto.daemon.backoffice",
                              in_signature='', out_signature='a{ss}')
         def GetDict(self):
             return {"first": "Hello Dict", "second": " from pinytod.py"}

         @dbus.service.method("de.pinyto.daemon.backoffice",
                              in_signature='', out_signature='')
         def Exit(self):
             mainloop.quit()


     if __name__ == '__main__':
         DBusGMainLoop(set_as_default=True)

         session_bus = dbus.SessionBus()
         name = dbus.service.BusName("de.pinyto.daemon", session_bus)
         backoffice_interface = BackofficeInterface(session_bus, '/Backoffice')

         mainloop = GObject.MainLoop()
         print("Pinyto daemon is running.")
         mainloop.run()

Um zu erklären, was hier passiert beginnen wir mit der Initialisierung nach

1

     if __name__ == '__main__':

Da der Dämon mit asynchronen Requests hantieren muss und dabei nicht blockieren soll, muss eine MainLoop eingerichtet werden. Diese checkt auf resourcenschonende Art nach Neuigkeiten und koordiniert die richtige Ausführung. Es ergibt keinen Sinn mehr als eine MainLoop zu haben, weshalb man der DBus Schnittstelle mitteilen kann, dass die Glib MainLoop die wir benutzen der Default sein soll. Prinzipiell sollte glib-python mit verschiedenen MainLoops funktionieren, ich konnte jedoch nur zur GLib MainLoop ein funktionierendes Beispiel finden.

Bevor die MainLoop gestartet werden kann, müssen aber noch einige Dinge initialisiert werden. Zunächst brauchen wir einen Bus. DBus bietet immer zwei Standard-Busse, den SystemBus und den SessionBus. Der SystemBus dient zur Kommunikation mit Systemdiensten wie dem NetworkManager, der SessionBus zur Kommunikation von Programmen eines angemeldeten Benutzers untereinander. Da sowohl der Dämon als auch der Client in der Session des Users laufen sollen wird eine Referenz zum SessionBus geladen.

Bei diesem Bus muss sich der Dämon nun mit einem DBus-konformen Namen anmelden. Konvention sind umgekehrte Domainnamen mit dem Programmnamen hinter dem letzten Punkt. Hier also "de.pinyto.daemon". Ist der Name auf diese Weise registriert, leifert DBus interessierten Clients die Information, dass hier etwas erreichbar ist.

Unterhalb des Namens, der den Dämon identifiziert kann dieser verschiedene Dienste unter verschiedenen Pfaden anbieten. Im Beispiel ist es ein einzelner Dienst, definiert in der Klasse BackofficeInterface, der unter dem Pfad "/Backoffice" erreichbar gemacht wird.

Die Klasse BackofficeInterface wird zum DBus-Interface (Die Dienste heißen bei DBus "Interface"), indem sie von dbus.service.Object erbt. Damit ihre Methoden über das Interface aufgerufen werden können, müssen sie mit @dbus.service.method dekoriert werden. Im Decoratior wird jeweils nochmal ein Name des Service angegeben ("do.pinyto.daemon.backoffice") und die Signatur für Eingebe- und Ausgabeparameter angegeben. Dies ist nötig, da DBus im Gegensatz zu Python statisch typisiert ist. Eine Tabelle mit den verfügbaren Typen findet sich im Tutorial. Die Methoden selbst enthalten normalen Python-Code, der natürlich die passenden Typen zurückgeben muss.

Nach der Initialisierung des Interface kann ein mainloop-Objekt erzeigt werden und die MainLoop mit mainloop.run() gestartet werden.

Mit diesem Code kann der Dämon gesartet werden und läuft dann unendlich oder bis er mit der Exit-Methode gestoppt wird. Während der Dämon läuft, antwortet er auf Requests, die per DBus hereinkommen.

Der Client

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

     import sys
     import traceback

     from gi.repository import GObject

     import dbus
     import dbus.mainloop.glib


     # Callbacks for asynchronous calls
     def handle_hello_reply(r):
         global hello_replied
         hello_replied = True

         print(str(r))

         if hello_replied and raise_replied:
             loop.quit()


     def handle_hello_error(e):
         global failed
         global hello_replied
         hello_replied = True
         failed = True

         print("HelloWorld raised an exception! That's not meant to happen...")
         print("\t" + str(e))

         if hello_replied and raise_replied:
             loop.quit()


     def handle_raise_reply():
         global failed
         global raise_replied
         raise_replied = True
         failed = True

         print("RaiseException returned normally! That's not meant to happen...")

         if hello_replied and raise_replied:
             loop.quit()


     def handle_raise_error(e):
         global raise_replied
         raise_replied = True

         print("RaiseException raised an exception as expected:")
         print("\t" + str(e))

         if hello_replied and raise_replied:
             loop.quit()


     def make_calls():
         # To make an async call, use the reply_handler and error_handler kwargs
         remote_object.HelloWorld("Hello from dbus_test.py!",
                                  dbus_interface='de.pinyto.daemon.backoffice',
                                  reply_handler=handle_hello_reply,
                                  error_handler=handle_hello_error)

         # Interface objects also support async calls
         iface = dbus.Interface(remote_object, 'de.pinyto.daemon.backoffice')

         iface.RaiseException(reply_handler=handle_raise_reply,
                              error_handler=handle_raise_error)

         return False

     if __name__ == '__main__':
         dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

         bus = dbus.SessionBus()
         try:
             remote_object = bus.get_object("de.pinyto.daemon",
                                            "/Backoffice")
         except dbus.DBusException:
             traceback.print_exc()
             sys.exit(1)

         # Make the method call after a short delay
         GObject.timeout_add(1000, make_calls)

         failed = False
         hello_replied = False
         raise_replied = False

         loop = GObject.MainLoop()
         loop.run()
         if failed:
             raise SystemExit("Async client failed!")

Da der Client seine Requests asynchron absetzen soll, braucht auch er eine MainLoop. Natürlich muss er auch den selben Bus benutzen. Da der Client aber keine Dienste anbietet, muss sein Name nicht am Bus angemeldet werden. Stattdessen holt er sich von DBus ein Proxy-Objekt, das die Signaturen des Interface beim Dämon übernimmt. Mit dem Proxy-Objekt (remote_object) kann dann wie mit einer Instanz der Interface-Klasse verfahren werden. Damit das Proxy-Objekt passend aufgebaut werden kann muss natürlich das Interface eindeutig mit Name und Pfad definiert werden. Das schlägt natürlich fehl, wenn sich der Dämon nicht am Bus angemeldet hat, was z.B. der Fall wäre, wenn er nicht läuft.

Anschließend wird make_calls nach einer Sekunde Wartezeit ausgeführt. Der Timeout zählt ab dem starten der MainLoop. In make_calls wird Hello direkt aufgerufen, indem das Interface als String benannt wird. RaiseException wird danach auf einem Interface-Objekt aufgerufen. Beide Varianten funktionieren. Für viele Requests lohnt es sich ein Interface-Objekt zu erzeugen. Für einzelne Calls ist die erste Variante sinnvoller. In beiden Fällen muss ein reply_handler und ein error_handler angegeben werden. Beides sind normale Python-Funktionen, die im Erfolgs- oder Fehlerfall aufgerufen werden, sobald der Request abgeschlossen ist. Ein großer Teil des Codes dient lediglich dazu die MainLoop in dem Moment zu stoppen, wenn alle Requests abgeschlossen sind. In einem grafischen Programm ist es gut möglich, dass es durch Benutzerinteraktion beendet wird und der Code daher sogar einfacher wird.

Fazit

DBus in Python ist möglich und erfordert auch nicht übermäßig komplizierten Code. Wirklich pythonic kommt dbus-python nicht daher, weshalb pydbus durchaus noch etwas verbessern könnte. Da dort aber noch weniger Dokumentation vorhanden ist, bin ich als Einsteiger einfach außer stande es zu benutzen. Zur Prformance kann ich noch nicht viel sagen, aber es scheint bisher alles hinreichend schnell zu sein.

Prinzipiell ist DBus ein sehr interessantes System, da es Desktop-Applikationen ermöglicht, die selbst wenig machen und trotzdem im Zusammenspiel mit anderen Diensten mächtige Funktionalität anbieten können. Allerdings muss die Dokumentation rund um die DBus implementierungen deutlich besser werden, wozu ich hiermit hoffentlich meinen Beitrag geleistet habe.

Weitergehende Infos

• Hier wird erklärt, wie man mit einem .service File DBus dazu bringen kann den Dämon genau dann zu starten, wenn er gebraucht wird.