Merge lp:~verterok/ubuntuone-client/waiting-meta into lp:ubuntuone-client

[Guillermo Gonzalez]

Expose waiting metadata commands via DBus and add waiting_metadata method to SyncDaemonTool.

Expose list of waiting metadata commands via DBus and add the method to SyncDaemonTool.

[Rick McBride (rmcbride)]

+1

review: Approve

[Eric Casteleijn (thisfred)]

Looks good, tests green!

review: Approve

=== modified file 'tests/syncdaemon/test_dbus.py'
--- tests/syncdaemon/test_dbus.py	2010-03-09 17:29:18 +0000
+++ tests/syncdaemon/test_dbus.py	2010-03-09 22:18:13 +0000
@@ -63,6 +63,12 @@
         """Just succeed."""
         return defer.succeed(None)
 
+    def __str__(self):
+        name = self.__class__.__name__
+        tmpl = name + "(" + "share_id=%s, node_id=%s" + ")"
+        return tmpl % (self.share_id,
+                       self.node_id)
+
 
 class DBusInterfaceTests(DBusTwistedTestCase):
     """ Basic tests to the objects exposed with D-Bus"""
@@ -253,6 +259,31 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_waiting_metadata(self):
+        """Test Status.waiting_metadata with fake data in the AQ."""
+        # inject the fake data
+        self.action_q.meta_queue.waiting.extend([
+                FakeCommand("node_a_foo", "node_a_bar"),
+                FakeCommand("node_b_foo", "node_b_bar")])
+        # OK, testing time
+        client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
+        d = defer.Deferred()
+        def waiting_handler(result):
+            """waiting_metadata reply handler."""
+            self.assertEquals(2, len(result))
+            # the second time we're called, the result should be reversed
+            node_a, node_b = result
+            self.assertEquals(str(FakeCommand("node_a_foo", "node_a_bar")),
+                              node_a)
+            self.assertEquals(str(FakeCommand("node_b_foo", "node_b_bar")),
+                              node_b)
+            d.callback(True)
+        client.call_method('waiting_metadata',
+                           reply_handler=waiting_handler,
+                           error_handler=self.error_handler)
+        return d
+
+
     def test_contq_changed(self):
         """Test the Status.ContentQueueChanged signal."""
         # prepare the VM so it lies for us

=== modified file 'tests/syncdaemon/test_tools.py'
--- tests/syncdaemon/test_tools.py	2010-03-03 15:04:02 +0000
+++ tests/syncdaemon/test_tools.py	2010-03-09 22:18:13 +0000
@@ -26,6 +26,7 @@
     volume_manager,
     states,
 )
+from tests.syncdaemon.test_dbus import FakeCommand
 from contrib.testing.testcase import (
     DBusTwistedTestCase,
 )
@@ -298,17 +299,26 @@
         d.addCallbacks(handler, self.fail)
         return d
 
+    def test_waiting_metadata(self):
+        """Test SyncDaemonTool.waiting_metadata."""
+        # inject the fake data
+        self.action_q.meta_queue.waiting.extend([
+                FakeCommand("node_a_foo", "node_a_bar"),
+                FakeCommand("node_b_foo", "node_b_bar")])
+        d = self.tool.waiting_metadata()
+        def check(result):
+            """waiting_metadata reply handler."""
+            self.assertEquals(2, len(result))
+            # the second time we're called, the result should be reversed
+            node_a, node_b = result
+            self.assertEquals(str(FakeCommand("node_a_foo", "node_a_bar")),
+                              node_a)
+            self.assertEquals(str(FakeCommand("node_b_foo", "node_b_bar")),
+                              node_b)
+        return d
+
     def test_waiting_content_schedule_next(self):
         """Test waiting_content and schedule_next"""
-        class FakeCommand(object):
-            """A fake command"""
-            def __init__(self, share_id, node_id):
-                """create it"""
-                self.share_id = share_id
-                self.node_id = node_id
-            def is_runnable(self):
-                """is runnable"""
-                return True
         path = os.path.join(self.root_dir, "foo")
         self.fs_manager.create(path, "")
         self.fs_manager.set_node_id(path, "node_id")

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2010-03-09 15:42:50 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2010-03-09 22:18:13 +0000
@@ -1419,6 +1419,17 @@
         """Returns the action queue."""
         return self._queue.action_queue
 
+    def __str__(self, str_attrs=None):
+        """Return a str representation of the instance."""
+        if str_attrs is None:
+            str_attrs = self.logged_attrs
+        name = self.__class__.__name__
+        if len(str_attrs) == 0:
+            return name
+        attrs = [str(attr) + '=' + str(getattr(self, attr, None) or 'None') \
+                 for attr in str_attrs]
+        return ''.join([name, '(', ', '.join([attr for attr in attrs]), ')'])
+
 
 class WaitForCondition(ActionQueueCommand):
     """A command which waits for some condition to be satisfied."""
@@ -2257,6 +2268,11 @@
 
     is_dir = True
 
+    def __str__(self):
+        """Return a str representation of the instance."""
+        to_show = ('share_id', 'node_id', 'server_hash')
+        return super(ListDir, self).__str__(str_attrs=to_show)
+
 
 class Download(GetContentMixin, ActionQueueCommand):
     """Get the contents of a file."""

=== modified file 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-03-09 21:11:16 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-03-09 22:18:13 +0000
@@ -191,6 +191,15 @@
             current_downloads.append(entry)
         return current_downloads
 
+    @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='as')
+    def waiting_metadata(self):
+        """Return a list of the operations in the meta-queue."""
+        logger.debug('called waiting_metadata')
+        waiting_metadata = []
+        for cmd in self.action_queue.meta_queue.waiting:
+            waiting_metadata.append(str(cmd))
+        return waiting_metadata
+
     @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='aa{ss}')
     def waiting_content(self):
         """

=== modified file 'ubuntuone/syncdaemon/tools.py'
--- ubuntuone/syncdaemon/tools.py	2010-03-09 15:45:46 +0000
+++ ubuntuone/syncdaemon/tools.py	2010-03-09 22:18:13 +0000
@@ -593,6 +593,16 @@
                                   error_handler=d.errback)
         return d
 
+    def waiting_metadata(self):
+        """Return a description of the waiting metadata queue elements."""
+        d = defer.Deferred()
+        status_client = DBusClient(self.bus, '/status',
+                                   DBUS_IFACE_STATUS_NAME)
+        status_client.call_method('waiting_metadata',
+                                  reply_handler=d.callback,
+                                  error_handler=d.errback)
+        return d
+
     def waiting_content(self):
         """Returns the waiting content queue elements."""
         d = defer.Deferred()