ext: Convert commands to use new registry system.

Creates a placeholder registry using the existing hooks, and updates the
commands to use these. The actual registry still needs to be created.

mopidy/__main__.py

@@ -108,10 +108,16 @@ def main():
                 args.extension.ext_name)
             return 1
 
+        registry = {'backends': [], 'frontends': [], 'local:library': []}
+        for extension in enabled_extensions:
+            registry['backends'].extend(extension.get_backend_classes())
+            registry['frontends'].extend(extension.get_frontend_classes())
+            registry['local:library'].extend(extension.get_library_updaters())
+
         # Anything that wants to exit after this point must use
         # mopidy.utils.process.exit_process as actors can have been started.
         try:
-            return args.command.run(args, proxied_config, enabled_extensions)
+            return args.command.run(args, proxied_config, registry)
         except NotImplementedError:
             print root_cmd.format_help()
             return 1

mopidy/backends/local/commands.py

@@ -22,27 +22,22 @@ class LocalCommand(commands.Command):
 class ScanCommand(commands.Command):
     help = "Scan local media files and populate the local library."
 
-    def run(self, args, config, extensions):
+    def run(self, args, config, registry):
         media_dir = config['local']['media_dir']
         scan_timeout = config['local']['scan_timeout']
         excluded_file_extensions = set(
             ext.lower() for ext in config['local']['excluded_file_extensions'])
 
-        updaters = {}
-        for e in extensions:
-            for updater_class in e.get_library_updaters():
-                if updater_class and 'local' in updater_class.uri_schemes:
-                    updaters[e.ext_name] = updater_class
-
+        # TODO: select updater / library to use by name
+        updaters = registry['local:library']
         if not updaters:
             logger.error('No usable library updaters found.')
             return 1
         elif len(updaters) > 1:
             logger.error('More than one library updater found. '
-                         'Provided by: %s', ', '.join(updaters.keys()))
+                         'Provided by: %s', ', '.join(updaters))
             return 1
-
-        local_updater = updaters.values()[0](config)
+        local_updater = updaters[0](config)
 
         uri_path_mapping = {}
         uris_in_library = set()

mopidy/commands.py

@@ -257,22 +257,22 @@ class RootCommand(Command):
             type=config_override_type, metavar='OPTIONS',
             help='`section/key=value` values to override config options')
 
-    def run(self, args, config, extensions):
+    def run(self, args, config, registry):
         loop = gobject.MainLoop()
         try:
             audio = self.start_audio(config)
-            backends = self.start_backends(config, extensions, audio)
+            backends = self.start_backends(config, registry, audio)
             core = self.start_core(audio, backends)
-            self.start_frontends(config, extensions, core)
+            self.start_frontends(config, registry, core)
             loop.run()
         except KeyboardInterrupt:
             logger.info('Interrupted. Exiting...')
             return
         finally:
             loop.quit()
-            self.stop_frontends(extensions)
+            self.stop_frontends(registry)
             self.stop_core()
-            self.stop_backends(extensions)
+            self.stop_backends(registry)
             self.stop_audio()
             process.stop_remaining_actors()
 
@@ -280,10 +280,8 @@ class RootCommand(Command):
         logger.info('Starting Mopidy audio')
         return Audio.start(config=config).proxy()
 
-    def start_backends(self, config, extensions, audio):
-        backend_classes = []
-        for extension in extensions:
-            backend_classes.extend(extension.get_backend_classes())
+    def start_backends(self, config, registry, audio):
+        backend_classes = registry['backends']
 
         logger.info(
             'Starting Mopidy backends: %s',
@@ -300,10 +298,8 @@ class RootCommand(Command):
         logger.info('Starting Mopidy core')
         return Core.start(audio=audio, backends=backends).proxy()
 
-    def start_frontends(self, config, extensions, core):
-        frontend_classes = []
-        for extension in extensions:
-            frontend_classes.extend(extension.get_frontend_classes())
+    def start_frontends(self, config, registry, core):
+        frontend_classes = registry['frontends']
 
         logger.info(
             'Starting Mopidy frontends: %s',
@@ -312,21 +308,19 @@ class RootCommand(Command):
         for frontend_class in frontend_classes:
             frontend_class.start(config=config, core=core)
 
-    def stop_frontends(self, extensions):
+    def stop_frontends(self, registry):
         logger.info('Stopping Mopidy frontends')
-        for extension in extensions:
-            for frontend_class in extension.get_frontend_classes():
-                process.stop_actors_by_class(frontend_class)
+        for frontend_class in registry['frontends']:
+            process.stop_actors_by_class(frontend_class)
 
     def stop_core(self):
         logger.info('Stopping Mopidy core')
         process.stop_actors_by_class(Core)
 
-    def stop_backends(self, extensions):
+    def stop_backends(self, registry):
         logger.info('Stopping Mopidy backends')
-        for extension in extensions:
-            for backend_class in extension.get_backend_classes():
-                process.stop_actors_by_class(backend_class)
+        for backend_class in registry['backends']:
+            process.stop_actors_by_class(backend_class)
 
     def stop_audio(self):
         logger.info('Stopping Mopidy audio')