Merge lp:~jderose/dmedia/dbus3 into lp:dmedia

[Jason Gerard DeRose]

The actual porting to python3-dbus was tiny, but then I also had to merge everything into a single real service, which is what most of the change is.

I also did a bit of cleanup and refinement:

1. Renamed DBus bus name from 'org.freedesktop.DMedia' to 'org.freedesktop.Dmedia' to be consistent with the way we now write 'Dmedia'

2. Moved Avahi integration into new dmedia.service.avahi module so `dmedia-service` is more managable

3. Revamped the `dmedia-cli` script to be simpler and more maintainable, yet hopefully retain all the good UX enhancements that David Green did

4. Added Dmedia.Resolve() DBus method... this is needed for the Novacut render server, and is the start of the API 3rd party apps will use to integrate with Dmedia

=== modified file 'debian/control'
--- debian/control	2011-12-29 07:01:47 +0000
+++ debian/control	2012-01-17 04:20:28 +0000
@@ -11,6 +11,8 @@
 Package: dmedia
 Architecture: all
 Depends: ${misc:Depends}, python3 (>= 3.2),
+    python3-gi | python3-gobject,
+    python3-dbus,
     python3-filestore (>= 12.01),
     python3-microfiber (>= 12.01),
     python3-userwebkit (>= 12.01),

=== modified file 'dmedia-browser'
--- dmedia-browser	2012-01-15 15:32:45 +0000
+++ dmedia-browser	2012-01-17 04:20:28 +0000
@@ -24,18 +24,20 @@
 from urllib.parse import urlparse
 
 from userwebkit import BaseApp
+import dmedia
 from dmedia import local
 
 
 class App(BaseApp):
     name = 'dmedia'
     dbname = 'dmedia-0'
+    version = dmedia.__version__
     title = 'Dmedia Browser'
 
     splash = 'splash.html'
     page = 'browser.html'
 
-    proxy_bus = 'org.freedesktop.DMedia'
+    proxy_bus = dmedia.BUS
     local = None
     
     def dmedia_resolver(self, uri):

=== modified file 'dmedia-cli'
--- dmedia-cli	2011-10-24 21:22:09 +0000
+++ dmedia-cli	2012-01-17 04:20:28 +0000
@@ -27,234 +27,150 @@
 Command line tool for talking to dmedia DBus services.
 """
 
-from sys import argv, stderr
+import optparse
+from collections import OrderedDict
+import sys
+from gettext import ngettext
+from os import path
+
+import dbus
+
 import dmedia
-from dmedia.service.api import DMedia
-
-class DBusCLI (object):
-    """
-    DBusCLI allows you to easily create command line interfaces from
-    DBus APIs.
-
-    Example usage:
-        my_cli = DBusCLI(
-            'mycli', '1.0', 'org.freedesktop.My',
-            '/', 'org.freedesktop.My'
-        )
-        my_cli.add_action("name1", function1, "usage of name1", "description of name1")
-        my_cli.add_dbus_action("MethodName", "usage of MethodName", "description of MethodName")
-        if __name__ == '__main__':
-            my_cli.main(*sys.argv[1:])
-    """
-    def __init__(self, exec_name, version):
-        """
-        `exec_name` is the name of the executable of the command line
-        program. It should be what the user needs to run to use the
-        program.
-
-        `version` is the version string of the command line program.
-
-        `dbus_bus` is the dbus bus name of the dbus API.
-
-        `dbus_object` is the dbus object of the dbus API.
-
-        `dbus_iface` is the dbus interface of the dbus API.
-        """
-        self._exec = exec_name
-        self._version = version
-        self._action_methods = {}
-        self._action_help = {}
-        self._add_default_actions()
-        self._dmedia = DMedia()
-
-    def has_action(self, name):
-        """
-        Return true if the action `name` exists,
-        false otherwise.
-        """
-        return (name in self._action_methods and name in self._action_help)
-
-    def get_action_method(self, name):
-        """
-        Return the function for action `name`.
-        """
-        return self._action_methods[name]
-
-    def get_usage(self):
-        """
-        Return the usage string for this program.
-        """
-        return """Usage:
-\t%s ACTION [ARGUMENTS]
-
-Run:
-\t%s help ACTION
-for help with a specific action.
-
-Run:
-\t%s actions
-for a list of available actions.
-""" % (self._exec, self._exec, self._exec)
-
-    def get_help(self, *names):
-        """
-        Return the help string for action(s) `names`.
-        If no names are specified, the help string will show
-        help for all available actions.
-        """
-        if len(names) == 0:
-            names = self.get_actions()
-        return "\n".join(map(
-            lambda name: "Action `%s`. Usage:\n\t%s %s %s\n%s\n" % (
-                (name, self._exec, name) + self._action_help[name]
-            ),
-            names
-        ))
-
-    def get_actions(self):
-        """
-        Return all available actions as a tuple.
-        """
-        return tuple(self._action_methods)
-
-    def show_usage(self):
-        """
-        Display the usage string for this program.
-        """
-        print(self.get_usage())
-
-    def show_help(self, *names):
-        """
-        Display the help string for `names`. See `get_help`.
-        """
-        print(self.get_help(*names))
-
-    def show_actions(self):
-        """
-        Display all available actions, each on a separate line.
-        """
-        print("\n".join(self.get_actions()))
-
-    def show_version(self):
-        """
-        Display the version of this program.
-        """
-        print(self._version)
-
-    def dbus_run(self, name, *args):
-        """
-        Run the dbus method `name` with arguments `args`.
-        Catch any errors and print them to stderr.
-        """
-        try:
-            method = getattr(self._dmedia, name)
-            print(str(method(*args)))
-        except Exception as e:
-            stderr.write("Error: {}\n".format(e))
-
-    def run_action(self, name, *args):
-        """
-        Run the action `name` with arguments `args`.
-        """
-        if self.has_action(name):
-            self.get_action_method(name)(*args)
-        else:
-            stderr.write("No such action `%s`\n" % name)
-            print(self.get_usage())
-
-    def run_action_with_bus(self, bus, name, *args):
-        """
-        Run the action `name` with arguments `args`.
-        Use a custom dbus bus name `bus`.
-        """
-        self._bus = bus
-        self.run_action(name, *args)
-
-    def add_action(self, name, function=lambda *a:None, usage="", description=""):
-        """
-        Add an action to the command line program.
-        `name` is the name of the action.
-        `function` is the function to be called for this action.
-        `usage` is a string describing the arguments of the action to the user.
-        `description` is a string describing what the action does.
-        """
-        self._action_methods[name] = function
-        self._action_help[name] = (usage, description)
-
-    def add_dbus_action(self, name, usage="", description=""):
-        """
-        Add an action to the command line program based upon a dbus method.
-        `name` is the name of the action and the name of the dbus method.
-        `usage` is a string describing the arguments of the action to the user.
-        `description` is a string describing what the action does.
-        """
-        self.add_action(
-            name,
-            lambda *args:self.dbus_run(name, *args),
-            usage,
-            description
-        )
-
-    def _add_default_actions(self):
-        #version
-        self.add_action(
-            "version",
-            self.show_version,
-            "",
-            "Display the version of this program."
-        )
-        #help
-        self.add_action(
-            "help",
-            self.show_help,
-            "[ACTION_1] [ACTION_2] ... [ACTION_N]",
-            "Display help information for each of the listed actions. If no actions are listed, help will be displayed for all available actions."
-        )
-        #usage
-        self.add_action(
-            "usage",
-            self.show_usage,
-            "",
-            "Display a usage message."
-        )
-        #actions
-        self.add_action(
-            "actions",
-            self.show_actions,
-            "",
-            "Display the list of available actions."
-        )
-        #bus
-        self.add_action(
-            "bus",
-            self.run_action_with_bus,
-            "BUS_NAME ACTION [ARGUMENTS]",
-            "Run an action using the dbus bus `BUS_NAME` for any dbus interaction."
-        )
-
-    def main(self, *args):
-        """
-        Run the command line program with the specified arguments.
-        """
-        args = list(args)
-        if len(args) < 1:
-            self.run_action("usage")
-        else:
-            self.run_action(args.pop(0), *args)
-
-dmedia_cli = DBusCLI("dmedia-cli", dmedia.__version__)
-
-dmedia_cli.add_dbus_action("Version", "", "Display the version of running `dmedia-service`.")
-dmedia_cli.add_dbus_action("Kill", "", "Shutdown `dmedia-service`.")
-dmedia_cli.add_dbus_action("AddFileStore", "PARENT_DIR", "Add a new dmedia file store. Create it in the `PARENT_DIR` directory (eg. /home/username).")
-dmedia_cli.add_dbus_action("RemoveFileStore", "PARENT_DIR", "Remove an existing dmedia file store.")
-#dmedia_cli.add_dbus_action("GetDoc", "DOC_ID", "Get a document from CouchDB. `DOC_ID` is the _id of the document.")
-#dmedia_cli.add_dbus_action("Upload", "FILE_ID STORE_ID", "Upload the file with id `FILE_ID` to the remote store with id `STORE_ID`.")
-#dmedia_cli.add_dbus_action("Download", "FILE_ID STORE_ID", "Download the file with id `FILE_ID` from the remote store with id `STORE_ID`.")
-#dmedia_cli.add_dbus_action("ListTransfers", "", "List active uploads and downloads.")
-dmedia_cli.add_dbus_action("GetEnv", "", "Display dmedia env as JSON.")
-#dmedia_cli.add_dbus_action("GetAuthURL", "", "Get URL with basic auth user and password.")
-#dmedia_cli.add_dbus_action("HasApp", "", "")
-
-if __name__ == '__main__':
-    dmedia_cli.main(*argv[1:])
+from dmedia.units import minsec
+
+
+methods = OrderedDict()
+session = dbus.SessionBus()
+
+
+def error(msg, code=1):
+    print('ERROR:', msg)
+    sys.exit(code)
+
+
+def print_methods():
+    print('DBus methods on {}:'.format(dmedia.BUS))
+    width = max(len(name) for name in methods)
+    for name in methods:
+        cls = methods[name]
+        print('  {}  {}'.format(name.ljust(width), cls.__doc__))
+
+
+def print_usage(cls):
+    print('Usage:')
+    print(' ', *cls.usage())
+
+
+class MethodMeta(type):
+    def __new__(meta, name, bases, dict):
+        cls = type.__new__(meta, name, bases, dict)
+        if not name.startswith('_'):
+            methods[name] = cls
+        return cls
+
+
+class _Method(metaclass=MethodMeta):
+    args = tuple()
+
+    def __init__(self, bus):
+        self.bus = bus
+        self.proxy = session.get_object(bus, '/')
+
+    @classmethod
+    def usage(cls):
+        script = path.basename(sys.argv[0])
+        cmd = [script, cls.__name__]
+        cmd.extend(arg.upper() for arg in cls.args)
+        return cmd
+
+    def run(self, args):
+        args = self.validate_args(*args)
+        method = self.proxy.get_dbus_method(self.__class__.__name__)
+        return self.format_output(method(*args))
+
+    def validate_args(self, *args):
+        return args
+
+    def format_output(self, output):
+        return output
+
+
+class Version(_Method):
+    'Show version of running `dmedia-service`'
+
+
+class Kill(_Method):
+    'Shutdown `dmedia-service`'
+    
+    def format_output(self, seconds):
+        return '{} was running for {}'.format(self.bus, minsec(seconds))
+
+
+class GetEnv(_Method):
+    'Get the CouchDB and Dmedia environment info'
+
+
+class LocalDmedia(_Method):
+    'Get the _local/dmedia document (shows file-stores)'
+
+
+class LocalPeers(_Method):
+    'Get the _local/peers document'
+
+
+class AddFileStore(_Method):
+    'Add a file storage location'
+
+    args = ['directory']
+    
+    def validate_args(self, directory):
+        return [path.abspath(directory)]
+
+
+class RemoveFileStore(AddFileStore):
+    'Add a file storage location'
+
+
+class Resolve(_Method):
+    'Resolve Dmedia file ID into a regular file path'
+
+    args = ['file_id']
+
+
+parser = optparse.OptionParser(
+    usage='%prog METHOD [ARGS...]',
+	version=dmedia.__version__,
+)
+parser.add_option('--bus',
+    help='DBus bus name; default is {!r}'.format(dmedia.BUS),
+    default=dmedia.BUS
+)
+(options, args) = parser.parse_args()
+
+
+if len(args) == 0:
+    parser.print_help()
+    print('')
+    print_methods()
+    sys.exit(0)
+
+name = args[0]
+args = args[1:]
+if name not in methods:
+    print_methods()
+    print('')
+    error('Unknown method {!r}'.format(name))
+
+cls = methods[name]
+if len(args) != len(cls.args):
+    print_usage(cls)
+    print('')
+    msg = ngettext(
+        '{!r} takes exactly {} argument',
+        '{!r} takes exactly {} arguments',
+        len(cls.args)
+    )
+    error(msg.format(name, len(cls.args)))
+
+method = cls(options.bus)
+print(method.run(args))

=== modified file 'dmedia-gtk'
--- dmedia-gtk	2012-01-04 10:10:10 +0000
+++ dmedia-gtk	2012-01-17 04:20:28 +0000
@@ -157,7 +157,7 @@
     splash = 'splash.html'
     page = 'index.html'
     title = 'Dmedia'
-    proxy_bus = 'org.freedesktop.DMedia'
+    proxy_bus = dmedia.BUS
 
     signals = {
         'create_project': ['title'],

=== modified file 'dmedia-service'
--- dmedia-service	2012-01-03 02:31:47 +0000
+++ dmedia-service	2012-01-17 04:20:28 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 # dmedia: distributed media library
 # Copyright (C) 2011 Novacut Inc
@@ -22,159 +22,168 @@
 #   Jason Gerard DeRose <[e-mail]>
 
 """
-Hacky shim till it's possible to implement DBus servers in PyGI.
-
-Note that because this script must be Python2, it can't import anything from the
-`dmedia` package as that will only be installed under Python3.
+Dmedia DBus service on org.freedesktop.Dmedia.
 """
 
-import argparse
-import os
-from os import path
-from subprocess import Popen
+import time
+start_time = time.time()
+
+import optparse
 import logging
-import time
-import sys
 import json
+from os import path
 
-import xdg.BaseDirectory
 import dbus
 import dbus.service
 from dbus.mainloop.glib import DBusGMainLoop
-from dc3lib.microfiber import Database, NotFound
-
-
-__version__ = '12.01.0'
-BUS = 'org.freedesktop.DMedia'
+from microfiber import Database, NotFound
+from gi.repository import GObject
+
+import dmedia
+from dmedia.core import Core, start_file_server
+from dmedia.service.dbus import UDisks
+from dmedia.service.avahi import Avahi
+
+
+BUS = dmedia.BUS
 IFACE = BUS
 log = logging.getLogger()
-service3 = path.join(path.dirname(path.abspath(__file__)), 'dmedia-service3')
-assert path.isfile(service3)
 
+GObject.threads_init()
 DBusGMainLoop(set_as_default=True)
 session = dbus.SessionBus()
 
 
-def configure_logging():
-    format = [
-        '%(levelname)s',
-        '%(message)s',
-    ]
-    script = path.abspath(sys.argv[0])
-    namespace = path.basename(script)
-    cache = path.join(xdg.BaseDirectory.xdg_cache_home, 'dmedia')
-    if not path.exists(cache):
-        os.makedirs(cache)
-    filename = path.join(cache, namespace + '.log')
-    if path.exists(filename):
-        os.rename(filename, filename + '.previous')
-    logging.basicConfig(
-        filename=filename,
-        filemode='w',
-        level=logging.DEBUG,
-        format='\t'.join(format),
-    )
-    logging.info('script: %r', script)
-    logging.info('dmedia.__file__: %r', __file__)
-    logging.info('dmedia.__version__: %r', __version__)
-
-
-class DMedia(dbus.service.Object):
-    def __init__(self, bus, mainloop):
-        self._killed = False
-        self._bus = bus
-        self._mainloop = mainloop
-
-        log.info('Binding to %r', bus)
-        super(DMedia, self).__init__(session, object_path='/')
-        self._busname = dbus.service.BusName(bus, session)
-
-        self._dc3 = session.get_object('org.freedesktop.DC3', '/')
-        self._machine_id = None
-        env = self._get_env()
-
-        log.info('Starting %r', service3)
-        self._child = Popen([service3, '--bus', bus])
-        db = Database('dmedia-0', env)
-        while True:
-            try:
-                time.sleep(0.1)
-                doc = db.get('_local/dmedia')
-                self._machine_id = doc['machine_id']
-                log.info('machine_id = %r', self._machine_id)
-                break
-            except NotFound:
-                pass
-
-    def _get_env(self):
-        log.info('Calling DC3.GetEnv()')
-        env = json.loads(self._dc3.GetEnv())
-        env['machine_id'] = self._machine_id
-        return env
+def dumps(obj):
+    return json.dumps(obj, sort_keys=True, separators=(',', ': '), indent=4)
+
+
+class Service(dbus.service.Object):
+    httpd = None
+    avahi = None
+
+    def __init__(self, bus, env_s):
+        self.bus = bus
+        self.env_s = env_s
+        self.mainloop = GObject.MainLoop()
+        log.info('DBus: binding to %r', bus)
+        super().__init__(session, object_path='/')
+        self.busname = dbus.service.BusName(bus, session)
+
+    def start_core(self):
+        if self.env_s is None:
+            self.dc3 = session.get_object('org.freedesktop.DC3', '/')
+            env = json.loads(self.dc3.GetEnv())
+        else:
+            env = json.loads(self.env_s)
+        self.udisks = UDisks()
+        self.core = Core(env, self.udisks.get_parentdir_info)
+        self.env_s = dumps(self.core.env)
+        if len(self.core.stores) == 0:
+            self.core.add_filestore('/home')
+        self.udisks.connect('store_added', self.on_store_added)
+        self.udisks.connect('store_removed', self.on_store_removed)
+        self.udisks.monitor()
+ 
+    def start_httpd(self):
+        (self.httpd, self.port) = start_file_server(self.core.env)
+        self.avahi = Avahi(self.core.env, self.port)
+        self.avahi.run()
+
+    def run(self):
+        self.start_core()
+        self.start_httpd()
+        self.mainloop.run()
+
+    def kill(self):
+        if self.avahi is not None:
+            self.avahi.free()
+        if self.httpd is not None:
+            self.httpd.terminate()
+            self.httpd.join()
+        self.mainloop.quit()
+
+    def on_store_added(self, udisks, obj, parentdir, partition, drive):
+        log.info('UDisks store_added: %r', parentdir)
+        try:
+            self.AddFileStore(parentdir)
+        except Exception:
+            log.exception('Could not add FileStore %r', parentdir)
+
+    def on_store_removed(self, udisks, obj, parentdir):
+        log.info('UDisks store_removed: %r', parentdir)
+        try:
+            self.RemoveFileStore(parentdir)
+        except Exception:
+            log.exception('Could not remove FileStore %r', parentdir)
 
     @dbus.service.method(IFACE, in_signature='', out_signature='s')
     def Version(self):
         """
         Return dmedia version.
         """
-        return __version__
+        return dmedia.__version__
 
-    @dbus.service.method(IFACE, in_signature='', out_signature='')
+    @dbus.service.method(IFACE, in_signature='', out_signature='i')
     def Kill(self):
         """
         Kill the `dmedia-service` process.
         """
-        if self._killed:
-            return
-        self._killed = True
-        log.info('Killing dmedia core service on %r', self._bus)
-        self.FwdKill()
-        self._child.wait()
-        self._mainloop.quit()
-
-    @dbus.service.signal(IFACE, signature='')
-    def FwdKill(self):
-        pass
+        self.kill()
+        return int(time.time() - start_time)
 
     @dbus.service.method(IFACE, in_signature='', out_signature='s')
     def GetEnv(self):
         """
         Return dmedia env as JSON string.
         """
-        return json.dumps(self._get_env())
-
-    @dbus.service.method(IFACE, in_signature='s', out_signature='')
+        return self.env_s
+
+    @dbus.service.method(IFACE, in_signature='', out_signature='s')
+    def LocalDmedia(self):
+        """
+        Return the _local/dmedia doc.
+        """
+        return dumps(self.core.db.get('_local/dmedia'))
+
+    @dbus.service.method(IFACE, in_signature='', out_signature='s')
+    def LocalPeers(self):
+        """
+        Return the _local/peers doc.
+        """
+        return dumps(self.core.db.get('_local/peers')) 
+
+    @dbus.service.method(IFACE, in_signature='s', out_signature='s')
     def AddFileStore(self, parentdir):
-        self.FwdAddFileStore(parentdir)
-
-    @dbus.service.signal(IFACE, signature='s')
-    def FwdAddFileStore(self, parentdir):
-        pass
-
-    @dbus.service.method(IFACE, in_signature='s', out_signature='')
+        fs = self.core.add_filestore(parentdir)
+        return self.LocalDmedia()
+
+    @dbus.service.method(IFACE, in_signature='s', out_signature='s')
     def RemoveFileStore(self, parentdir):
-        self.FwdRemoveFileStore(parentdir)
-
-    @dbus.service.signal(IFACE, signature='s')
-    def FwdRemoveFileStore(self, parentdir):
-        pass
-
-
-parser = argparse.ArgumentParser(
-    description='DBus service @{}'.format(BUS),
-)
-parser.add_argument('--version', action='version', version=__version__)
-parser.add_argument('--bus',
-    default=BUS,
-    help='DBus bus name; default is %(default)r',
-)
-args = parser.parse_args()
-configure_logging()
-
-from gi.repository import GObject
-GObject.threads_init()
-
-mainloop = GObject.MainLoop()
-dmedia = DMedia(args.bus, mainloop)
-mainloop.run()
-dmedia.Kill()
+        fs = self.core.remove_filestore(parentdir)
+        return self.LocalDmedia()
+
+    @dbus.service.method(IFACE, in_signature='s', out_signature='s')
+    def Resolve(self, _id):
+        return self.core.resolve(_id)
+
+
+parser = optparse.OptionParser(
+	version=dmedia.__version__,
+)
+parser.add_option('--env',
+    help='JSON-encoded CouchDB environment (for unit testing)',
+)
+parser.add_option('--bus',
+    help='DBus bus name; default is {!r}'.format(BUS),
+    default=BUS
+)
+(options, args) = parser.parse_args()
+
+
+dmedia.configure_logging()
+service = Service(options.bus, options.env)
+try:
+    service.run()
+finally:
+    service.kill()

=== removed file 'dmedia-service3'
--- dmedia-service3	2011-12-27 10:02:37 +0000
+++ dmedia-service3	1970-01-01 00:00:00 +0000
@@ -1,181 +0,0 @@
-#!/usr/bin/python3
-
-# dmedia: distributed media library
-# Copyright (C) 2011 Novacut Inc
-#
-# This file is part of `dmedia`.
-#
-# `dmedia` is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# `dmedia` is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Authors:
-#   Jason Gerard DeRose <[e-mail]>
-
-"""
-The real Python3 dmedia DBus service (well, almost).
-"""
-
-import sys
-import json
-from os import path
-import optparse
-import logging
-
-from gi.repository import GObject
-from microfiber import NotFound
-
-import dmedia
-from dmedia.service import dbus
-from dmedia.service.dbus import session, UDisks
-from dmedia.core import Core, start_file_server
-
-GObject.threads_init()
-log = logging.getLogger()
-
-
-class DMedia:
-    def __init__(self, bus):
-        self.mainloop = GObject.MainLoop()
-        dc3 = session.get('org.freedesktop.DC3', '/')
-        env = json.loads(dc3.GetEnv())
-        self.udisks = UDisks()
-        self.core = Core(env, self.udisks.get_parentdir_info)
-        if len(self.core.stores) == 0:
-            self.core.add_filestore('/home')
-        self._fwd = {
-            'AddFileStore': self.AddFileStore,
-            'RemoveFileStore': self.RemoveFileStore,
-            'Kill': self.Kill,
-        }
-        if bus:
-            log.info('Listing to forwards from %r', bus)
-            self.proxy = session.get(bus, '/', 'org.freedesktop.DMedia')
-            self.proxy.connect('g-signal', self.on_g_signal)
-        self.avahi = dbus.system.get(
-            'org.freedesktop.Avahi',
-            '/',
-            'org.freedesktop.Avahi.Server'
-        )
-        try:
-            self._peers = self.core.db.get('_local/peers')
-        except NotFound:
-            self._peers = {'_id': '_local/peers'}
-        self._peers['peers'] = {}
-        self.core.db.save(self._peers)
-        self.udisks.connect('store_added', self.on_store_added)
-        self.udisks.connect('store_removed', self.on_store_removed)
-        self.udisks.monitor()
-
-    def run(self):
-        (self.httpd, self.port) = start_file_server(self.core.env)
-        self.group = dbus.system.get(
-            'org.freedesktop.Avahi',
-            self.avahi.EntryGroupNew(),
-            'org.freedesktop.Avahi.EntryGroup'
-        )
-        self.group.AddService('(iiussssqaay)',
-            -1,  # Interface
-            0,  # Protocol -1 = both, 0 = ipv4, 1 = ipv6
-            0,  # Flags
-            self.core.machine_id,
-            '_dmedia._tcp',
-            '',  # Domain, default to .local
-            '',  # Host, default to localhost
-            self.port,  # Port
-            None  # TXT record
-        )
-        self.group.Commit()
-        browser_path = self.avahi.ServiceBrowserNew('(iissu)',
-            -1,  # Interface
-            0,  # Protocol -1 = both, 0 = ipv4, 1 = ipv6
-            '_dmedia._tcp',
-            'local',
-            0  # Flags
-        )
-        self.browser = dbus.system.get(
-            'org.freedesktop.Avahi',
-            browser_path,
-            'org.freedesktop.Avahi.ServiceBrowser'
-        )
-        self.browser.connect('g-signal', self.on_browser_g_signal)
-        self.mainloop.run()
-
-    def on_store_added(self, udisks, obj, parentdir, partition, drive):
-        log.info('UDisks store_added: %r', parentdir)
-        try:
-            self.AddFileStore(parentdir)
-        except Exception:
-            log.exception('Could not add FileStore %r', parentdir)
-
-    def on_store_removed(self, udisks, obj, parentdir):
-        log.info('UDisks store_removed: %r', parentdir)
-        try:
-            self.RemoveFileStore(parentdir)
-        except Exception:
-            log.exception('Could not remove FileStore %r', parentdir)
-
-    def on_g_signal(self, proxy, sender, signal, params):
-        if signal.startswith('Fwd'):
-            name = signal[3:]
-            args = params.unpack()
-            try:
-                self._fwd[name](*args)
-            except KeyError:
-                pass
-
-    def on_browser_g_signal(self, proxy, sender, signal, params):
-        if signal == 'ItemNew':
-            (interface, protocol, name, _type, domain, flags) = params.unpack()
-            if name != self.core.machine_id:  # Ignore what we publish ourselves
-                (ip, port) = self.avahi.ResolveService('(iisssiu)',
-                    interface, protocol, name, _type, domain, -1, 0
-                )[7:9]
-                url = 'http://{}:{}/'.format(ip, port)
-                log.info('New peer %r at %r', name, url)
-                self._peers['peers'][name] = url
-                self.core.db.save(self._peers)
-        elif signal == 'ItemRemove':
-            (interface, protocol, name, _type, domain, flags) = params.unpack()
-            log.info('Removing peer %r', name)
-            try:
-                del self._peers['peers'][name]
-                self.core.db.save(self._peers)
-            except KeyError:
-                pass
-
-    def AddFileStore(self, parentdir):
-        self.core.add_filestore(path.abspath(parentdir))
-
-    def RemoveFileStore(self, parentdir):
-        self.core.remove_filestore(path.abspath(parentdir))
-
-    def Kill(self):
-        self.group.Reset()
-        self.httpd.terminate()
-        self.httpd.join()
-        self.mainloop.quit()
-
-
-parser = optparse.OptionParser(
-	usage='Usage: %prog FILE',
-	version=dmedia.__version__,
-)
-parser.add_option('--bus',
-    help='If provided, expect Python2 shim on this DBus bus',
-)
-(options, args) = parser.parse_args()
-
-dmedia.configure_logging()
-service = DMedia(options.bus)
-service.run()
-service.Kill()

=== modified file 'dmedia/__init__.py'
--- dmedia/__init__.py	2011-12-27 07:21:46 +0000
+++ dmedia/__init__.py	2012-01-17 04:20:28 +0000
@@ -27,6 +27,7 @@
 """
 
 __version__ = '12.01.0'
+BUS = 'org.freedesktop.Dmedia'
 
 
 def configure_logging():

=== modified file 'dmedia/constants.py'
--- dmedia/constants.py	2012-01-03 02:12:57 +0000
+++ dmedia/constants.py	2012-01-17 04:20:28 +0000
@@ -45,10 +45,8 @@
 
 
 # D-Bus releated:
-BUS = 'org.freedesktop.DMedia'
+BUS = 'org.freedesktop.Dmedia'
 IFACE = BUS
-IMPORT_BUS = 'org.freedesktop.DMediaImporter'
-IMPORT_IFACE = IMPORT_BUS
 DC_BUS = 'org.desktopcouch.CouchDB'
 DC_INTERFACE = DC_BUS
 

=== modified file 'dmedia/core.py'
--- dmedia/core.py	2012-01-02 23:49:23 +0000
+++ dmedia/core.py	2012-01-17 04:20:28 +0000
@@ -39,6 +39,7 @@
 from microfiber import Database, NotFound, random_id2
 from filestore import FileStore, check_root_hash, check_id
 
+import dmedia
 from dmedia import schema
 from dmedia.local import LocalStores
 from dmedia.views import init_views
@@ -133,6 +134,7 @@
             self.db.save(machine)
         self.machine_id = self.local['machine_id']
         self.env['machine_id'] = self.machine_id
+        self.env['version'] = dmedia.__version__
         log.info('machine_id = %r', self.machine_id)
 
     def _init_stores(self):
@@ -207,3 +209,7 @@
         assert set(self.local['stores']) == set(self.stores.parentdirs)
         assert set(s['id'] for s in self.local['stores'].values()) == set(self.stores.ids)
 
+    def resolve(self, _id):
+        doc = self.db.get(_id)
+        fs = self.stores.choose_local_store(doc)
+        return fs.stat(_id).name

=== modified file 'dmedia/service/api.py'
--- dmedia/service/api.py	2011-10-24 21:36:05 +0000
+++ dmedia/service/api.py	2012-01-17 04:20:28 +0000
@@ -30,10 +30,10 @@
 
 class DMedia:
     """
-    Talk to "org.freedesktop.DMedia".
+    Talk to "org.freedesktop.Dmedia".
     """
 
-    def __init__(self, bus='org.freedesktop.DMedia'):
+    def __init__(self, bus='org.freedesktop.Dmedia'):
         self.bus = bus
         self._proxy = None
 

=== added file 'dmedia/service/avahi.py'
--- dmedia/service/avahi.py	1970-01-01 00:00:00 +0000
+++ dmedia/service/avahi.py	2012-01-17 04:20:28 +0000
@@ -0,0 +1,116 @@
+# dmedia: distributed media library
+# Copyright (C) 2011 Novacut Inc
+#
+# This file is part of `dmedia`.
+#
+# `dmedia` is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# `dmedia` is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along
+# with `dmedia`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+"""
+Advertise Dmedia HTTP server over Avahi, discover other peers.
+"""
+
+import logging
+
+from microfiber import Database, NotFound
+
+from dmedia.service.dbus import system
+
+
+PEERS = '_local/peers'
+log = logging.getLogger()
+
+
+class Avahi:
+    group = None
+
+    def __init__(self, env, port):
+        self.avahi = system.get(
+            'org.freedesktop.Avahi',
+            '/',
+            'org.freedesktop.Avahi.Server'
+        )
+        self.db = Database('dmedia-0', env)
+        self.machine_id = env['machine_id']
+        self.port = port
+
+    def __del__(self):
+        self.free()
+
+    def run(self):
+        try:
+            self.peers = self.db.get(PEERS)
+            if self.peers.get('peers') != {}:
+                self.peers['peers'] = {}
+                self.db.save(self.peers)
+        except NotFound:
+            self.peers = {'_id': PEERS, 'peers': {}}
+            self.db.save(self.peers)
+        self.group = system.get(
+            'org.freedesktop.Avahi',
+            self.avahi.EntryGroupNew(),
+            'org.freedesktop.Avahi.EntryGroup'
+        )
+        log.info('Avahi: advertising %r on port %r', self.machine_id, self.port)
+        self.group.AddService('(iiussssqaay)',
+            -1,  # Interface
+            0,  # Protocol -1 = both, 0 = ipv4, 1 = ipv6
+            0,  # Flags
+            self.machine_id,
+            '_dmedia._tcp',
+            '',  # Domain, default to .local
+            '',  # Host, default to localhost
+            self.port,  # Port
+            None  # TXT record
+        )
+        self.group.Commit()
+        browser_path = self.avahi.ServiceBrowserNew('(iissu)',
+            -1,  # Interface
+            0,  # Protocol -1 = both, 0 = ipv4, 1 = ipv6
+            '_dmedia._tcp',
+            'local',
+            0  # Flags
+        )
+        self.browser = system.get(
+            'org.freedesktop.Avahi',
+            browser_path,
+            'org.freedesktop.Avahi.ServiceBrowser'
+        )
+        self.browser.connect('g-signal', self.on_g_signal)
+
+    def free(self):
+        if self.group is not None:
+            self.group.Reset()
+ 
+    def on_g_signal(self, proxy, sender, signal, params):
+        if signal == 'ItemNew':
+            (interface, protocol, name, _type, domain, flags) = params.unpack()
+            if name != self.machine_id:  # Ignore what we publish ourselves
+                (ip, port) = self.avahi.ResolveService('(iisssiu)',
+                    interface, protocol, name, _type, domain, -1, 0
+                )[7:9]
+                url = 'http://{}:{}/'.format(ip, port)
+                log.info('Avahi: new peer %r at %r', name, url)
+                self.peers['peers'][name] = url
+                self.db.save(self.peers)
+        elif signal == 'ItemRemove':
+            (interface, protocol, name, _type, domain, flags) = params.unpack()
+            log.info('Avahi: removing peer %r', name)
+            try:
+                del self.peers['peers'][name]
+                self.db.save(self.peers)
+            except KeyError:
+                pass

=== modified file 'dmedia/transfers.py'
--- dmedia/transfers.py	2011-09-22 10:20:44 +0000
+++ dmedia/transfers.py	2012-01-17 04:20:28 +0000
@@ -41,7 +41,7 @@
 _uploaders = {}
 _downloaders = {}
 
-# Note: should probably export each download on the org.freedesktop.DMedia bus
+# Note: should probably export each download on the org.freedesktop.Dmedia bus
 # at the object path /downloads/FILE_ID
 
 def download_key(file_id, store_id):
@@ -63,7 +63,7 @@
     """
     return '/downloads/' + file_id
 
-# Note: should probably export each upload on the org.freedesktop.DMedia bus
+# Note: should probably export each upload on the org.freedesktop.Dmedia bus
 # at the object path /uploads/FILE_ID/REMOTE_ID
 
 def upload_key(file_id, store_id):

=== modified file 'dmedia/units.py'
--- dmedia/units.py	2011-10-08 11:18:57 +0000
+++ dmedia/units.py	2012-01-17 04:20:28 +0000
@@ -68,3 +68,16 @@
     return (
         '{:.3g} {}'.format(s, BYTES10[i])
     )
+
+
+def minsec(seconds):
+    """
+    Format *seconds* as a M:SS string with minutes and seconds.
+    
+    For example:
+    
+    >>> minsec(123)
+    '2:03'
+    
+    """
+    return '{:d}:{:02d}'.format(seconds // 60, seconds % 60)

=== modified file 'setup.py'
--- setup.py	2012-01-15 15:21:24 +0000
+++ setup.py	2012-01-17 04:20:28 +0000
@@ -159,12 +159,11 @@
         ('lib/dmedia',
             [
                 'dmedia-service',
-                'dmedia-service3',
                 'share/init-filestore',
             ]
         ),
         ('share/dbus-1/services/',
-            ['share/org.freedesktop.DMedia.service']
+            ['share/org.freedesktop.Dmedia.service']
         ),
     ],
 )

=== renamed file 'share/org.freedesktop.DMedia.service' => 'share/org.freedesktop.Dmedia.service'
--- share/org.freedesktop.DMedia.service	2011-04-10 11:02:23 +0000
+++ share/org.freedesktop.Dmedia.service	2012-01-17 04:20:28 +0000
@@ -1,3 +1,3 @@
 [D-BUS Service]
-Name=org.freedesktop.DMedia
+Name=org.freedesktop.Dmedia
 Exec=/usr/lib/dmedia/dmedia-service

=== added file 'test-cli.py'
--- test-cli.py	1970-01-01 00:00:00 +0000
+++ test-cli.py	2012-01-17 04:20:28 +0000
@@ -0,0 +1,33 @@
+#!/usr/bin/python3
+
+from usercouch.misc import TempCouch
+from microfiber import random_id
+import json
+import time
+from subprocess import Popen, check_output
+
+bus = 'tmp' + random_id() + '.Dmedia'
+
+def call(*args):
+    cmd = ('./dmedia-cli', '--bus', bus) + args
+    print(check_output(cmd).decode('utf-8'))
+
+# Check that printing help doesn't connect to the DBus service:
+call()
+
+# Start a tmp couchdb and the dbus service on a random bus name:
+tmpcouch = TempCouch()
+env = tmpcouch.bootstrap()
+cmd = ['./dmedia-service', '--bus', bus, '--env', json.dumps(env)]
+child = Popen(cmd)
+time.sleep(1)
+
+try:
+    call('Version')
+    call('GetEnv')
+    call('LocalDmedia')
+    call('LocalPeers')
+    call('RemoveFileStore', '/home/')
+    call('AddFileStore', '/home/')
+finally:
+    call('Kill')

=== added file 'test-service.py'
--- test-service.py	1970-01-01 00:00:00 +0000
+++ test-service.py	2012-01-17 04:20:28 +0000
@@ -0,0 +1,29 @@
+#!/usr/bin/python3
+
+from usercouch.misc import TempCouch
+from microfiber import random_id
+import json
+import time
+from subprocess import Popen
+from dmedia.service.dbus import session
+
+bus = 'tmp' + random_id() + '.Dmedia'
+tmpcouch = TempCouch()
+env = tmpcouch.bootstrap()
+
+cmd = ['./dmedia-service', '--bus', bus, '--env', json.dumps(env)]
+
+child = Popen(cmd)
+time.sleep(2)
+
+proxy = session.get(bus, '/', 'org.freedesktop.Dmedia')
+try:
+    print(proxy.Version())
+    print(proxy.GetEnv())
+    print(proxy.LocalDmedia())
+    print(proxy.LocalPeers())
+    print(proxy.RemoveFileStore('(s)', '/home'))
+    print(proxy.AddFileStore('(s)', '/home'))
+finally:
+    print(proxy.Kill())
+