Merge lp:~facundo/magicicada-gui/more-api into lp:magicicada-gui

[Facundo Batista]

More API implemented!

- on_started

- on_connected

- on_online

- content_queue

- meta_queue

[Facundo Batista (facundo)]

The resto of the simple API from the bug

[Natalia Bidart (nataliabidart)]

I personally prefer name.startswith('_') than if name[0] == "_", is there any reason to pick the second? (I know is not a change in this branch).

Other than that, great job!

review: Approve

=== modified file 'magicicada/syncdaemon.py'
--- magicicada/syncdaemon.py	2010-05-18 22:00:50 +0000
+++ magicicada/syncdaemon.py	2010-05-19 20:56:30 +0000
@@ -29,11 +29,6 @@
 
 from magicicada.helpers import NO_OP
 
-# structures that hold content and queue information
-QueueData = collections.namedtuple('QueueData', 'operation path share node')
-State = collections.namedtuple('State', 'name description is_error '
-                               'is_connected is_online queues connection')
-
 # regular expressions for parsing MetaQueue data
 RE_OP_LISTDIR = re.compile("(ListDir)\(share_id=(.*?), node_id=(.*?), .*")
 RE_OP_UNLINK = re.compile("(Unlink)\(share_id=(.*?), node_id=(.*?), .*")
@@ -50,19 +45,23 @@
     _attrs =  ['name', 'description', 'is_error', 'is_connected',
                'is_online', 'queues', 'connection', 'is_started']
 
-    def __init__(self, syncdaemon):
-        self._sd = syncdaemon
+    def __init__(self):
+        # starting defaults
+        self.name = ''
+        self.description = ''
+        self.is_error = False
+        self.is_connected = False
+        self.is_online = False
+        self.queues = ''
+        self.connection = ''
+        self.is_started = False
 
     def __getattribute__(self, name):
         """Return the value if there."""
         if name[0] == "_":
             return object.__getattribute__(self, name)
         else:
-            if name == 'is_started':
-                v = self._sd._get_started()
-            else:
-                v = self.__dict__.get(name)
-            return v
+            return self.__dict__[name]
 
     def _set(self, **data):
         """Sets the attributes fromd data, if allowed."""
@@ -80,16 +79,20 @@
         loop = DBusGMainLoop(set_as_default=True)
         self._bus = bus = dbus.SessionBus(mainloop=loop)
         self.sync_daemon_tool = tools.SyncDaemonTool(bus)
-        self.current_state = State(self)
+        self.current_state = State()
 
         # hook up for signals and store info for the shutdown
         _signals = [
             (self._on_status_changed, 'Status', 'StatusChanged'),
             (self._on_content_queue_changed, 'Status', 'ContentQueueChanged'),
+            (self._on_name_owner_changed, None, 'NameOwnerChanged'),
         ]
         self._dbus_matches = []
         for method, dbus_lastname, signal_name in _signals:
-            dbus_interface = 'com.ubuntuone.SyncDaemon.' + dbus_lastname
+            if dbus_lastname is None:
+                dbus_interface = None
+            else:
+                dbus_interface = 'com.ubuntuone.SyncDaemon.' + dbus_lastname
             match = bus.add_signal_receiver(method,
                                             dbus_interface=dbus_interface,
                                             signal_name=signal_name)
@@ -99,11 +102,16 @@
         self.status_changed_callback = NO_OP
         self.content_queue_changed_callback = NO_OP
         self.meta_queue_changed_callback = NO_OP
+        self.on_started_callback = NO_OP
+        self.on_stopped_callback = NO_OP
+        self.on_connected_callback = NO_OP
+        self.on_disconnected_callback = NO_OP
+        self.on_online_callback = NO_OP
+        self.on_offline_callback = NO_OP
 
         # calls to obtain data from SDT
         self._get_content_queue = self.sync_daemon_tool.waiting_content
         self._get_meta_queue = self.sync_daemon_tool.waiting_metadata
-        self._get_started = tools.is_running
         self._do_start = self.sync_daemon_tool.start
         self._do_quit = self.sync_daemon_tool.quit
         self._do_connect = self.sync_daemon_tool.connect
@@ -128,6 +136,20 @@
         if self._mqcaller is not None and self._mqcaller.active():
             self._mqcaller.cancel()
 
+    def _on_name_owner_changed(self, name, oldowner, newowner):
+        """Receives the NameOwnerChanged signal from DBus."""
+        if name == 'com.ubuntuone.SyncDaemon':
+            old = bool(oldowner)
+            new = bool(newowner)
+            if old == new:
+                raise ValueError("Owners should have changed! Old: %r  "
+                                 "New: %r" % (oldowner, newowner))
+            self.current_state._set(is_started=new)
+            if new:
+                self.on_started_callback()
+            else:
+                self.on_stopped_callback()
+
     def _on_status_changed(self, state):
         """Receives the StatusChanged signal and send its data."""
         name = state['name']
@@ -137,12 +159,44 @@
         is_online = bool(state['is_online'])
         queues = state['queues']
         connection = state['connection']
+
+        # check status changes to call callbacks
+        if is_connected and not self.current_state.is_connected:
+            self.on_connected_callback()
+        if not is_connected and self.current_state.is_connected:
+            self.on_disconnected_callback()
+        if is_online and not self.current_state.is_online:
+            self.on_online_callback()
+        if not is_online and self.current_state.is_online:
+            self.on_offline_callback()
+
+
+        # set current state to new values and call status changed cb
         self.current_state._set(**state)
         self.status_changed_callback(name, description, is_error,
                                      is_connected, is_online,
                                      queues, connection)
+
+        # if corresponds, supervise MQ
         self._check_mq()
 
+    def _generate_cq_info(self, data):
+        """Genereates an api friendly version of the data."""
+        all_items = []
+        for d in data:
+            cq = QueueData(operation=d['operation'], path=d['path'],
+                           node=d['node'], share=d['share'])
+            all_items.append(cq)
+        return all_items
+
+    @property
+    def content_queue(self):
+        """Returns the last known CQ info."""
+        if self._last_CQ_data is None:
+            return []
+        else:
+            return self._generate_cq_info(self._last_CQ_data)
+
     def _process_cq(self, data):
         """Processes ContentQueue data."""
         # if same data than before, abort notification; else store it for later
@@ -150,12 +204,7 @@
             return
         self._last_CQ_data = data
 
-        all_items = []
-        for d in data:
-            cq = QueueData(operation=d['operation'], path=d['path'],
-                           node=d['node'], share=d['share'])
-            all_items.append(cq)
-
+        all_items = self._generate_cq_info(data)
         self.content_queue_changed_callback(all_items)
 
     def _on_content_queue_changed(self, _):
@@ -164,6 +213,17 @@
         d = self._get_content_queue()
         d.addCallback(self._process_cq)
 
+    @property
+    def meta_queue(self):
+        """Returns the last known MQ info."""
+        if self._last_MQ_data is None:
+            return []
+        else:
+            all_items = []
+            for d in self._last_MQ_data:
+                all_items.append(self._parse_mq(d))
+            return all_items
+
     def _parse_mq(self, data):
         """Parse MetaQueue string to extract its data."""
         if data in ('AccountInquiry', 'FreeSpaceInquiry', 'GetPublicFiles',

=== modified file 'magicicada/tests/test_syncdaemon.py'
--- magicicada/tests/test_syncdaemon.py	2010-05-18 19:53:38 +0000
+++ magicicada/tests/test_syncdaemon.py	2010-05-19 20:56:30 +0000
@@ -173,6 +173,44 @@
                 self.assertEqual(received.share, original['share'])
                 self.assertEqual(received.node, original['node'])
 
+    def test_CQ_state_none(self):
+        """Check the ContentQueue info, being none."""
+        self.assertEqual(len(self.sd.content_queue), 0)
+
+    def test_CQ_state_one(self):
+        """Check the ContentQueue info, being one."""
+        d = dict(operation='oper', path='path', share='share', node='node')
+        self.sd._process_cq([d])
+        self.assertEqual(len(self.sd.content_queue), 1)
+
+        # check the data
+        cqit = self.sd.content_queue[0]
+        self.assertEqual(cqit.operation, 'oper')
+        self.assertEqual(cqit.path, 'path')
+        self.assertEqual(cqit.share, 'share')
+        self.assertEqual(cqit.node, 'node')
+
+    def test_CQ_state_several(self):
+        """Check the ContentQueue info, several calls, last one is bigger."""
+        c = dict(operation='oper1', path='path1', share='share1', node='node1')
+        d = dict(operation='oper2', path='path2', share='share2', node='node2')
+        self.sd._process_cq([c])
+        self.sd._process_cq([d])
+        self.sd._process_cq([c, d])
+        self.assertEqual(len(self.sd.content_queue), 2)
+
+        # check the data
+        cqit = self.sd.content_queue[0]
+        self.assertEqual(cqit.operation, 'oper1')
+        self.assertEqual(cqit.path, 'path1')
+        self.assertEqual(cqit.share, 'share1')
+        self.assertEqual(cqit.node, 'node1')
+        cqit = self.sd.content_queue[1]
+        self.assertEqual(cqit.operation, 'oper2')
+        self.assertEqual(cqit.path, 'path2')
+        self.assertEqual(cqit.share, 'share2')
+        self.assertEqual(cqit.node, 'node2')
+
 
 class MetaQueueChangedTests(SignalsBaseTest):
     """Check the MetaQueueChanged handling."""
@@ -373,37 +411,74 @@
         deferred = defer.Deferred()
         return deferred
 
+    def test_MQ_state_none(self):
+        """Check the MetaQueue info, being none."""
+        self.assertEqual(len(self.sd.meta_queue), 0)
+
+    def test_MQ_state_one(self):
+        """Check the MetaQueue info, being one."""
+        self.sd._process_mq(['ListShares'])
+        self.assertEqual(len(self.sd.meta_queue), 1)
+
+        # check the data
+        mqit = self.sd.meta_queue[0]
+        self.assertEqual(mqit.operation, 'ListShares')
+        self.assertEqual(mqit.path, None)
+        self.assertEqual(mqit.share, None)
+        self.assertEqual(mqit.node, None)
+
+    def test_MQ_state_several(self):
+        """Check the MetaQueue info, several calls, last one is bigger."""
+        cmd1 = 'MakeDir(share_id=a, parent_id=b, name=c, marker=d)'
+        cmd2 = 'GetPublicFiles'
+        self.sd._process_mq([cmd1])
+        self.sd._process_mq([cmd2])
+        self.sd._process_mq([cmd1, cmd2])
+        self.assertEqual(len(self.sd.meta_queue), 2)
+
+        # check the data
+        mqit = self.sd.meta_queue[0]
+        self.assertEqual(mqit.operation, 'MakeDir')
+        self.assertEqual(mqit.path, '/?.../c')
+        self.assertEqual(mqit.share, 'a')
+        self.assertEqual(mqit.node, None)
+        mqit = self.sd.meta_queue[1]
+        self.assertEqual(mqit.operation, 'GetPublicFiles')
+        self.assertEqual(mqit.path, None)
+        self.assertEqual(mqit.share, None)
+        self.assertEqual(mqit.node, None)
+
 
 class StateTests(unittest.TestCase):
     """Test State class."""
 
     def test_initial(self):
         """Initial state for vals."""
-        st = State(None)
-        self.assertEqual(st.name, None)
+        st = State()
+        self.assertEqual(st.name, '')
 
     def test_set_one_value(self):
         """Set one value."""
-        st = State(None)
+        st = State()
         st._set(name=55)
 
         # check the one is set, the rest not
         self.assertEqual(st.name, 55)
-        self.assertEqual(st.description, None)
+        self.assertEqual(st.description, '')
 
     def test_set_two_values(self):
         """Set two values."""
-        st = State(None)
+        st = State()
         st._set(name=55, description=77)
 
         # check those two are set, the rest not
         self.assertEqual(st.name, 55)
         self.assertEqual(st.description, 77)
-        self.assertEqual(st.is_error, None)
+        self.assertFalse(st.is_error)
 
     def test_bad_value(self):
         """Set a value that should not."""
-        st = State(None)
+        st = State()
         self.assertRaises(AttributeError, st._set, not_really_allowed=44)
 
 
@@ -429,10 +504,15 @@
         f = lambda *a, **k: setattr(self, 'called', True)
         setattr(obj, method_name, f)
 
+    def flag_called(self, obj, method_name):
+        """Replace callback to flag called."""
+        f = lambda *a, **k: setattr(self, 'called', True)
+        setattr(obj, method_name, f)
+
     def test_defaults_are_callable(self):
         """Check the attributes are callable."""
         meths = (self.sd._get_content_queue, self.sd._get_meta_queue,
-                 self.sd._get_started, self.sd._do_start, self.sd._do_quit,
+                 self.sd._do_start, self.sd._do_quit,
                  self.sd._do_connect, self.sd._do_disconnect)
         for meth in meths:
             self.assertTrue(callable(meth), "Meth %r is not callable" % meth)
@@ -471,12 +551,13 @@
 
     def test_is_started_yes(self):
         """Check is_started, True."""
-        self.sd._get_started = lambda: True
+        # simulate the signal that indicates the name was registered
+        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', '', 'yes')
         self.assertTrue(self.sd.current_state.is_started)
 
     def test_is_started_no(self):
         """Check is_started, False."""
-        self.sd._get_started = lambda: False
+        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', 'yes', '')
         self.assertFalse(self.sd.current_state.is_started)
 
     def test_start(self):
@@ -502,3 +583,67 @@
         self.mpatch_called(self.sd, '_do_disconnect')
         self.sd.disconnect()
         self.assertTrue(self.called)
+
+    def test_on_started(self):
+        """Called when SD started."""
+        self.flag_called(self.sd, 'on_started_callback')
+
+        # simulate the signal that indicates the name was registered
+        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', '', 'yes')
+        self.assertTrue(self.called)
+
+    def test_on_stopped(self):
+        """Called when SD stopped."""
+        self.flag_called(self.sd, 'on_stopped_callback')
+
+        # simulate the signal that indicates the name was registered
+        self.sd._on_name_owner_changed('com.ubuntuone.SyncDaemon', 'yes', '')
+        self.assertTrue(self.called)
+
+    def test_on_connected(self):
+        """Called when SD connected."""
+        self.flag_called(self.sd, 'on_connected_callback')
+
+        # first signal with connected in True
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='', queues='queues',
+                 connection='connection')
+        self.sd._on_status_changed(d)
+        self.assertTrue(self.called)
+
+    def test_on_disconnected(self):
+        """Called when SD disconnected."""
+        self.flag_called(self.sd, 'on_disconnected_callback')
+
+        # connect and disconnect
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='', queues='queues',
+                 connection='connection')
+        self.sd._on_status_changed(d)
+        d['is_connected'] = ''
+        self.sd._on_status_changed(d)
+        self.assertTrue(self.called)
+
+    def test_on_online(self):
+        """Called when SD goes online."""
+        self.flag_called(self.sd, 'on_online_callback')
+
+        # first signal with online in True
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='True', queues='queues',
+                 connection='connection')
+        self.sd._on_status_changed(d)
+        self.assertTrue(self.called)
+
+    def test_on_offline(self):
+        """Called when SD goes offline."""
+        self.flag_called(self.sd, 'on_offline_callback')
+
+        # go online and then offline
+        d = dict(name='name', description='description', is_error='',
+                 is_connected='True', is_online='True', queues='queues',
+                 connection='connection')
+        self.sd._on_status_changed(d)
+        d['is_online'] = ''
+        self.sd._on_status_changed(d)
+        self.assertTrue(self.called)