Also, I think I am now starting to get a hang of things; however, one doubt solved raises another doubt :D
The reason I began looking out for the two-threads-approach, is because when trying to use the GUI (Gtk) application as a dbus-service, I was getting the error "This connection was not provided by any of .service files".
I now see that the reason of it was :: I wasn't using "dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)" prior to the statement "Gtk.main()".
Now, by your helpful guidance, wherein you stated that "Gtk.main()" has the same effect as "GObject.MainLoop.run()", I added the statement "dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)" before "Gtk.main()", and voila.. now I could get a proxy object, and invoke methods remotely. Thus, two threads are now not needed.
However, it now raises a new doubt : in my second approach, wherein I used "add_to_signal_receiver" (at the server side), and dbus-send (at the client side), how come things worked now, since I did not add "dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)" in this approach at all? I presume that even in this case, dbus would need to know that the GUI application is ok to listen to dbus-signals?
Are the different requirements in these two approaches expected? Or is it an inconsistency with dbus-python?
Thanks for the extensive info; however it needs some hours (if not days :P) to be digested.
On Tue, Dec 25, 2012 at 9:24 PM, Simon McVittie <firstname.lastname@example.org> wrote:
On 24/12/12 08:26, Ajay Garg wrote:In general that is something that can work, but it's necessary to
> For a recap of the brief history, I have a parent process, that is
> spawning a child process via "subprocess".
> Currently, the child-process is a GUI process; however, I intend to
> "behave" it as a dbus-service as well.
understand a bit about how main loops work, and how the modules of your
process deal with a main loop.
Just saying "GUI" is not very informative: there are dozens of GUI
frameworks that you might be using, each with their own requirements and
oddities. If you say Gtk, or Qt, or Tk, or Windows MFC, or whatever
specific GUI framework you're using, then it becomes possible to say
something concrete about your situation.
Based on later mails in the thread you seem to be using Gtk.
I should note here that you seem to be using PyGtk (the "traditional"
Gtk 2 Python binding), which is deprecated. The modern version is to use
PyGI, the Python GObject-Introspection binding, and Gtk 3.
When using PyGI, you have a choice of two D-Bus implementations: either
GDBus (part of gi.repository.GIO), or dbus-python ("import dbus"). I
would recommend GDBus, since dbus-python is constrained by backwards
compatibility with some flawed design decisions.
However, assuming you're stuck with dbus-python:
Almost; it's not a busy-wait. GObject.mainloop.run() is the equivalent
> I then used composition, wherein another class, "RemoteListener"
> deriving from "dbus.service.Object" was made an attribute of the "main"
> class. That worked.
> However, when I do
> in the "RemoteListener"'s __init__ method, the GUI of the "main" class
> fails to load (apparently, because the "mainloop.run()" causes the
> singular, main-thread to go into busy-wait).
of this pseudocode:
while not global_default_main_context.someone_has_called_quit:
so it will loop until someone calls GObject.mainloop.quit() or
equivalent, or forever if that never happens - but as long as nothing
"interesting" happens, it will block on a poll() or select() syscall in
what my pseudocode calls wait_for_an_event(), which is the right thing
to do in event-driven programming like GLib/Gtk.
(If you replace the last line of my pseudocode with "continue", that
would be a busy-wait.)
It is unclear whether the dbus-glib main loop glue (as set up by
> I tried option b), but now instantiating "RemoteListener" in a separate
DBusGMainLoop) is thread-safe or not. The safest assumption is always
"if you don't know whether foo is thread-safe, it probably isn't". In
any case, if it *is* thread-safe, the subset of it that's exposed
through dbus-python isn't enough to use it in multiple threads.
GDBus, as made available via PyGI (specifically, gi.repository.GIO), is
known to be thread-safe.
The general answer: only if either the GUI and the D-Bus code
> Is there a way to run GUI and a dbus-service together?
run in different threads, or if they run in the same thread and can be
made to share a main context.
The specific answer for Gtk: yes, they can easily share a main context.
sets up dbus-python's mainloop integration to integrate with the global
default main-context in GLib (implementation detail: it currently uses
dbus-glib to do that). What that means is that whenever a D-Bus
connection started by dbus-python wants to listen for events on a
socket, or wait for a timeout, it will ask GLib to add those to the
global default main context as event sources.
iterates GLib's global default main context, analogous to the pseudocode
I mentioned before. Any "interesting" events that happen will cause your
code to be executed.
A typical GUI application also needs to run the main loop to
wait for events. In PyGtk, you'd typically do that with:
Gtk also uses GLib's global default main context, so this is pretty
similar to GObject.mainloop.run() - if you just remove the call to
GObject.mainloop.run() and use Gtk.main() instead, everything should be
> As per http://www.pygtk.org/pygtk2reference/class-
> gobjectmainloop.html, it seems that we must be able to add eventYes. For instance, gobject.timeout_add(), gobject.idle_add() and
> sources to gobject.mainloop
gobject.io_add_watch() all add event sources to the default main context.
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) tells dbus-python
that when it needs to add an event source to "the" main loop, it should
use equivalent C functions in GLib to do so.
(In principle, DBusGMainLoop ought to take a GObject.MainContext as an
optional argument - but that's never been implemented, and it currently
always uses the default main context, which is the same one Gtk uses,
and which should only be iterated from the main thread.)
No, that's not true; gobject.mainloop is a namespace for a set of global
> Once the event sources are added, each instance of gobject.mainloop
> (in its particular thread), will cater to only those sources.
functions, not an object. If you must use multiple threads (not
recommended), please see the GLib C API documentation for details of how
main loops and main contexts relate, then the PyGtk documentation to see
how that translates into Python.
It instantiates a new DBusGMainLoop and sets it as dbus-python's global
> How is dbus."mainloop.glib.DBusGMainLoop(set_as_default=True)"
> related to gobject.mainloop?
default main-loop-integration object. (With hindsight, DBusGMainLoop was
a poor choice of name - it should have been DBusGMainIntegration or
something.) The result is that whenever a new dbus.connection.Connection
is instantiated, it will call methods on that DBusGMainLoop to connect
its event sources up to the default GLib main context, which is the same
one used by Gtk.
dbus.bus.BusConnection, dbus.Bus, dbus.SessionBus etc. are
dbus.connection.Connection subclasses, so anything I say about
dbus.connection.Connection applies equally to them.
It instantiates a new DBusGMainLoop and doesn't use it for anything. If
> How is dbus."mainloop.glib.DBusGMainLoop(set_as_default=False)"
> related to gobject.mainloop?
you save the returned DBusGMainLoop in a variable (e.g.
my_dbus_g_main_loop = DBusGMainLoop(...)), then you can pass a keyword
argument mainloop=my_dbus_g_main_loop to a dbus.connection.Connection
constructor, and that dbus.connection.Connection will use that
DBusGMainLoop instead of dbus-python's global default. In practice, only
a very unusual application would need to do that.
There is currently no point in having more than one DBusGMainLoop; it
would become useful if dbus-glib was thread-safe, and if dbus-python
supported non-default GLib main-contexts.
Yes. Otherwise, dbus-python has no way to know that your application is
> Is it necessary at all to specify
> "mainloop.glib.DBusGMainLoop(set_as_default=True)" or
> "mainloop.glib.DBusGMainLoop(set_as_default=False)" when using
going to be iterating the GLib main loop, as opposed to Qt or Tk or
Enlightenment or something.
Yes, either dbus-python or GDBus. Each of those can do everything
> currently for the client, I am having the (client) (parent) process
> run the command "dbus-send" via the python-subprocess API.
> Does there exist a python API to do it in a cleaner manner?
dbus-send can, and more.
For a start, could you please point me to the paradigm to send a dbus-signal from the client to the server (where the server has the "add_to_signal_receiver" been set up).
From the limited googling that I did, I remember someone saying that for sending a signal, the typical setting-up-of-a-proxy-object is not required; however, I could not hit upon the exact dbus-python mechanism to send a signal :-\
dbus mailing list