Merge lp:~oubiwann/ubuntu-accomplishments-system/946850-twisted-app into lp:~jonobacon/ubuntu-accomplishments-system/trophyinfo

[Duncan McGreggor]

Okay, this branch provides a twistd daemon. The wiki will need to be updated for usage:

To run the daemon under non-development conditions (e.g., from an rc script) one needs to invoke the daemon in the following manner:

 $ twistd -y ./bin/daemon

This will write a log file and a pid file to the working directory.

From an rc script, you'd (obviously) need to give the full path and have the accomplishments code installed on the Python path for the version that the rc script would be using. Also, for an rc script, you will probably want to pass options for the pid file and log file directories, and maybe even uid/guid options.

When developing, one can use the following so that the daemon is not daemonized, but instead writes it log file to stdout:

 $ twistd -noy ./bin/daemon

Usage notes aside, this branch makes some big changes. First and foremost, it introduces a set of Twisted application services and nests them so that we can have fine-grained control over what gets started, stopped, etc., and what does it first, what depends on another thing, etc.

The second big change is the use of an asyncapi attribute to reference all the async calls. An AsyncAPI class was created to keep things straight (what calls depend upon Twisted and deferreds, and which ones don't). The intent with this move is to continue this trend with the other code (in future branches): a ConfigAPI and configapi attribute, ExtraInfoAPI and extrainfoapi attribute, etc.

The other thing to keep in mind with this branch is that it adds lots of TODOs (look for XXX comments) as inline comments and makes recommendations on refactoring a significant portion of the api.py code. In particular, all blocking calls that are going to be made in functions/methods that return deferreds should either be converted to async code that utilizes Twisted to accomplish the same thing, or be run in a thread with deferToThread. Otherwise, you will get poor (blocking) performance and not receive the benefits of Twisted.

Another big refactor that needs to happen is breaking the methods up: they are large and usually have more responsibility than they should. Several TODO comments were made that point the direction for this (e.g., "split this out into sync and share methods"),

No attempt to change any of that was done in this branch, as the focus here was simply to get a daemon created that was twistd-friendly.

[Duncan McGreggor (oubiwann)]

Oh, another note for future work: there are a bunch of pyflakes. Install pyflakes (sudo apt-get install pyflakes) and run it against the accomplishments directory. There's lots of stuff to be fixed.

Similarly with the pep8 tool.

[Jono Bacon (jonobacon)]

Thanks so much, Duncan, for taking the time to work on this. I have a few questions, bearing in mind some of my more limited Twisted knowledge.

 * It looks like I needed to set my PYTHONPATH, is this the case?
 * I see you created AsyncAPI - does this literally just put these async orientated methods into a different class for the purposes of classification/naming, or does this do anything differently?
 * It looks like each of the classes in service.py overload a set of methods in Twisted (startService, stopService etc) and then applicationFactory in app.py gets everything up and running. Is this right?
 * In the notes you say "all blocking calls that are going to be made in functions/methods that return deferreds should either be converted to async code that utilizes Twisted to accomplish the same thing, or be run in a thread with deferToThread" - I thought that by using inline callbacks (as my code does already) this was doing this the Twisted way and not blocking?

Thanks!

   Jono

[Duncan McGreggor (oubiwann)]

On Thu, Mar 22, 2012 at 1:23 PM, Jono Bacon <email address hidden> wrote:
> Thanks so much, Duncan, for taking the time to work on this. I have a few questions, bearing in mind some of my more limited Twisted knowledge.
>
>  * It looks like I needed to set my PYTHONPATH, is this the case?

I was never able to duplicate the issues you had with importing python
files from the working directory. I added a sys.path.insert(0, ".") to
hopefully overcome that for you. If that works, you should be all set.
If not, we'll have to do some trial and error to see what does work.
There should be no need to set any environment variables for this to
work, though.

>  * I see you created AsyncAPI - does this literally just put these async orientated methods into a different class for the purposes of classification/naming

Yup.

The idea is that all the different types of API calls that are mixed
in the Accomplishments class right now would be organized into their
own class and then instantiated like AsyncAPI is (e.g., self.asyncapi
= AsyncAPI()). This is simply to help with code organization,
readability, etc.

>  * It looks like each of the classes in service.py overload a set of methods in Twisted (startService, stopService etc)

It doesn't overload. It simply implements the method defined by the
interface. Each service can potentially do lots of difference things
in its startService and stopService methods -- all different from each
other, since each service is of a different type and has different
responsibilities.

This would be a good place to do any DBus main loop tweaks, if needed,
for instance.

(Btw, Python can't really do classic overloading, since a
method/function can only be defined once in the same scope. However,
you can achieve a mostly similar-seeming result with positional and
named args and a dispatch mechanism. You could also override and then
call the superclass's method, that also gets you something similar to
overloading.)

> and then applicationFactory in app.py gets everything up and running. Is this right?

Almost. applicationFactory creates an application object (with lots of
child components) and assigns that to the variable name "application"
in the .tac file. twistd loads the .tac file, looks for the
"application" variable name, loads the object stored there, and fires
of the chain of startService methods on each child object.

So it's twistd that gets everything up and running. applicationFactory
just applies the configuration to various instantiations and then
passes the application object back.

>  * In the notes you say "all blocking calls that are going to be made in functions/methods that return deferreds should either be converted to async code that utilizes Twisted to accomplish the same thing, or be run in a thread with deferToThread" - I thought that by using inline callbacks (as my code does already) this was doing this the Twisted way and not blocking?

Nope. This is one of the many pitfalls of using inlineCallbacks.

inlineCallbacks is basically a wrapper for deferreds. It doesn't
magically make code non-blocking any more than using deferreds
directly does. There's a famous saying in the Twisted community:
  http://www.f...

[Jono Bacon (jonobacon)]

Sorry for the delay, Duncan, I am still on vacation.

On 22 March 2012 15:22, Duncan McGreggor <email address hidden> wrote:
>>  * It looks like I needed to set my PYTHONPATH, is this the case?
>
> I was never able to duplicate the issues you had with importing python
> files from the working directory. I added a sys.path.insert(0, ".") to
> hopefully overcome that for you. If that works, you should be all set.
> If not, we'll have to do some trial and error to see what does work.
> There should be no need to set any environment variables for this to
> work, though.

Thanks, Duncan, I will test again soon.

>>  * I see you created AsyncAPI - does this literally just put these async orientated methods into a different class for the purposes of classification/naming
>
> Yup.
>
> The idea is that all the different types of API calls that are mixed
> in the Accomplishments class right now would be organized into their
> own class and then instantiated like AsyncAPI is (e.g., self.asyncapi
> = AsyncAPI()). This is simply to help with code organization,
> readability, etc.

Makes sense. :-)

>>  * It looks like each of the classes in service.py overload a set of methods in Twisted (startService, stopService etc)
>
> It doesn't overload. It simply implements the method defined by the
> interface. Each service can potentially do lots of difference things
> in its startService and stopService methods -- all different from each
> other, since each service is of a different type and has different
> responsibilities.
>
> This would be a good place to do any DBus main loop tweaks, if needed,
> for instance.
>
> (Btw, Python can't really do classic overloading, since a
> method/function can only be defined once in the same scope. However,
> you can achieve a mostly similar-seeming result with positional and
> named args and a dispatch mechanism. You could also override and then
> call the superclass's method, that also gets you something similar to
> overloading.)

So it looks like each of the different services are set up and each of
these are then used throughout the rest of the API (e.g. when we
run_scripts() this uses the ScriptRunner service). I guess the
startService/stopService pieces are then used to help them start and
stop in a twistd way (incorporating logging etc), right?

>> and then applicationFactory in app.py gets everything up and running. Is this right?
>
> Almost. applicationFactory creates an application object (with lots of
> child components) and assigns that to the variable name "application"
> in the .tac file. twistd loads the .tac file, looks for the
> "application" variable name, loads the object stored there, and fires
> of the chain of startService methods on each child object.

I saw mention of a .tac file in the twistd docs, but I didn't see it
in the code. Is there a file somewhere I should see?

> So it's twistd that gets everything up and running. applicationFactory
> just applies the configuration to various instantiations and then
> passes the application object back.

Gotcha. Btw, you showed me how to start a twistd service, how do I stop it?

Also, do you know if there is a good way to map twistd start/stop to
upstart ...

[Duncan McGreggor (oubiwann)]

On Mon, Mar 26, 2012 at 2:01 AM, Jono Bacon <email address hidden> wrote:
> On 22 March 2012 15:22, Duncan McGreggor <email address hidden> wrote:
>>
>>>  * It looks like each of the classes in service.py overload a set of methods in Twisted (startService, stopService etc)
>>
>> It doesn't overload. It simply implements the method defined by the
>> interface. Each service can potentially do lots of difference things
>> in its startService and stopService methods -- all different from each
>> other, since each service is of a different type and has different
>> responsibilities.
>>
>> This would be a good place to do any DBus main loop tweaks, if needed,
>> for instance.
>>
>> (Btw, Python can't really do classic overloading, since a
>> method/function can only be defined once in the same scope. However,
>> you can achieve a mostly similar-seeming result with positional and
>> named args and a dispatch mechanism. You could also override and then
>> call the superclass's method, that also gets you something similar to
>> overloading.)
>
> So it looks like each of the different services are set up and each of
> these are then used throughout the rest of the API (e.g. when we
> run_scripts() this uses the ScriptRunner service). I guess the
> startService/stopService pieces are then used to help them start and
> stop in a twistd way (incorporating logging etc), right?

Yup.

>>> and then applicationFactory in app.py gets everything up and running. Is this right?
>>
>> Almost. applicationFactory creates an application object (with lots of
>> child components) and assigns that to the variable name "application"
>> in the .tac file. twistd loads the .tac file, looks for the
>> "application" variable name, loads the object stored there, and fires
>> of the chain of startService methods on each child object.
>
> I saw mention of a .tac file in the twistd docs, but I didn't see it
> in the code. Is there a file somewhere I should see?

Sorry, I renamed it to not use an extension, since it will be used as
a daemon in a long-running process. It's still a .tac file, though.
(it's in the bin dir)

>> So it's twistd that gets everything up and running. applicationFactory
>> just applies the configuration to various instantiations and then
>> passes the application object back.
>
> Gotcha. Btw, you showed me how to start a twistd service, how do I stop it?

So when run in non-daemonized mode (for development), it's just ^C.

When run in daemon mode, it writes std out to a log file
(configurable; see twistd --help) and the PID of the process to a .pid
file (configurable; see twistd --help). Sys V init scripts typically
generate a file or shell variable themselves then later cat the pid
file when running a kill against it. You'll do the same thing here,
except the pid file has already been created for you.

> Also, do you know if there is a good way to map twistd start/stop to
> upstart start/stop events?

I've never written upstart scripts, but twistd is used in all sorts of
init/rc scripts, similarly to how I outlined above.

Jereb (another core hacker/long-time Twisted guy) did a great write-up
here for plugins:
  https://bitbucket.org/jerub/twisted-plugin-exampl...

[Jono Bacon (jonobacon)]

Thanks for your work on thus Duncan. I think I have my head around this now. I took a good look at it today and fixed the issue with trophy_received and I have just merged this in.

I might drop you a message every so often if I have further Twisted questions if that is OK. Thanks!

review: Approve

[Duncan McGreggor (oubiwann)]

On Sat, Mar 31, 2012 at 8:06 PM, Jono Bacon <email address hidden> wrote:
> Review: Approve
>
> Thanks for your work on thus Duncan. I think I have my head around this now. I took a good look at it today and fixed the issue with trophy_received and I have just merged this in.
>
> I might drop you a message every so often if I have further Twisted questions if that is OK.

You betcha!

> Thanks!

No prob, bro :-)

d

=== modified file 'accomplishments/daemon/api.py'
--- accomplishments/daemon/api.py	2012-03-18 16:56:29 +0000
+++ accomplishments/daemon/api.py	2012-03-20 03:24:21 +0000
@@ -12,7 +12,6 @@
 import gobject
 import gpgme
 import json
-import logging
 import os
 import pwd
 import subprocess
@@ -24,6 +23,7 @@
 from twisted.internet import defer, reactor
 from twisted.internet.protocol import ProcessProtocol
 from twisted.python import filepath
+from twisted.python import log
 
 import xdg.BaseDirectory
 
@@ -38,7 +38,7 @@
 import accomplishments
 from accomplishments import exceptions
 from accomplishments.daemon import dbusapi
-from accomplishments.util import get_data_file
+from accomplishments.util import get_data_file, SubprocessReturnCodeProtocol
 
 
 MATRIX_USERNAME = "openiduser155707"
@@ -46,20 +46,229 @@
 SCRIPT_DELAY = 900
 
 
-class SubprocessReturnCodeProtocol(ProcessProtocol):
-    """
-    """
-    def connectionMade(self):
-        self.returnCodeDeferred = defer.Deferred()
-
-    def processEnded(self, reason):
-        self.returnCodeDeferred.callback(reason.value.exitCode)
-
-    def outReceived(self, data):
-        print data
-
-    def errReceived(self, data):
-        print data
+# XXX the source code needs to be updated to use Twisted async calls better:
+# grep the source code for any *.asyncapi.* references, and if they return
+# deferreds, adjust them to use callbacks
+class AsyncAPI(object):
+    """
+    This class simply organizes all the Twisted calls into a single location
+    for better readability and separation of concerns.
+    """
+    def __init__(self, parent):
+        self.parent = parent
+
+    @staticmethod
+    def run_a_subprocess(command):
+        log.msg("Running subprocess command: " + str(command))
+        pprotocol = SubprocessReturnCodeProtocol()
+        reactor.spawnProcess(pprotocol, command[0], command, env=os.environ)
+        return pprotocol.returnCodeDeferred
+
+    # XXX let's rewrite this to use deferreds explicitly
+    @defer.inlineCallbacks
+    def wait_until_a_sig_file_arrives(self):
+        path, info = yield self.parent.sd.wait_for_signals(
+            signal_ok="DownloadFinished",
+            success_filter=lambda path,
+            info: path.startswith(self.trophies_path)
+            and path.endswith(".asc"))
+        log.msg("Trophy signature recieved...")
+        accomname = os.path.splitext(os.path.splitext(
+            os.path.split(path)[1])[0])[0]
+        data = self.parent.listAccomplishmentInfo(accomname)
+        iconpath = os.path.join(
+            self.parent.accomplishments_path,
+            data[0]["application"],
+            "trophyimages",
+            data[0]["icon"])
+
+        item = os.path.split(path)[1][:-11]
+        app = os.path.split(os.path.split(path)[0])[1]
+        data = self.parent.listAccomplishmentInfo(item)
+
+        if self.parent.scriptrun_total == len(self.parent.scriptrun_results):
+            self.parent.show_unlocked_accomplishments()
+
+        if self.parent.show_notifications == True and pynotify and (
+        pynotify.is_initted() or pynotify.init("icon-summary-body")):
+            self.parent.service.trophy_received("foo")
+            trophy_icon_path = "file://%s" % os.path.realpath(
+                os.path.join(
+                    os.path.split(__file__)[0],
+                    "trophy-accomplished.svg"))
+            n = pynotify.Notification(
+                "You have accomplished something!", data[0]["title"], iconpath)
+            n.show()
+
+        self.wait_until_a_sig_file_arrives()
+        #reload_trophy_corresponding_to_sig_file(path)
+
+    # XXX let's rewrite this to use deferreds explicitly
+    @defer.inlineCallbacks
+    def register_trophy_dir(self, trophydir):
+        """
+        Creates the Ubuntu One share for the trophydir and offers it to the
+        server. Returns True if the folder was successfully shared, False if
+        not.
+        """
+        timeid = str(time.time())
+        log.msg("Registering Ubuntu One share directory: " + trophydir)
+
+        folder_list = yield self.parent.sd.get_folders()
+        folder_is_synced = False
+        for folder in folder_list:
+            if folder["path"] == trophydir:
+                folder_is_synced = True
+                break
+        if not folder_is_synced:
+            # XXX let's breack this out into a separate sync'ing method
+            log.msg(
+                "...the '%s' folder is not synced with the Matrix" % trophydir)
+            log.msg("...creating the share folder on Ubuntu One")
+            self.parent.sd.create_folder(trophydir)
+
+            success_filter = lambda info: info["path"] == trophydir
+            info = yield self.parent.sd.wait_for_signals(
+                signal_ok='FolderCreated', success_filter=success_filter)
+
+            self.parent.sd.offer_share(
+                trophydir, MATRIX_USERNAME, LOCAL_USERNAME + " Trophies Folder"
+                + " (" + timeid + ")", "Modify")
+            log.msg(
+                "...share has been offered (" + trophydir + "" + ", "
+                + MATRIX_USERNAME + ", " + LOCAL_USERNAME + ")")
+            return
+
+        log.msg("...the '%s' folder is already synced" % trophydir)
+        # XXX put the following logic into a folders (plural) sharing method
+        log.msg("... now checking whether it's shared")
+        shared_list = yield self.parent.sd.list_shared()
+        folder_is_shared = False
+        shared_to = []
+        for share in shared_list:
+            # XXX let's break this out into a separate share-tracking method
+            if share["path"] == trophydir:
+                log.msg("...the folder is already shared.")
+                folder_is_shared = True
+                shared_to.append("%s (%s)" % (
+                    share["other_visible_name"], share["other_username"]))
+        if not folder_is_shared:
+            # XXX let's break this out into a separate folder-sharing method
+            log.msg("...the '%s' folder is not shared" % trophydir)
+            self.parent.sd.offer_share(
+                trophydir, MATRIX_USERNAME, LOCAL_USERNAME + " Trophies Folder"
+                + " (" + timeid + ")", "Modify")
+            log.msg("...share has been offered (" + trophydir + "" + ", "
+                + MATRIX_USERNAME + ", " + LOCAL_USERNAME + ")")
+            log.msg("...offered the share.")
+            return
+        else:
+            log.msg("The folder is shared, with: %s" % ", ".join(
+                shared_to))
+            return
+
+    # XXX let's rewrite this to use deferreds explicitly
+    @defer.inlineCallbacks
+    def run_scripts_for_user(self, uid):
+        log.msg("--- Starting Running Scripts ---")
+        timestart = time.time()
+        self.parent.service.scriptrunner_start()
+
+        # Is the user currently logged in and running a gnome session?
+        # XXX use deferToThread
+        username = pwd.getpwuid(uid).pw_name
+        try:
+            # XXX since we're using Twisted, let's use it here too and use the
+            # deferred-returning call
+            proc = subprocess.check_output(
+                ["pgrep", "-u", username, "gnome-session"]).strip()
+        except subprocess.CalledProcessError:
+            # user does not have gnome-session running or isn't logged in at
+            # all
+            log.msg("No gnome-session process for user %s" % username)
+            return
+        # XXX this is a blocking call and can't be here if we want to take
+        # advantage of deferreds; instead, rewrite this so that the blocking
+        # call occurs in a separate thread (e.g., deferToThread)
+        fp = open("/proc/%s/environ" % proc)
+        try:
+            envars = dict(
+                [line.split("=", 1) for line in fp.read().split("\0")
+                if line.strip()])
+        except IOError:
+            # user does not have gnome-session running or isn't logged in at
+            # all
+            log.msg("No gnome-session environment for user %s" % username)
+            return
+        fp.close()
+
+        # XXX use deferToThread
+        os.seteuid(uid)
+
+        required_envars = ['DBUS_SESSION_BUS_ADDRESS']
+        env = dict([kv for kv in envars.items() if kv[0] in required_envars])
+        # XXX use deferToThread
+        oldenviron = os.environ
+        os.environ.update(env)
+        # XXX note that for many of these deferredToThread changes, we can put
+        # them all in a DeferredList and once they're all done and we have the
+        # results for all of them, a callback can be fired to continue.
+
+        # XXX this next call, a DBus check, happens in the middle of this
+        # method; it would be better if this check was done at a higher level,
+        # for instance, where this class is initiated: if the daemon isn't
+        # registered at the time of instantiation, simply abort then instead of
+        # making all the way here and then aborting. (Note that moving this
+        # check to that location will also eliminate an obvious circular
+        # import.)
+        if not dbusapi.daemon_is_registered():
+            return
+
+        # XXX all parent calls should be refactored out of the AsyncAPI class
+        # to keep the code cleaner and the logic more limited to one particular
+        # task
+        accoms = self.parent.listAllAvailableAccomplishmentsWithScripts()
+        totalscripts = len(accoms)
+        self.parent.scriptrun_total = totalscripts
+        log.msg("Need to run (%d) scripts" % totalscripts)
+
+        scriptcount = 1
+        for accom in accoms:
+            msg = "%s/%s: %s" % (scriptcount, totalscripts, accom["_script"])
+            log.msg(msg)
+            exitcode = yield self.run_a_subprocess([accom["_script"]])
+            if exitcode == 0:
+                self.parent.scriptrun_results.append(
+                    str(accom["application"]) + "/"
+                    + str(accom["accomplishment"]))
+                self.parent.accomplish(
+                    accom["application"], accom["accomplishment"])
+                log.msg("...Accomplished")
+            elif exitcode == 1:
+                self.parent.scriptrun_results.append(None)
+                log.msg("...Not Accomplished")
+            elif exitcode == 2:
+                self.parent.scriptrun_results.append(None)
+                log.msg("....Error")
+            elif exitcode == 4:
+                self.parent.scriptrun_results.append(None)
+                log.msg("...Could not get launchpad email")
+            else:
+                self.parent.scriptrun_results.append(None)
+                log.msg("...Error code %d" % exitcode)
+            scriptcount = scriptcount + 1
+
+        os.environ = oldenviron
+
+        # XXX eventually the code in this method will be rewritten using
+        # deferreds; as such, we're going to have to be more clever regarding
+        # timing things...
+        timeend = time.time()
+        timefinal = round((timeend - timestart), 2)
+
+        log.msg(
+            "--- Completed Running Scripts in %.2f seconds---" % timefinal)
+        self.parent.service.scriptrunner_finish()
 
 
 class Accomplishments(object):
@@ -82,9 +291,9 @@
         self.scriptrun_results = []
         self.depends = []
         self.processing_unlocked = False
+        self.asyncapi = AsyncAPI(self)
 
         # create config / data dirs if they don't exist
-
         self.dir_config = os.path.join(
             xdg.BaseDirectory.xdg_config_home, "accomplishments")
         self.dir_data = os.path.join(
@@ -101,73 +310,26 @@
         if not os.path.exists(self.dir_cache):
             os.makedirs(self.dir_cache)
 
-        # set up logging
-        logdir = os.path.join(self.dir_cache, "logs")
-
-        if not os.path.exists(logdir):
-            os.makedirs(logdir)
-
-        #self.logging = logging
-        logging.basicConfig(
-            filename=(os.path.join(logdir, 'daemon.log')), level=logging.INFO)
-
-        now = datetime.datetime.now()
-        logging.info(
+        log.msg(
             "------------------- Ubuntu Accomplishments Daemon Log - %s "
-            "-------------------", str(now))
+            "-------------------", str(datetime.datetime.now()))
 
         self._loadConfigFile()
 
-        print "Accomplishments path: " + self.accomplishments_path
-        print "Scripts path: " + self.scripts_path
-        print "Trophies path: " + self.trophies_path
+        log.msg("Accomplishments path: " + self.accomplishments_path)
+        log.msg("Scripts path: " + self.scripts_path)
+        log.msg("Trophies path: " + self.trophies_path)
 
         self.show_notifications = show_notifications
-        logging.info("Connecting to Ubuntu One")
+        log.msg("Connecting to Ubuntu One")
         self.sd = SyncDaemonTool()
 
-        self.wait_until_a_sig_file_arrives()
+        # XXX this wait-until thing should go away; it should be replaced by a
+        # deferred-returning function that has a callback which fires off
+        # generate_all_trophis and schedule_run_scripts...
+        self.asyncapi.wait_until_a_sig_file_arrives()
         self.generate_all_trophies()
 
-        reactor.callLater(5, self.run_scripts, False)
-
-    @defer.inlineCallbacks
-    def wait_until_a_sig_file_arrives(self):
-        path, info = yield self.sd.wait_for_signals(
-            signal_ok="DownloadFinished",
-            success_filter=lambda path,
-            info: path.startswith(self.trophies_path)
-            and path.endswith(".asc"))
-        logging.info("Trophy signature recieved...")
-        accomname = os.path.splitext(os.path.splitext(
-            os.path.split(path)[1])[0])[0]
-        data = self.listAccomplishmentInfo(accomname)
-        iconpath = os.path.join(
-            self.accomplishments_path,
-            data[0]["application"],
-            "trophyimages",
-            data[0]["icon"])
-
-        item = os.path.split(path)[1][:-11]
-        app = os.path.split(os.path.split(path)[0])[1]
-        data = self.listAccomplishmentInfo(item)
-
-        if self.scriptrun_total == len(self.scriptrun_results):
-            self.show_unlocked_accomplishments()
-
-        if self.show_notifications == True and pynotify and (
-        pynotify.is_initted() or pynotify.init("icon-summary-body")):
-            self.service.trophy_received("foo")
-            trophy_icon_path = "file://%s" % os.path.realpath(
-                os.path.join(
-                    os.path.split(__file__)[0],
-                    "trophy-accomplished.svg"))
-            n = pynotify.Notification(
-                "You have accomplished something!", data[0]["title"], iconpath)
-            n.show()
-
-        self.wait_until_a_sig_file_arrives()
-        #reload_trophy_corresponding_to_sig_file(path)
 
     def get_media_file(self, media_file_name):
         media_filename = get_data_file('media', '%s' % (media_file_name,))
@@ -210,14 +372,14 @@
         self.depends = []
 
     def _get_accomplishments_files_list(self):
-        logging.info("Looking for accomplishments files in "
+        log.msg("Looking for accomplishments files in "
                      + self.accomplishments_path)
         accom_files = os.path.join(self.accomplishments_path,
             "*", "*.accomplishment")
         return glob.glob(accom_files)
 
     def _load_accomplishment_file(self, f):
-        logging.info("Loading accomplishments file: " + f)
+        log.msg("Loading accomplishments file: " + f)
         config = ConfigParser.RawConfigParser()
         config.read(f)
         data = dict(config._sections["accomplishment"])
@@ -232,7 +394,7 @@
         Returns True for valid or False for invalid (missing file, bad sig
         etc).
         """
-        logging.info("Validate trophy: " + str(filename))
+        log.msg("Validate trophy: " + str(filename))
 
         if os.path.exists(filename):
             # the .asc signed file exists, so let's verify that it is correctly
@@ -246,24 +408,24 @@
             sig = c.verify(signed, None, plaintext)
 
             if len(sig) != 1:
-                logging.info("...No Sig")
+                log.msg("...No Sig")
                 return False
 
             if sig[0].status is not None:
-                logging.info("...Bad Sig")
+                log.msg("...Bad Sig")
                 return False
             else:
                 result = {'timestamp': sig[0].timestamp, 'signer': sig[0].fpr}
-                logging.info("...Verified!")
+                log.msg("...Verified!")
                 return True
         else:
-            logging.info(".asc does not exist for this trophy")
+            log.msg(".asc does not exist for this trophy")
             return False
 
-        logging.info("Verifying trophy signature")
+        log.msg("Verifying trophy signature")
 
     def _load_trophy_file(self, f):
-        logging.info("Load trophy file: " + f)
+        log.msg("Load trophy file: " + f)
         config = ConfigParser.RawConfigParser()
         config.read(f)
         data = dict(config._sections["trophy"])
@@ -272,7 +434,7 @@
         return data
 
     def listAllAccomplishments(self):
-        logging.info("List all accomplishments")
+        log.msg("List all accomplishments")
         fs = [self._load_accomplishment_file(f) for f in
             self._get_accomplishments_files_list()]
         return fs
@@ -351,32 +513,32 @@
                     img = Image.composite(layer, reduced, layer)
                     img.save(filecore + "-locked" + filetype)
                 except Exception, (msg):
-                    print msg
+                    log.msg(msg)
 
     def verifyU1Account(self):
         # check if this machine has an Ubuntu One account
-        logging.info("Check if this machine has an Ubuntu One account...")
+        log.msg("Check if this machine has an Ubuntu One account...")
         u1auth_response = auth.request(
             url='https://one.ubuntu.com/api/account/')
         u1email = None
         if not isinstance(u1auth_response, basestring):
             u1email = json.loads(u1auth_response[1])['email']
         else:
-            logging.info("No Ubuntu One account is configured.")
+            log.msg("No Ubuntu One account is configured.")
 
         if u1email is None:
-            logging.info("...No.")
-            logging.info(u1auth_response)
+            log.msg("...No.")
+            log.msg(u1auth_response)
             self.has_u1 = False
             return False
         else:
-            logging.info("...Yes.")
+            log.msg("...Yes.")
             self.has_u1 = True
             return True
 
     def getConfigValue(self, section, item):
         """Return a configuration value from the .accomplishments file"""
-        logging.info(
+        log.msg(
             "Returning configuration values for: %s, %s", section, item)
         homedir = os.getenv("HOME")
         config = ConfigParser.RawConfigParser()
@@ -395,7 +557,7 @@
 
     def setConfigValue(self, section, item, value):
         """Set a configuration value in the .accomplishments file"""
-        logging.info(
+        log.msg(
             "Set configuration file value in '%s': %s = %s", section, item,
             value)
         homedir = os.getenv("HOME")
@@ -415,7 +577,7 @@
         self._loadConfigFile()
 
     def _writeConfigFile(self):
-        logging.info("Writing the configuration file")
+        log.msg("Writing the configuration file")
         homedir = os.getenv("HOME")
         config = ConfigParser.RawConfigParser()
         cfile = self.dir_config + "/.accomplishments"
@@ -433,10 +595,10 @@
 
         self.accomplishments_path = os.path.join(
             self.accomplishments_path, "accomplishments")
-        logging.info("...done.")
+        log.msg("...done.")
 
     def accomplish(self, app, accomplishment_name):
-        logging.info(
+        log.msg(
             "Accomplishing something: %s, %s", app, accomplishment_name)
         accom_file = os.path.join(self.accomplishments_path, app,
             "%s.accomplishment" % accomplishment_name)
@@ -481,9 +643,9 @@
         cp.write(fp)
         fp.close()
 
-        if not data["needs-signing"] or data["needs-signing"] == False:
-            self.trophy_received()
-            if self.show_notifications == True and pynotify and (
+        if not data["needs-signing"] or data["needs-signing"] is False:
+            self.service.trophy_received()
+            if self.show_notifications is True and pynotify and (
             pynotify.is_initted() or pynotify.init("icon-summary-body")):
                 trophy_icon_path = "file://%s" % os.path.realpath(
                     os.path.join(
@@ -507,19 +669,19 @@
             self.has_u1 = True
 
         if config.read(cfile):
-            logging.info("Loading configuration file: " + cfile)
+            log.msg("Loading configuration file: " + cfile)
             if config.get('config', 'accompath'):
                 self.accomplishments_path = os.path.join(
                     config.get('config', 'accompath'), "accomplishments/")
-                logging.info(
+                log.msg(
                     "...setting accomplishments path to: "
                     + self.accomplishments_path)
                 self.scripts_path = os.path.split(
                     os.path.split(self.accomplishments_path)[0])[0] + "/scripts"
-                logging.info(
+                log.msg(
                     "...setting scripts path to: " + self.scripts_path)
             if config.get('config', 'trophypath'):
-                logging.info(
+                log.msg(
                     "...setting trophies path to: "
                     + config.get('config', 'trophypath'))
                 self.trophies_path = config.get('config', 'trophypath')
@@ -529,84 +691,23 @@
                 self.has_verif = config.getboolean('config', 'has_verif')
         else:
             accompath = os.path.join(homedir, "accomplishments")
-            logging.info("Configuration file not found...creating it!")
-            print "Configuration file not found...creating it!"
+            log.msg("Configuration file not found...creating it!")
 
             self.has_verif = False
             self.accomplishments_path = accompath
-            logging.info(
+            log.msg(
                 "...setting accomplishments path to: "
                 + self.accomplishments_path)
             self.trophies_path = os.path.join(self.dir_data, "trophies")
-            logging.info("...setting trophies path to: " + self.trophies_path)
+            log.msg("...setting trophies path to: " + self.trophies_path)
             self.scripts_path = os.path.join(accompath, "scripts")
-            logging.info("...setting scripts path to: " + self.scripts_path)
+            log.msg("...setting scripts path to: " + self.scripts_path)
 
             if not os.path.exists(self.trophies_path):
                 os.makedirs(self.trophies_path)
 
             self._writeConfigFile()
 
-    @defer.inlineCallbacks
-    def registerTrophyDir(self, trophydir):
-        """
-        Creates the Ubuntu One share for the trophydir and offers it to the
-        server. Returns True if the folder was successfully shared, False if
-        not.
-        """
-        timeid = str(time.time())
-        logging.info("Registering Ubuntu One share directory: " + trophydir)
-
-        folder_list = yield self.sd.get_folders()
-        folder_is_synced = False
-        for folder in folder_list:
-            if folder["path"] == trophydir:
-                folder_is_synced = True
-                break
-        if not folder_is_synced:
-            logging.info(
-                "...the '%s' folder is not synced with the Matrix" % trophydir)
-            logging.info("...creating the share folder on Ubuntu One")
-            self.sd.create_folder(trophydir)
-
-            success_filter = lambda info: info["path"] == trophydir
-            info = yield self.sd.wait_for_signals(
-                signal_ok='FolderCreated', success_filter=success_filter)
-
-            self.sd.offer_share(
-                trophydir, MATRIX_USERNAME, LOCAL_USERNAME + " Trophies Folder"
-                + " (" + timeid + ")", "Modify")
-            logging.info(
-                "...share has been offered (" + trophydir + "" + ", "
-                + MATRIX_USERNAME + ", " + LOCAL_USERNAME + ")")
-            return
-
-        logging.info(
-            "...the '%s' folder is already synced... now checking whether "
-            "it's shared" % trophydir)
-        shared_list = yield self.sd.list_shared()
-        folder_is_shared = False
-        shared_to = []
-        for share in shared_list:
-            if share["path"] == trophydir:
-                logging.info("...the folder is already shared.")
-                folder_is_shared = True
-                shared_to.append("%s (%s)" % (
-                    share["other_visible_name"], share["other_username"]))
-        if not folder_is_shared:
-            logging.info("...the '%s' folder is not shared" % trophydir)
-            self.sd.offer_share(
-                trophydir, MATRIX_USERNAME, LOCAL_USERNAME + " Trophies Folder"
-                + " (" + timeid + ")", "Modify")
-            logging.info("...share has been offered (" + trophydir + "" + ", "
-                + MATRIX_USERNAME + ", " + LOCAL_USERNAME + ")")
-            logging.info("...offered the share.")
-            return
-        else:
-            logging.info("The folder is shared, with: %s" % ", ".join(
-                shared_to))
-            return
-
     def getAllExtraInformationRequired(self):
         """
         Return a dictionary of all information required for the accomplishments
@@ -664,7 +765,7 @@
         else:
             getdepends = False
 
-        logging.info("List all accomplishments and status")
+        log.msg("List all accomplishments and status")
         accomplishments_files = self._get_accomplishments_files_list()
         things = {}
         for accomplishment_file in accomplishments_files:
@@ -748,7 +849,7 @@
         return things.values()
 
     def listAllAvailableAccomplishmentsWithScripts(self):
-        logging.info("List all accomplishments with scripts")
+        log.msg("List all accomplishments with scripts")
         available = [accom for accom in self.listAllAccomplishmentsAndStatus()
             if not accom["accomplished"] and not accom["locked"]]
         withscripts = []
@@ -764,7 +865,7 @@
         return withscripts
 
     def listAccomplishmentInfo(self, accomplishment):
-        logging.info("Getting accomplishment info for " + accomplishment)
+        log.msg("Getting accomplishment info for " + accomplishment)
         search = "/" + accomplishment + ".accomplishment"
         files = self._get_accomplishments_files_list()
         match = None
@@ -780,119 +881,23 @@
         data.append(dict(config._sections["accomplishment"]))
         return data
 
-    @defer.inlineCallbacks
-    def run_scripts_for_user(self, uid):
-        print "--- Starting Running Scripts ---"
-        logging.info("--- Starting Running Scripts ---")
-        timestart = time.time()
-        self.service.scriptrunner_start()
-
-        # Is the user currently logged in and running a gnome session?
-        username = pwd.getpwuid(uid).pw_name
-        try:
-            proc = subprocess.check_output(
-                ["pgrep", "-u", username, "gnome-session"]).strip()
-        except subprocess.CalledProcessError:
-            # user does not have gnome-session running or isn't logged in at
-            # all
-            logging.info("No gnome-session process for user %s" % username)
-            return
-        fp = open("/proc/%s/environ" % proc)
-        try:
-            envars = dict(
-                [line.split("=", 1) for line in fp.read().split("\0")
-                if line.strip()])
-        except IOError:
-            # user does not have gnome-session running or isn't logged in at
-            # all
-            logging.info("No gnome-session environment for user %s" % username)
-            return
-        fp.close()
-
-        os.seteuid(uid)
-
-        required_envars = ['DBUS_SESSION_BUS_ADDRESS']
-        env = dict([kv for kv in envars.items() if kv[0] in required_envars])
-        oldenviron = os.environ
-        os.environ.update(env)
-        # XXX this DBUS check happens in the middle of this method; it would be
-        # better if this check was done at a higher level, for instance, where
-        # this class is initiated: if the daemon isn't registered at the time
-        # of instantiation, simply abort then instead of making all the way
-        # here and then aborting. (Note that moving this check to that location
-        # will also eliminate an obvious circular import.)
-        if not dbusapi.daemon_is_registered():
-            return
-
-        accoms = self.listAllAvailableAccomplishmentsWithScripts()
-        totalscripts = len(accoms)
-        self.scriptrun_total = totalscripts
-        logging.info("Need to run (%d) scripts" % totalscripts)
-        print "Need to run (%d) scripts" % totalscripts
-
-        scriptcount = 1
-        for accom in accoms:
-            msg = "%s/%s: %s" % (scriptcount, totalscripts, accom["_script"])
-            print msg
-            logging.info(msg)
-            exitcode = yield self.run_a_subprocess([accom["_script"]])
-            if exitcode == 0:
-                self.scriptrun_results.append(
-                    str(accom["application"]) + "/"
-                    + str(accom["accomplishment"]))
-                self.accomplish(accom["application"], accom["accomplishment"])
-                print "...Accomplished"
-                logging.info("...Accomplished")
-            elif exitcode == 1:
-                self.scriptrun_results.append(None)
-                print "...Not Accomplished"
-                logging.info("...Not Accomplished")
-            elif exitcode == 2:
-                self.scriptrun_results.append(None)
-                print "...Error"
-                logging.info("....Error")
-            else:
-                self.scriptrun_results.append(None)
-                print "...Other error code."
-                logging.info("...Other error code")
-            scriptcount = scriptcount + 1
-
-        os.environ = oldenviron
-
-        timeend = time.time()
-        timefinal = round((timeend - timestart), 2)
-
-        print "--- Completed Running Scripts in %.2f seconds ---" % timefinal
-        logging.info(
-            "--- Completed Running Scripts in %.2f seconds---" % timefinal)
-        self.service.scriptrunner_finish()
-
-    def run_a_subprocess(self, command):
-        logging.info("Running subprocess command: " + str(command))
-        pprotocol = SubprocessReturnCodeProtocol()
-        reactor.spawnProcess(pprotocol, command[0], command, env=os.environ)
-        return pprotocol.returnCodeDeferred
-
     def run_scripts_for_all_active_users(self):
         for uid in [x.pw_uid for x in pwd.getpwall()
             if x.pw_dir.startswith('/home/') and x.pw_shell != '/bin/false']:
             os.seteuid(0)
-            self.run_scripts_for_user(uid)
+            self.asyncapi.run_scripts_for_user(uid)
 
     def run_scripts(self, run_by_client):
         uid = os.getuid()
         if uid == 0:
-            logging.info("Run scripts for all active users")
+            log.msg("Run scripts for all active users")
             self.run_scripts_for_all_active_users()
         else:
-            logging.info("Run scripts for user")
-            self.run_scripts_for_user(uid)
-
-        if run_by_client is False:
-            reactor.callLater(SCRIPT_DELAY, self.run_scripts, False)
+            log.msg("Run scripts for user")
+            self.asyncapi.run_scripts_for_user(uid)
 
     def createExtraInformationFile(self, app, item, data):
-        logging.info(
+        log.msg(
             "Creating Extra Information file: %s, %s, %s", app, item, data)
         extrainfodir = os.path.join(self.trophies_path, ".extrainformation/")
 
@@ -906,7 +911,6 @@
             f.write(data)
             f.close()
 
-
     def getExtraInformation(self, app, item):
         extrainfopath = os.path.join(self.trophies_path, ".extrainformation/")
         authfile = os.path.join(extrainfopath, item)
@@ -918,10 +922,3 @@
             #print "No data."
             final = [{item : False}]
         return final
-
-
-    # XXX once the other reference to dbusapi is removed from this file, this
-    # will be the last one. It doesn't really belong here... we can set a whole
-    # slew of dbus api calls on this object when it is instantiated, thus
-    # alleviating us from the burden of a hack like this below
-    trophy_received = dbusapi.DBUSSignals.trophy_received

=== modified file 'accomplishments/daemon/app.py'
--- accomplishments/daemon/app.py	2012-03-18 16:56:29 +0000
+++ accomplishments/daemon/app.py	2012-03-20 03:24:21 +0000
@@ -1,13 +1,15 @@
 from optparse import OptionParser
 
-from twisted.internet import glib2reactor
-glib2reactor.install()
-from twisted.internet import reactor
+from twisted.application.internet import TimerService
+from twisted.application.service import Application
 
 from accomplishments.daemon import dbusapi
-
-
-if __name__ == "__main__":
+from accomplishments.daemon import service
+
+
+# XXX these won't work with twistd; we need to write a twistd plugin to support
+# additional command line options.
+def parse_options():
     parser = OptionParser()
     parser.set_defaults(suppress_notifications=False)
     parser.add_option("--trophies-path", dest="trophies_path", default=None)
@@ -16,8 +18,31 @@
     parser.add_option("--scripts-path", dest="scripts_path", default=None)
     parser.add_option("--suppress-notifications", action="store_true",
                       dest="suppress_notifications")
-    options, args = parser.parse_args()
-
-    service = dbusapi.AccomplishmentsService(
-        show_notifications=not options.suppress_notifications)
-    reactor.run()
+    return parser.parse_args()
+
+
+def applicationFactory(app_name="", bus_name="", main_loop=None,
+                       session_bus=None, object_path="/", update_interval=3600,
+                       gpg_key=""):
+    # create the application object
+    application = Application(app_name)
+    # create the top-level service object that will contain all others; it will
+    # not shutdown until all child services have been terminated
+    top_level_service = service.AccomplishmentsDaemonService(gpg_key)
+    top_level_service.setServiceParent(application)
+    # create the service that all DBus services will rely upon (this parent
+    # service will wait until child DBus services are shutdown before it shuts
+    # down
+    dbus_service = service.DBusService(main_loop, session_bus)
+    dbus_service.setServiceParent(top_level_service)
+    # create a child dbus serivce
+    dbus_export_service = dbusapi.AccomplishmentsDBusService(
+        bus_name, session_bus, object_path=object_path,
+        show_notifications=False)
+    dbus_export_service.setServiceParent(dbus_service)
+    # create a service that will run the scripts at a regular interval
+    timer_service = service.ScriptRunnerService(
+        update_interval, dbus_export_service.api)
+    timer_service.setServiceParent(top_level_service)
+
+    return application

=== modified file 'accomplishments/daemon/dbusapi.py'
--- accomplishments/daemon/dbusapi.py	2012-03-18 16:56:29 +0000
+++ accomplishments/daemon/dbusapi.py	2012-03-20 03:24:21 +0000
@@ -3,11 +3,10 @@
 # GObject-introspection-capable C thing so anyone can use it. But someone else
 # needs to write that because I'm crap at Vala.
 import dbus
-import dbus.service
-from dbus.mainloop.glib import DBusGMainLoop
-
-
-DBusGMainLoop(set_as_default=True)
+
+from twisted.python import log
+
+from accomplishments.daemon import service
 
 
 def daemon_is_registered():
@@ -18,7 +17,7 @@
             "org.ubuntu.accomplishments", "/")
         return True
     except dbus.exceptions.DBusException:
-        logging.info(
+        log.msg(
             "User %s does not have the accomplishments daemon "
             "available" % username)
         return False
@@ -26,6 +25,17 @@
 
 # XXX as a function, this needs to be renamed to a lower-case function name and
 # not use the class naming convention of upper-case.
+# 
+# Hrm, on second thought... this is:
+#  * a singleton object (SessionBus)
+#  * obtaining an object indicated by string constants
+#  * and then doing a lookup on these
+# In other words, nothing changes ;-)
+#
+# As such, there's no need for this to be a function; instead, we can set our
+# own module-level singleton, perhaps as part of the AccomplishmentsDBusService
+# set up, since that object has access to all the configuration used here (bus
+# name and bus path).
 def Accomplishments():
     """
     """
@@ -33,23 +43,14 @@
     return dbus.Interface(obj, "org.ubuntu.accomplishments")
 
 
-class DBUSSignals(object):
-    """
-    """
-    @staticmethod
-    @dbus.service.signal(dbus_interface='org.ubuntu.accomplishments')
-    def trophy_received(self, trophy):
-        t = "mytrophy"
-        return t
-
-
-class AccomplishmentsService(dbus.service.Object):
-    """
-    """
-    def __init__(self, show_notifications=True):
-        bus_name = dbus.service.BusName(
-            'org.ubuntu.accomplishments', bus=dbus.SessionBus())
-        dbus.service.Object.__init__(self, bus_name, '/')
+class AccomplishmentsDBusService(service.DBusExportService):
+    """
+    """
+    def __init__(self, bus_name, session_bus, object_path="/", 
+                 show_notifications=True):
+        super(AccomplishmentsDBusService, self).__init__(bus_name, session_bus)
+        bus_name = dbus.service.BusName(bus_name, bus=session_bus)
+        dbus.service.Object.__init__(self, bus_name, object_path)
         self.show_notifications = show_notifications
         # XXX until all the imports are cleaned up and the code is organized
         # properly, we're doing the import here (to avoid circular imports).
@@ -57,76 +58,83 @@
         # this is not a subclass of dbus.service.Object *and* Accomplishments
         # because doing that confuses everything, so we create our own
         # private Accomplishments object and use it.
-        self.ad = api.Accomplishments(self, self.show_notifications)
+        self.api = api.Accomplishments(self, self.show_notifications)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def listAllAccomplishments(self):
-        return self.ad.listAllAccomplishments()
+        return self.api.listAllAccomplishments()
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def listAllAccomplishmentsAndStatus(self):
-        return self.ad.listAllAccomplishmentsAndStatus()
+        return self.api.listAllAccomplishmentsAndStatus()
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def listAllAvailableAccomplishmentsWithScripts(self):
-        return self.ad.listAllAvailableAccomplishmentsWithScripts()
+        return self.api.listAllAvailableAccomplishmentsWithScripts()
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def getAllExtraInformationRequired(self):
-        return self.ad.getAllExtraInformationRequired()
+        return self.api.getAllExtraInformationRequired()
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def listAccomplishmentInfo(self, accomplishment):
-        return self.ad.listAccomplishmentInfo(accomplishment)
+        return self.api.listAccomplishmentInfo(accomplishment)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="b", out_signature="")
     def run_scripts(self, run_by_client):
-        return self.ad.run_scripts(run_by_client)
+        return self.api.run_scripts(run_by_client)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="aa{sv}")
     def getExtraInformation(self, app, info):
-        return self.ad.getExtraInformation(app, info)
+        return self.api.getExtraInformation(app, info)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="")
     def createExtraInformationFile(self, app, item, data):
-        return self.ad.createExtraInformationFile(app, item, data)
+        return self.api.createExtraInformationFile(app, item, data)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="ss", out_signature="")
     def accomplish(self, app, accomplishment_name):
-        trophy = self.ad.accomplish(app, accomplishment_name)
+        trophy = self.api.accomplish(app, accomplishment_name)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="s", out_signature="b")
-    def registerTrophyDir(self, trophydir):
-        return self.ad.registerTrophyDir(trophydir)
+    def register_trophy_dir(self, trophydir):
+        return self.api.async.register_trophy_dir(trophydir)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="vv", out_signature="v")
     def getConfigValue(self, section, item):
-        return self.ad.getConfigValue(section, item)
+        return self.api.getConfigValue(section, item)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="vvv", out_signature="")
     def setConfigValue(self, section, item, value):
-        return self.ad.setConfigValue(section, item, value)
+        return self.api.setConfigValue(section, item, value)
 
     @dbus.service.method(dbus_interface='org.ubuntu.accomplishments',
         in_signature="", out_signature="b")
     def verifyU1Account(self):
-        return self.ad.verifyU1Account()
+        return self.api.verifyU1Account()
 
+    # XXX this looks like an unintentional duplicate of the "other"
+    # trophy_received... I've moved them here together so that someone in the
+    # know (Jono?) can clarify and remove the one that's not needed
     @dbus.service.signal(dbus_interface='org.ubuntu.accomplishments')
     def trophy_received(self, trophy):
         pass
+    @dbus.service.signal(dbus_interface='org.ubuntu.accomplishments')
+    def trophy_received(trophy):
+        t = "mytrophy"
+        return t
 
     @dbus.service.signal(dbus_interface='org.ubuntu.accomplishments')
     def scriptrunner_start(self):

=== added file 'accomplishments/daemon/service.py'
--- accomplishments/daemon/service.py	1970-01-01 00:00:00 +0000
+++ accomplishments/daemon/service.py	2012-03-20 03:24:21 +0000
@@ -0,0 +1,80 @@
+from twisted.application.internet import TimerService
+from twisted.application.service import MultiService
+from twisted.application.service import Service
+from twisted.python import log
+
+import dbus.service
+
+from accomplishments import util
+
+
+class AccomplishmentsDaemonService(MultiService):
+    """
+    The top-level service that all other services should set as their parent.
+    """
+    def __init__(self, gpg_pub_key):
+        MultiService.__init__(self)
+        self.gpg_key = gpg_pub_key
+
+    def startService(self):
+        log.msg("Starting up accomplishments daemon ...")
+        util.import_gpg_key(self.gpg_key)
+        MultiService.startService(self)
+
+    def stopService(self):
+        log.msg("Shutting down accomplishments daemon ...")
+        return MultiService.stopService(self)
+
+
+class DBusService(MultiService):
+    """
+    A Twisted application service that tracks the DBus mainloop and the DBus
+    session bus.
+    """
+    def __init__(self, main_loop, session_bus):
+        MultiService.__init__(self)
+        self.main_loop = main_loop
+        self.session_bus = session_bus
+
+    def startService(self):
+        log.msg("Starting up DBus service ...")
+        return MultiService.startService(self)
+
+    def stopService(self):
+        log.msg("Shutting down DBus service ...")
+        return MultiService.stopService(self)
+
+
+class DBusExportService(Service, dbus.service.Object):
+    """
+    A base class that is both a Twisted application service as well as a means
+    for exporting custom objects across a given bus.
+    """
+    def __init__(self, bus_name, session_bus):
+        self.bus_name = bus_name
+        self.session_bus = session_bus
+
+    def startService(self):
+        log.msg("Starting up API exporter service ...")
+        return Service.startService(self)
+
+    def stopService(self):
+        log.msg("Shutting down API exporter service ...")
+        return Service.stopService(self)
+
+
+class ScriptRunnerService(TimerService):
+    """
+    A simple wrapper for the TimerService that runs the scripts at the given
+    intertal.
+    """
+    def __init__(self, interval, api):
+        TimerService.__init__(self, interval, api.run_scripts, False)
+
+    def startService(self):
+        log.msg("Starting up script runner service ...")
+        return TimerService.startService(self)
+
+    def stopService(self):
+        log.msg("Shutting down script runner service ...")
+        return TimerService.stopService(self)

=== modified file 'accomplishments/gui/TrophyinfoWindow.py'
--- accomplishments/gui/TrophyinfoWindow.py	2012-03-12 16:53:31 +0000
+++ accomplishments/gui/TrophyinfoWindow.py	2012-03-20 03:24:21 +0000
@@ -233,7 +233,7 @@
         self.has_verif = True
         self.libaccom.setConfigValue("config", "has_verif", True)
 
-        res = self.libaccom.registerTrophyDir(trophydir)
+        res = self.libaccom.asyncapi.register_trophy_dir(trophydir)
 
         if res == 1:
             self.u1_button.set_label("Successfully shared. Click here to continue...")

=== modified file 'accomplishments/util/__init__.py'
--- accomplishments/util/__init__.py	2012-03-05 03:49:28 +0000
+++ accomplishments/util/__init__.py	2012-03-20 03:24:21 +0000
@@ -5,6 +5,11 @@
 import gettext
 from gettext import gettext as _
 
+from twisted.internet import defer
+from twisted.internet import protocol
+from twisted.internet import reactor
+from twisted.python import log
+
 import accomplishments
 from accomplishments import config
 from accomplishments import exceptions
@@ -43,7 +48,7 @@
         logger.setLevel(logging.DEBUG)
         logger.debug('logging enabled')
     if opts.verbose > 1:
-        lib_logger.setLevel(logging.DEBUG)
+        logger.setLevel(logging.DEBUG)
 
 
 def get_data_path():
@@ -86,3 +91,34 @@
         help=_("Clear your trophies collection"))
     (options, args) = parser.parse_args()
     return options
+
+
+class SubprocessReturnCodeProtocol(protocol.ProcessProtocol):
+    """
+    """
+    def __init__(self, command=""):
+        self.command = command
+
+    def connectionMade(self):
+        self.returnCodeDeferred = defer.Deferred()
+
+    def processEnded(self, reason):
+        self.returnCodeDeferred.callback(reason.value.exitCode)
+
+    def outReceived(self, data):
+        log.msg("Got process results: %s" % data)
+
+    def errReceived(self, data):
+        log.err("Got non-zero exit code for process: %s" % (
+            " ".join(self.command),))
+        log.msg(data)
+
+
+def import_gpg_key(pub_key):
+    """
+    """
+    cmd = ["gpg", "--import", pub_key]
+    gpg = SubprocessReturnCodeProtocol(cmd)
+    gpg.deferred = defer.Deferred()
+    process = reactor.spawnProcess(gpg, cmd[0], cmd, env=None)
+    return gpg.deferred

=== renamed file 'bin/rundaemon.sh' => 'bin/daemon'
--- bin/rundaemon.sh	2012-03-05 03:51:41 +0000
+++ bin/daemon	2012-03-20 03:24:21 +0000
@@ -1,15 +1,28 @@
-#!/bin/bash
-
-#D="../../"
-export PYTHONPATH=$PYTHONPATH:.
-
-echo Importing the validation key...
-gpg --import ./data/daemon/validation-key.pub
-
-echo Starting the accomplishments daemon...
-echo "(this would be done by D-Bus activation in the real world)"
-
-python ./accomplishments/daemon/app.py
-DAEMON=$!
-
-
+#!/usr/bin/twistd
+"""
+Run the Accomplishments daemon!
+"""
+import sys
+
+from twisted.internet import glib2reactor
+glib2reactor.install()
+
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+
+from accomplishments.daemon import app
+
+
+# PYTHONPATH mangling
+sys.path.insert(0, ".")
+
+dbus_loop = DBusGMainLoop(set_as_default=True)
+application = app.applicationFactory(
+    app_name="Ubuntu Accomplishments",
+    bus_name="org.ubuntu.accomplishments",
+    main_loop=dbus_loop,
+    session_bus=dbus.SessionBus(mainloop=dbus_loop),
+    object_path="/",
+    # Let's execute the timer service every 15 minutes
+    update_interval=15 * 60,
+    gpg_key="./data/daemon/validation-key.pub")