Merge lp:~facundo/ubuntuone-client/unleashed--finish-dbus-changes into lp:ubuntuone-client

[Facundo Batista]

Finish DBus changes after unleashed (LP: #720802, LP: #727344)

Finish DBus changes after unleashed

The "schedule_next" option is removed, because with unleashed queues the commands are no longer ordered.

New signals are sent through DBus: RequestQueueAdded and RequestQueueRemoved, with information about the command that was added/removed (the internal info, the type of operation, and its id so external parties can follow what started/finished).

Also, as part of some refactor of how the internal command data is handled to send through DBus, I made explicit support for markers (and now default to str() all unknown, to prevent future issues).

Tests included for everything.

[John O'Brien (jdobrien)]

Looks good, nice cleanup and fixes. Test pass.

review: Approve

[Facundo Batista (facundo)]

Approving with one review

review: Approve

=== modified file 'bin/u1sdtool'
--- bin/u1sdtool	2011-02-23 17:46:09 +0000
+++ bin/u1sdtool	2011-03-02 18:42:58 +0000
@@ -183,9 +183,6 @@
     elif options.waiting_content:
         d = sync_daemon_tool.waiting_content()
         d.addCallback(lambda r: show_waiting_content(r, out))
-    elif options.schedule_next:
-        share_id, node_id = options.schedule_next
-        d = sync_daemon_tool.schedule_next(share_id, node_id)
     elif options.start:
         d = sync_daemon_tool.start()
     else:
@@ -280,10 +277,6 @@
                       action='store_true',
                       help="Get the waiting metadata list - Warning: this "
                       "option is deprecated, use '--waiting' instead")
-    parser.add_option("", "--schedule-next", dest="schedule_next", 
-                      metavar="SHARE_ID NODE_ID", nargs=2, type='string',
-                      help="Move the node to be the next in the queue of "
-                      "waiting commands")
     parser.add_option("", "--start", dest="start", action='store_true', 
                       help="Start syncdaemon if it's not running")
 

=== modified file 'docs/man/u1sdtool.1'
--- docs/man/u1sdtool.1	2011-02-23 15:11:36 +0000
+++ docs/man/u1sdtool.1	2011-03-02 18:42:58 +0000
@@ -78,9 +78,6 @@
 \-\-waiting-content
 .br
 .B u1sdtool
-\-\-schedule-next=SHARE_ID NODE_ID
-.br
-.B u1sdtool
 \-\-start
 
 .SH DESCRIPTION
@@ -217,9 +214,6 @@
 .TP
 \fB\-\-waiting-content\fR
 Get the waiting content list (NOTE: This option is deprecated and will go away shortly)
-.TP
-\fB\-\-schedule-next\fR=\fISHARE_ID \fINODE_ID\fR
-Move the node to be the next in the queue of waiting commands
 .RS
 .TP
 .I SHARE_ID

=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2011-02-28 16:24:21 +0000
+++ tests/platform/linux/test_dbus.py	2011-03-02 18:42:58 +0000
@@ -594,7 +594,8 @@
         c1 = FakeCommand("share_id", "node_id_a", other=123)
         c2 = FakeCommand("share_id", "node_id_b", other=None)
         c2.running = False
-        self.action_q.queue.waiting.extend([c1, c2])
+        c3 = FakeCommand("share_id", "node_id_c", other=MDMarker('bar'))
+        self.action_q.queue.waiting.extend([c1, c2, c3])
 
         # testing time
         client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
@@ -602,22 +603,19 @@
 
         def waiting_handler(result):
             """Waiting reply handler."""
-            self.assertEqual(2, len(result))
-            node_a, node_b = result
-            n_a_name, n_a_data = node_a
-            n_b_name, n_b_data = node_b
-
-            self.assertEqual('FakeCommand', n_a_name)
-            self.assertEqual('share_id', str(n_a_data['share_id']))
-            self.assertEqual('node_id_a', str(n_a_data['node_id']))
-            self.assertEqual('True', str(n_a_data['running']))
-            self.assertEqual('123', str(n_a_data['other']))
-
-            self.assertEqual('FakeCommand', n_b_name)
-            self.assertEqual('share_id', str(n_b_data['share_id']))
-            self.assertEqual('node_id_b', str(n_b_data['node_id']))
-            self.assertEqual('', str(n_b_data['running']))
-            self.assertEqual('None', str(n_b_data['other']))
+            node_a, node_b, node_c = result
+
+            should = dict(share_id='share_id', node_id='node_id_a',
+                          running='True', other='123')
+            self.assertEqual(node_a, ('FakeCommand', should))
+
+            should = dict(share_id='share_id', node_id='node_id_b',
+                          running='', other='None')
+            self.assertEqual(node_b, ('FakeCommand', should))
+
+            should = dict(share_id='share_id', node_id='node_id_c',
+                          running='True', other='marker:bar')
+            self.assertEqual(node_c, ('FakeCommand', should))
 
             # OK, we're done
             d.callback(True)
@@ -1824,6 +1822,40 @@
         self.main.event_q.push('SYS_QUEUE_REMOVED', command=cmd)
         return d
 
+    def test_sys_queue_added(self):
+        """Test the signal because a command was removed from the queue."""
+        d = defer.Deferred()
+        def check(op_name, op_id, data):
+            self.assertEqual(op_name, 'FakeCommand')
+            self.assertEqual(op_id, str(id(cmd)))
+            should = dict(share_id='share', node_id='node',
+                          running='True', other='123')
+            self.assertEqual(data, should)
+            d.callback(True)
+        rec = self.bus.add_signal_receiver(check,
+                                           signal_name='RequestQueueAdded')
+        self.signal_receivers.add(rec)
+        cmd = FakeCommand('share', 'node', other=123)
+        self.main.event_q.push('SYS_QUEUE_ADDED', command=cmd)
+        return d
+
+    def test_sys_queue_removed(self):
+        """Test the signal because a command was removed from the queue."""
+        d = defer.Deferred()
+        def check(op_name, op_id, data):
+            self.assertEqual(op_name, 'FakeCommand')
+            self.assertEqual(op_id, str(id(cmd)))
+            should = dict(share_id='share', node_id='node',
+                          running='True', other='marker:foo')
+            self.assertEqual(data, should)
+            d.callback(True)
+        rec = self.bus.add_signal_receiver(check,
+                                           signal_name='RequestQueueRemoved')
+        self.signal_receivers.add(rec)
+        cmd = FakeCommand('share', 'node', other=MDMarker('foo'))
+        self.main.event_q.push('SYS_QUEUE_REMOVED', command=cmd)
+        return d
+
     def test_status_changed(self):
         """Test the DBus signals in Status."""
         client = DBusClient(self.bus, '/status', DBUS_IFACE_STATUS_NAME)
@@ -3519,6 +3551,7 @@
                                 error_handler=self.error_handler)
         yield d
 
+
 class TestStatusEmitSignals(DBusTwistedTestCase, MockerTestCase):
     """Test that the emit method have been correctly implemented."""
 
@@ -3535,6 +3568,22 @@
         # will assert that the signal method was called
         self.status.emit_content_queue_changed()
 
+    def test_emit_requestqueue_removed(self):
+        """Emit RequestQueueRemoved."""
+        self.status.RequestQueueRemoved = self.signal_method
+        self.signal_method('name', 'id', {})
+        self.mocker.replay()
+        # will assert that the signal method was called
+        self.status.emit_requestqueue_removed('name', 'id', {})
+
+    def test_emit_requestqueue_added(self):
+        """Emit RequestQueueAdded."""
+        self.status.RequestQueueAdded = self.signal_method
+        self.signal_method('name', 'id', {})
+        self.mocker.replay()
+        # will assert that the signal method was called
+        self.status.emit_requestqueue_added('name', 'id', {})
+
     def test_emit_invalid_name(self):
         """Emit InvalidName."""
         dirname = 'dirname'

=== modified file 'tests/platform/test_interaction_interfaces.py'
--- tests/platform/test_interaction_interfaces.py	2011-02-28 16:24:21 +0000
+++ tests/platform/test_interaction_interfaces.py	2011-03-02 18:42:58 +0000
@@ -69,15 +69,6 @@
         self.mocker.replay()
         self.assertEqual(result, self.status.waiting_content())
 
-    def test_schedule_next(self):
-        """Test if the method is relayed."""
-        share_id = 'share_id'
-        node_id = 'node_id'
-        self.syncdaemon_status.schedule_next(share_id, node_id)
-        self.mocker.replay()
-        # nothing is returned, just execute the code
-        self.status.schedule_next(share_id, node_id)
-
     def test_current_uploads(self):
         """Test if the method is relayed."""
         result = 'uploading'
@@ -154,8 +145,8 @@
         """Test if the method is relayed."""
         result = 'nirvana'
         last_event_interval = 'interval'
-        reply_handler = lambda: None 
-        error_handler = lambda: None 
+        reply_handler = lambda: None
+        error_handler = lambda: None
         self.service.wait_for_nirvana(last_event_interval, MATCH(callable),
             MATCH(callable))
         self.mocker.result(result)
@@ -165,8 +156,8 @@
 
     def test_quit(self):
         """Test if the method is relayed."""
-        reply_handler = lambda: None 
-        error_handler = lambda: None 
+        reply_handler = lambda: None
+        error_handler = lambda: None
         self.service.quit(MATCH(callable), MATCH(callable))
         self.mocker.replay()
         self.sync.quit(reply_handler, error_handler)
@@ -246,8 +237,8 @@
     def test_accept_share(self):
         """Test if the method is relayed."""
         share_id = 'id'
-        reply_handler = lambda: None 
-        error_handler = lambda: None 
+        reply_handler = lambda: None
+        error_handler = lambda: None
         self.syncdaemon_shares.accept_share(share_id, MATCH(callable),
             MATCH(callable))
         self.mocker.replay()
@@ -256,8 +247,8 @@
     def test_reject_share(self):
         """Test if the method is relayed."""
         share_id = 'id'
-        reply_handler = lambda: None 
-        error_handler = lambda: None 
+        reply_handler = lambda: None
+        error_handler = lambda: None
         self.syncdaemon_shares.reject_share(share_id, MATCH(callable),
             MATCH(callable))
         self.mocker.replay()

=== modified file 'ubuntuone/platform/linux/dbus_interface.py'
--- ubuntuone/platform/linux/dbus_interface.py	2011-02-28 16:24:21 +0000
+++ ubuntuone/platform/linux/dbus_interface.py	2011-03-02 18:42:58 +0000
@@ -25,6 +25,7 @@
 
 from twisted.internet import defer
 from twisted.python.failure import Failure
+from ubuntuone.syncdaemon.interfaces import IMarker
 from ubuntuone.platform.linux.credentials import (
     DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
     DBUS_CREDENTIALS_IFACE)
@@ -74,14 +75,30 @@
 
 
 def get_classname(thing):
-    """
-    Get the clasname of the thing.
+    """Get the clasname of the thing.
+
     If we could forget 2.5, we could do attrgetter('__class__.__name__')
     Alas, we can't forget it yet.
     """
     return thing.__class__.__name__
 
 
+def sanitize_dict(data):
+    """Sanitize *IN PLACE* a dict values to go through DBus."""
+    for k, v in data.items():
+        if IMarker.providedBy(v):
+            # this goes first, as it also is instance of basestring
+            data[k] = repr(v)
+        elif isinstance(v, basestring):
+            pass  # to avoid str() to already strings
+        elif isinstance(v, bool):
+            data[k] = bool_str(v)
+        elif v is None:
+            data[k] = 'None'
+        else:
+            data[k] = str(v)
+
+
 class DBusExposedObject(dbus.service.Object):
     """Base class that provides some helper methods to DBus exposed objects."""
     #__metaclass__ = InterfaceType
@@ -162,56 +179,41 @@
         logger.debug('called current_downloads')
         return self.syncdaemon_status.current_downloads()
 
-    @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='a(sa{sv})')
+    @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='a(sa{ss})')
     def waiting(self):
         """Return a list of the operations in action queue."""
         logger.debug('called waiting')
         commands = self.syncdaemon_status.waiting()
         for op, data  in commands:
-            for k, v in data.items():
-                if isinstance(v, bool):
-                    data[k] = bool_str(v)
-                elif v is None:
-                    data[k] = 'None'
+            sanitize_dict(data)
         return commands
 
     @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='a(sa{ss})')
     def waiting_metadata(self):
         """Return a list of the operations in the meta-queue.
 
-        As we don't have meta-queue anymore, this is faked.
+        As we don't have meta-queue anymore, this is faked.  This method
+        is deprecated, and will go away in a near future.
         """
         logger.debug('called waiting_metadata')
         commands = self.syncdaemon_status.waiting_metadata()
         for op, data  in commands:
-            for k, v in data.items():
-                if isinstance(v, bool):
-                    data[k] = bool_str(v)
+            sanitize_dict(data)
         return commands
 
     @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='aa{ss}')
     def waiting_content(self):
         """Return a list of files that are waiting to be up- or downloaded.
 
-        As we don't have content-queue anymore, this is faked.
+        As we don't have content-queue anymore, this is faked.  This method
+        is deprecated, and will go away in a near future.
         """
         logger.debug('called waiting_content')
         commands = self.syncdaemon_status.waiting_content()
         for data in commands:
-            for k, v in data.items():
-                if isinstance(v, bool):
-                    data[k] = bool_str(v)
+            sanitize_dict(data)
         return commands
 
-    @dbus.service.method(DBUS_IFACE_STATUS_NAME, in_signature='ss')
-    def schedule_next(self, share_id, node_id):
-        """
-        Make the command on the given share and node be next in the
-        queue of waiting commands.
-        """
-        logger.debug('called schedule_next')
-        self.syncdaemon_status.schedule_next(share_id, node_id)
-
     @dbus.service.method(DBUS_IFACE_STATUS_NAME, out_signature='aa{ss}')
     def current_uploads(self):
         """Return a list of files with a upload in progress."""
@@ -260,14 +262,31 @@
 
     @dbus.service.signal(DBUS_IFACE_STATUS_NAME)
     def ContentQueueChanged(self):
-        """Fire a signal to notify that the content queue has changed."""
+        """Fire a signal to notify that the content queue has changed.
+
+        This signal is deprecated, and will go away in a near future.
+        """
 
     @dbus.service.signal(DBUS_IFACE_STATUS_NAME)
     def MetaQueueChanged(self):
-        """Fire a signal to notify that the meta queue has changed."""
+        """Fire a signal to notify that the meta queue has changed.
+
+        This signal is deprecated, and will go away in a near future.
+        """
+
+    @dbus.service.signal(DBUS_IFACE_STATUS_NAME, signature='ssa{ss}')
+    def RequestQueueAdded(self, op_name, op_id, data):
+        """Fire a signal to notify that this command was added."""
+
+    @dbus.service.signal(DBUS_IFACE_STATUS_NAME, signature='ssa{ss}')
+    def RequestQueueRemoved(self, op_name, op_id, data):
+        """Fire a signal to notify that this command was removed."""
 
     def emit_content_queue_changed(self):
-        """Emit ContentQueueChanged."""
+        """Emit ContentQueueChanged.
+
+        This signal is deprecated, and will go away in a near future.
+        """
         self.ContentQueueChanged()
 
     def emit_invalid_name(self, dirname, filename):
@@ -324,9 +343,22 @@
         self.AccountChanged(info_dict)
 
     def emit_metaqueue_changed(self):
-        """Emit MetaQueueChanged."""
+        """Emit MetaQueueChanged.
+
+        This signal is deprecated, and will go away in a near future.
+        """
         self.MetaQueueChanged()
 
+    def emit_requestqueue_added(self, op_name, op_id, data):
+        """Emit RequestQueueAdded."""
+        sanitize_dict(data)
+        self.RequestQueueAdded(op_name, str(op_id), data)
+
+    def emit_requestqueue_removed(self, op_name, op_id, data):
+        """Emit RequestQueueRemoved."""
+        sanitize_dict(data)
+        self.RequestQueueRemoved(op_name, str(op_id), data)
+
 
 class Events(DBusExposedObject):
     """The events of the system translated to D-BUS signals.

=== modified file 'ubuntuone/platform/linux/tools.py'
--- ubuntuone/platform/linux/tools.py	2011-02-28 16:24:21 +0000
+++ ubuntuone/platform/linux/tools.py	2011-03-02 18:42:58 +0000
@@ -661,18 +661,6 @@
                                   error_handler=d.errback)
         return d
 
-    def schedule_next(self, share_id, node_id):
-        """Make the command on the given share_id and node_id be next in the
-        queue of waiting commands.
-        """
-        d = defer.Deferred()
-        status_client = DBusClient(self.bus, '/status',
-                                   DBUS_IFACE_STATUS_NAME)
-        status_client.call_method('schedule_next', share_id, node_id,
-                                  reply_handler=d.callback,
-                                  error_handler=d.errback)
-        return d
-
     def start(self):
         """Start syncdaemon using the StartServiceByName method
         if it's not running.

=== modified file 'ubuntuone/platform/windows/dbus_interface.py'
--- ubuntuone/platform/windows/dbus_interface.py	2011-02-21 15:14:08 +0000
+++ ubuntuone/platform/windows/dbus_interface.py	2011-03-02 18:42:58 +0000
@@ -37,20 +37,20 @@
 logger = logging.getLogger("ubuntuone.SyncDaemon.Pb")
 
 
-def remote_handler(handler):    
+def remote_handler(handler):
     if handler:
         handler = lambda x: handler.callRemote('execute', x)
     return handler
 
 class RemoteMeta(type):
     """Append remte_ to the remote methods.
-    
+
     Remote has to be appended to the remote method to work over pb but this
     names cannot be used since the other platforms do not expect the remote
     prefix. This metaclass create those prefix so that the methods can be
     correctly called.
     """
-    
+
     def __new__(cls, name, bases, attrs):
         remote_calls = attrs.get('remote_calls', None)
         if remote_calls:
@@ -69,7 +69,7 @@
     def remote_register_to_signals(self, client):
         """Allow a client to register to a signal."""
         self.clients.append(client)
-    
+
     def emit_signal(self, signal_name, *args, **kwargs):
         """Emit the given signal to the clients."""
         for current_client in self.clients:
@@ -82,17 +82,16 @@
     """ Represent the status of the syncdaemon """
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'current_status',
         'current_downloads',
         'waiting_metadata',
         'waiting_content',
-        'schedule_next',
         'current_uploads',
     ]
-    
+
     def __init__(self, main, action_queue, fs_manager):
         """ Creates the instance."""
         super(Status, self).__init__()
@@ -127,14 +126,6 @@
         logger.debug('called waiting_content')
         return self.syncdaemon_status.waiting_content()
 
-    def schedule_next(self, share_id, node_id):
-        """
-        Make the command on the given share and node be next in the
-        queue of waiting commands.
-        """
-        logger.debug('called schedule_next')
-        self.syncdaemon_status.schedule_next(share_id, node_id)
-
     def current_uploads(self):
         """ return a list of files with a upload in progress """
         logger.debug('called current_uploads')
@@ -170,7 +161,7 @@
         """Emit DownloadFileProgress."""
         for k, v in info.copy().items():
             info[str(k)] = str(v)
-        self.emit_signal('on_download_file_progress', download, info)        
+        self.emit_signal('on_download_file_progress', download, info)
 
     def emit_download_finished(self, download, **info):
         """Emit DownloadFinished."""
@@ -208,7 +199,7 @@
     """The events of the system translated to ipc signals."""
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'push_event',
@@ -235,7 +226,7 @@
     """ The Daemon ipc interface. """
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'connect',
@@ -311,7 +302,7 @@
     """ An ipc interface to the FileSystem Manager. """
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'get_metadata',
@@ -354,7 +345,7 @@
     """A ipc interface to interact with shares."""
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
        'get_shares',
@@ -388,7 +379,7 @@
         logger.debug('accept_share: %r', share_id)
         self.syncdaemon_shares.accept_share(share_id,
             remote_handler(reply_handler), remote_handler(error_handler))
-        
+
     def reject_share(self, share_id, reply_handler=None, error_handler=None):
         """Reject a share."""
         logger.debug('reject_share: %r', share_id)
@@ -485,7 +476,7 @@
 
     def refresh_shares(self):
         """ Refresh the share list, requesting it to the server. """
-        self.syncdaemon_shares.refresh_shares() 
+        self.syncdaemon_shares.refresh_shares()
 
     def get_shared(self):
         """ returns a list of dicts, each dict represents a shared share.
@@ -531,7 +522,7 @@
     """ The Syncdaemon config/settings ipc interface. """
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'get_throttling_limits',
@@ -551,7 +542,7 @@
         'enable_show_all_notifications',
         'disable_show_all_notifications'
     ]
-    
+
     def __init__(self, main, action_queue):
         """ Creates the instance."""
         super(Config, self).__init__()
@@ -653,7 +644,7 @@
     """An interface to interact with User Defined Folders"""
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'create',
@@ -664,7 +655,7 @@
         'get_info',
         'refresh_volumes',
     ]
-    
+
     def __init__(self, volume_manager, fs_manager):
         """Creates the instance."""
         super(Folders, self).__init__()
@@ -760,13 +751,13 @@
     """An IPC interface for handling public files."""
 
     __metaclass__ = RemoteMeta
-    
+
     # calls that will be accessible remotly
     remote_calls = [
         'change_public_access',
         'get_public_files',
     ]
-    
+
     def __init__(self, fs_manager, action_queue):
         super(PublicFiles, self).__init__()
         self.syncdaemon_public_files = SyncdaemonPublicFiles(fs_manager,

=== modified file 'ubuntuone/syncdaemon/interaction_interfaces.py'
--- ubuntuone/syncdaemon/interaction_interfaces.py	2011-02-23 19:56:01 +0000
+++ ubuntuone/syncdaemon/interaction_interfaces.py	2011-03-02 18:42:58 +0000
@@ -155,14 +155,6 @@
                 waiting_content.append(data)
         return waiting_content
 
-    def schedule_next(self, share_id, node_id):
-        """
-        Make the command on the given share and node be next in the
-        queue of waiting commands.
-        """
-        logger.debug('called schedule_next')
-        self.action_queue.content_queue.schedule_next(share_id, node_id)
-
     def current_uploads(self):
         """return a list of files with a upload in progress"""
         logger.debug('called current_uploads')
@@ -1105,12 +1097,33 @@
         self.interface.sync.emit_quota_exceeded(volume_dict)
 
     def handle_SYS_QUEUE_ADDED(self, command):
-        """Handle SYS_QUEUE_ADDED."""
+        """Handle SYS_QUEUE_ADDED.
+
+        The content and meta queue changed signals are deprecacted and
+        will go away in a near future.
+        """
         if isinstance(command, (Upload, Download)):
             self.interface.status.emit_content_queue_changed()
         else:
             self.interface.status.emit_metaqueue_changed()
 
+        data = command.to_dict()
+        op_name = command.__class__.__name__
+        op_id = id(command)
+        self.interface.status.emit_requestqueue_added(op_name, op_id, data)
+
     def handle_SYS_QUEUE_REMOVED(self, command):
-        """Handle SYS_QUEUE_REMOVED."""
-        self.handle_SYS_QUEUE_ADDED(command)
+        """Handle SYS_QUEUE_REMOVED.
+
+        The content and meta queue changed signals are deprecacted and
+        will go away in a near future.
+        """
+        if isinstance(command, (Upload, Download)):
+            self.interface.status.emit_content_queue_changed()
+        else:
+            self.interface.status.emit_metaqueue_changed()
+
+        data = command.to_dict()
+        op_name = command.__class__.__name__
+        op_id = id(command)
+        self.interface.status.emit_requestqueue_removed(op_name, op_id, data)