Merge lp:~verterok/ubuntuone-client/fix-645519-stable-1-4 into lp:ubuntuone-client

[Guillermo Gonzalez]

This branch fix delete_share DBus method to actually delete shares (from_me), and mainting support for deleting share volumes (to me).

[dobey (dobey)]

Wrong branch.

review: Needs Resubmitting

Unmerged revisions

718. By Guillermo Gonzalez on 2010-09-23

fix duplicated docstring

717. By Guillermo Gonzalez on 2010-09-23

Fix delete_share DBus method to actually delete shares

716. By Roman Yepishev on 2010-09-23

Reuse shared structure to avoid crashes due to referencing already released memory.

715. By John Lenton on 2010-09-22

correctly stringify http errors that occur in restclient (in another process), and fix the call to bus.get_object in the case of removing the current machine's token.

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-09-07 16:02:04 +0000
+++ contrib/testing/testcase.py	2010-09-23 18:06:01 +0000
@@ -145,6 +145,8 @@
         """Send the event."""
         self.eq.push('AQ_ANSWER_SHARE_OK', share_id, answer)
 
+    def delete_share(self, share_id):
+        """Stub."""
 
     def disconnect(self, *a, **k):
         """Stub implementation."""

=== modified file 'nautilus/ubuntuone-nautilus.c'
--- nautilus/ubuntuone-nautilus.c	2010-09-23 13:37:34 +0000
+++ nautilus/ubuntuone-nautilus.c	2010-09-23 18:06:01 +0000
@@ -328,6 +328,142 @@
   iface->get_widget = ubuntuone_nautilus_get_location_widget;
 }
 
+<<<<<<< TREE
+=======
+static void __cb_data_free (struct _CBData * data, gboolean destroy) {
+  if (!data)
+    return;
+
+  data->uon = NULL;
+  data->parent = NULL;
+  data->make_public = FALSE;
+
+  if (data->path) {
+    g_free (data->path);
+    data->path = NULL;
+  }
+
+  if (destroy) {
+    g_free (data);
+    data = NULL;
+  }
+
+}
+
+/* Menu callbacks */
+static void ubuntuone_nautilus_public_meta (SyncdaemonFilesystemInterface *interface,
+					    gboolean success,
+					    SyncdaemonMetadata *metadata,
+					    gpointer user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  GError * error = NULL;
+  const gchar * share_id, * node_id;
+  SyncdaemonInterface *public;
+
+  if (!success) {
+    g_warning ("ERROR: getting metadata for public file");
+    return;
+  }
+
+  share_id = syncdaemon_metadata_get_share_id (metadata);
+  node_id = syncdaemon_metadata_get_node_id (metadata);
+
+  public = syncdaemon_daemon_get_publicfiles_interface (data->uon->syncdaemon);
+  if (public != NULL) {
+    syncdaemon_publicfiles_interface_change_public_access (SYNCDAEMON_PUBLICFILES_INTERFACE (public),
+							   share_id, node_id, data->make_public);
+  }
+}
+
+static void ubuntuone_nautilus_unsubscribe_folder (NautilusMenuItem *item,
+						   gpointer user_data) {
+  SyncdaemonInterface *interface;
+  struct _CBData * data = (struct _CBData *) user_data;
+
+  /* Perform the removal of this folder */
+  interface = syncdaemon_daemon_get_folders_interface (data->uon->syncdaemon);
+  if (interface != NULL) {
+    SyncdaemonFolderInfo *folder_info;
+
+    folder_info = syncdaemon_folders_interface_get_info (SYNCDAEMON_FOLDERS_INTERFACE (interface),
+                                                         data->path);
+    if (folder_info != NULL) {
+      if (ubuntuone_nautilus_check_shares_and_public_files (data->uon, folder_info, data->parent)) {
+        syncdaemon_folders_interface_delete (SYNCDAEMON_FOLDERS_INTERFACE (interface),
+                                             syncdaemon_folder_info_get_volume_id (folder_info));
+      }
+      g_object_unref (G_OBJECT (folder_info));
+    }
+  }
+}
+
+static void ubuntuone_nautilus_subscribe_folder (NautilusMenuItem *item,
+						 gpointer user_data) {
+  SyncdaemonInterface *interface;
+  struct _CBData * data = (struct _CBData *) user_data;
+
+  /* Perform the addition of this folder */
+  interface = syncdaemon_daemon_get_folders_interface (data->uon->syncdaemon);
+  if (interface != NULL) {
+    /* If there is no user authenticated, make Syncdaemon do so */
+    if (!syncdaemon_authentication_has_credentials (syncdaemon_daemon_get_authentication (data->uon->syncdaemon)))
+      syncdaemon_daemon_connect (data->uon->syncdaemon);
+    syncdaemon_folders_interface_create (SYNCDAEMON_FOLDERS_INTERFACE (interface),
+                                         data->path);
+  }
+}
+
+static void ubuntuone_nautilus_copy_public_url (NautilusMenuItem * item,
+						gpointer user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  gchar * url;
+
+  url = g_hash_table_lookup (data->uon->public, data->path);
+  gtk_clipboard_set_text (gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
+			  url, strlen (url));
+  gtk_clipboard_store (gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+}
+
+static void ubuntuone_nautilus_toggle_publicity (NautilusMenuItem * item,
+						 gpointer user_data) {
+  SyncdaemonFilesystemInterface *interface;
+  struct _CBData * data = (struct _CBData *) user_data;
+
+  interface = (SyncdaemonFilesystemInterface *) syncdaemon_daemon_get_filesystem_interface (data->uon->syncdaemon);
+  if (interface != NULL) {
+    /* we know this will not be a directory (so no need for _and_quick_tree_synced) */
+    syncdaemon_filesystem_interface_get_metadata_async (interface, data->path, FALSE,
+							(SyncdaemonGotMetadataFunc) ubuntuone_nautilus_public_meta,
+							data);
+  }
+
+  g_hash_table_replace (data->uon->public, g_strdup (data->path), UPDATE_PENDING);
+  ubuntuone_nautilus_reset_emblem (data->uon, data->path);
+}
+
+static void ubuntuone_nautilus_share_folder (NautilusMenuItem * item,
+					     gpointer * user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  GtkWidget * dialog;
+
+  dialog = share_dialog_new (data->parent, data->uon, data->path);
+  gtk_widget_show (dialog);
+}
+
+static void ubuntuone_nautilus_unshare_folder (NautilusMenuItem * item,
+					       gpointer * user_data) {
+  struct _CBData * data = (struct _CBData *) user_data;
+  gchar * share_id;
+  SyncdaemonSharesInterface *interface;
+
+  interface = (SyncdaemonSharesInterface *) syncdaemon_daemon_get_shares_interface (data->uon->syncdaemon);
+  if (interface != NULL) {
+    share_id = g_hash_table_lookup (data->uon->shares, data->path);
+    syncdaemon_shares_interface_delete (interface, share_id);
+  }
+}
+
+>>>>>>> MERGE-SOURCE
 /* Menu provider */
 static GList *
 ubuntuone_nautilus_get_menu_items (NautilusMenuProvider * provider,
@@ -335,8 +471,20 @@
 				   GList * files)
 {
   UbuntuOneNautilus * uon;
+<<<<<<< TREE
   GList *items = NULL;
   NautilusMenuItem *root_item;
+=======
+  NautilusFileInfo * file;
+  NautilusMenu * submenu;
+  NautilusMenuItem * root_item;
+  GList * items = NULL;
+  gchar * path;
+  gchar * item;
+  gchar * homedir_path;
+  gboolean is_managed, is_root, is_udf, is_public, is_shared, is_pending;
+  gboolean is_inhome, is_dir, is_regular;
+>>>>>>> MERGE-SOURCE
 
   uon = UBUNTUONE_NAUTILUS (provider);
 
@@ -344,9 +492,266 @@
   if (!syncdaemon_daemon_is_ready (uon->syncdaemon))
     return NULL;
 
+<<<<<<< TREE
   root_item = context_menu_new (uon, window, files);
   if (root_item != NULL)
 	  items = g_list_append (items, root_item);
+=======
+  is_managed = is_root = is_udf = is_public = is_shared = is_pending = FALSE;
+  is_inhome = is_dir = is_regular = FALSE;
+
+  if (g_list_length (files) != 1)
+    return NULL;
+
+  file = g_list_nth_data (files, 0);
+  path = g_filename_from_uri (nautilus_file_info_get_uri (file), NULL, NULL);
+
+  if (path == NULL)
+    goto done;
+
+  if (ubuntuone_is_storagefs (uon, path, &is_root))
+    is_managed = TRUE;
+
+  homedir_path = g_strdup_printf ("%s/", g_get_home_dir());
+  if (strncmp (path, homedir_path, strlen (homedir_path)) == 0)
+	is_inhome = TRUE;
+  g_free (homedir_path);
+
+  if ((item = g_hash_table_lookup (uon->udfs, path)) != NULL) {
+    is_udf = TRUE;
+	if (strcmp (item, UPDATE_PENDING) == 0)
+	  is_pending = TRUE;
+  } else if ((item = g_hash_table_lookup (uon->public, path)) != NULL) {
+    is_public = TRUE;
+	if (strcmp (item, UPDATE_PENDING) == 0)
+	  is_pending = TRUE;
+  }
+  if (g_hash_table_lookup (uon->shares, path) != NULL)
+    is_shared = TRUE;
+
+  is_dir = nautilus_file_info_is_directory (file);
+  is_regular = nautilus_file_info_get_file_type (file) == G_FILE_TYPE_REGULAR;
+
+  /* Create new structure only if it does not already exist */
+  if (uon->cb_data)
+    __cb_data_free (uon->cb_data, FALSE);
+  else
+    uon->cb_data = g_new0 (struct _CBData, 1);
+
+  uon->cb_data->uon = uon;
+  uon->cb_data->parent = window;
+  uon->cb_data->path = g_strdup (path);
+
+  root_item = nautilus_menu_item_new ("ubuntuone",
+                                      _("_Ubuntu One"),
+                                      _("Ubuntu One options"),
+                                      "ubuntuone");
+  submenu = nautilus_menu_new ();
+  nautilus_menu_item_set_submenu (root_item, submenu);
+
+  items = g_list_append (items, root_item);
+
+  /* Share/unshare */
+  {
+    NautilusMenuItem * item;
+
+    if ((is_managed || is_udf) && !is_root && is_dir) {
+
+      item = nautilus_menu_item_new ("ubuntuone-share",
+                                     _("_Share..."),
+                                     _("Share this folder on Ubuntu One"),
+                                     "ubuntuone");
+          if (is_pending)
+            g_object_set (item, "sensitive", FALSE, NULL);
+
+      g_signal_connect (item, "activate",
+                        G_CALLBACK (ubuntuone_nautilus_share_folder),
+                        uon->cb_data);
+    } else {
+      /* the different tooltips will probably do us no good */
+      if (is_root) {
+        item = nautilus_menu_item_new ("ubuntuone-noshare-root",
+                                       _("_Share..."),
+                                       _("Sorry, you can't share the root of a Ubuntu One volume"),
+                                       "ubuntuone");
+      } else if (!(is_managed || is_udf)) {
+        item = nautilus_menu_item_new ("ubuntuone-noshare-unmanaged",
+                                       _("_Share..."),
+                                       _("Sorry, you can't share folders not managed by Ubuntu One"),
+                                       "ubuntuone");
+      } else {
+        item = nautilus_menu_item_new ("ubuntuone-noshare-unmanaged",
+                                       _("_Share..."),
+                                       _("Sorry, you can only share folders"),
+                                       "ubuntuone");
+      }
+      g_object_set (item, "sensitive", FALSE, NULL);
+    }
+
+    nautilus_menu_append_item (submenu, item);
+  }
+
+  if ((is_managed && is_shared) && !is_root && is_dir) {
+    NautilusMenuItem * item;
+
+    item = nautilus_menu_item_new ("ubuntuone-unshare",
+				   _("Stop _Sharing"),
+				   _("Stop sharing this folder on Ubuntu One"),
+				   "ubuntuone");
+	if (is_pending)
+	  g_object_set (item, "sensitive", FALSE, NULL);
+
+    g_signal_connect (item, "activate",
+		      G_CALLBACK (ubuntuone_nautilus_unshare_folder),
+		      uon->cb_data);
+    nautilus_menu_append_item (submenu, item);
+  }
+
+  {
+    /* UDF logic
+     *
+     * XXX: clean this up and separate the logic out and reuse this
+     * and locationbar somewhere (libsd?)
+     */
+    NautilusMenuItem * item = NULL;
+    if (is_dir && is_inhome) {
+      /* UDFs could be happening */
+      if (is_managed) {
+	if (strcmp (path, uon->managed) == 0) {
+	  /* the Ubuntu One directory, no UDFs */
+          item = nautilus_menu_item_new ("ubuntuone-no-disable-u1",
+                                         _("Stop Synchronizing This _Folder"),
+                                         _("Sorry, you can't stop synchronizing ~/Ubuntu One"),
+                                         "ubuntuone");
+          g_object_set (item, "sensitive", FALSE, NULL);
+	} else if (is_root) {
+	  /* the root of a UDF: disabling possible */
+
+	  item = nautilus_menu_item_new ("ubuntuone-disable-udf",
+					 _("Stop Synchronizing This _Folder"),
+					 _("Stop synchronizing this folder with Ubuntu One"),
+					 "ubuntuone");
+
+	  g_signal_connect (item, "activate",
+			    G_CALLBACK (ubuntuone_nautilus_unsubscribe_folder),
+			    uon->cb_data);
+	}
+      } else {
+	/* unmanaged */
+
+	item = nautilus_menu_item_new ("ubuntuone-enable-udf",
+				       _("Synchronize This _Folder"),
+				       _("Start synchronizing this folder with Ubuntu One"),
+				       "ubuntuone");
+
+	g_signal_connect (item, "activate",
+			  G_CALLBACK (ubuntuone_nautilus_subscribe_folder),
+			  uon->cb_data);
+      }
+    } else {
+      if (is_dir) {
+        item = nautilus_menu_item_new ("ubuntuone-no-disable-u1",
+				       _("Synchronize This _Folder"),
+				       _("Sorry, you can only synchronize folders within your home folder"),
+                                       "ubuntuone");
+      } else {
+        item = nautilus_menu_item_new ("ubuntuone-no-disable-u1",
+				       _("Synchronize This _Folder"),
+				       _("Sorry, you can only synchronize folders"),
+                                       "ubuntuone");
+      }
+      g_object_set (item, "sensitive", FALSE, NULL);
+    }
+    if (!item) {
+	item = nautilus_menu_item_new ("ubuntuone-no-udf-operation-possible",
+				       _("Synchronize This _Folder"),
+				       _("Synchronization not possible for this folder"),
+				       "ubuntuone");
+	g_object_set (item, "sensitive", FALSE, NULL);
+    }
+    nautilus_menu_append_item (submenu, item);
+  }
+
+  /* public files */
+  {
+    NautilusMenuItem * item = NULL, * urlitem = NULL;
+
+    if (is_managed && is_regular) {
+
+      if (is_public) {
+        urlitem = nautilus_menu_item_new ("ubuntuone-geturl",
+                                          _("Copy Web _Link"),
+                                          _("Copy the Ubuntu One public URL for this file to the clipboard."),
+                                          "ubuntuone");
+        if (is_pending)
+          g_object_set (urlitem, "sensitive", FALSE, NULL);
+
+        g_signal_connect (urlitem, "activate",
+                          G_CALLBACK (ubuntuone_nautilus_copy_public_url),
+                          uon->cb_data);
+        item = nautilus_menu_item_new ("ubuntuone-unpublish",
+                                       _("Stop _Publishing"),
+                                       _("No longer share this file with everyone via Ubuntu One."),
+                                       "ubuntuone");
+        if (is_pending)
+          g_object_set (item, "sensitive", FALSE, NULL);
+
+        uon->cb_data->make_public = FALSE;
+      } else {
+        item = nautilus_menu_item_new ("ubuntuone-publish",
+                                       _("_Publish"),
+                                       _("Make this file available to anyone via Ubuntu One."),
+                                       "ubuntuone");
+        uon->cb_data->make_public = TRUE;
+      }
+      g_signal_connect (item, "activate",
+                        G_CALLBACK (ubuntuone_nautilus_toggle_publicity),
+                        uon->cb_data);
+    }
+    if (!urlitem) {
+      urlitem = nautilus_menu_item_new ("ubuntuone-geturl",
+                                        _("Copy Web _Link"),
+                                        _("Sorry, no public URL for this file via Ubuntu One."),
+                                        "ubuntuone");
+      g_object_set (urlitem, "sensitive", FALSE, NULL);
+    }
+    if (!item) {
+      item = nautilus_menu_item_new ("ubuntuone-publish",
+                                     _("_Publish"),
+                                     _("Sorry, unable to publish via Ubuntu One."),
+                                     "ubuntuone");
+      g_object_set (item, "sensitive", FALSE, NULL);
+    }
+
+    nautilus_menu_append_item (submenu, item);
+    nautilus_menu_append_item (submenu, urlitem);
+  }
+
+  /* location bar enable/disable */
+  {
+    NautilusMenuItem * item;
+    if (show_location()) {
+      item = nautilus_menu_item_new ("ubuntuone-location-hide",
+                                     _("Hide _Ribbon"),
+                                     _("Do not show the Ubuntu One ribbon"
+                                       " in selected folders"),
+                                     "ubuntuone");
+    } else {
+      item = nautilus_menu_item_new ("ubuntuone-location-show",
+                                     _("Show _Ribbon in Some Folders"),
+                                     _("Show the Ubuntu One ribbon"
+                                       " in selected folders"),
+                                     "ubuntuone");
+    }
+    g_signal_connect (item, "activate",
+                      G_CALLBACK (toggle_location),
+                      uon->cb_data);
+    nautilus_menu_append_item (submenu, item);
+  }
+
+ done:
+  g_free (path);
+>>>>>>> MERGE-SOURCE
 
   return items;
 }
@@ -439,6 +844,11 @@
 static void ubuntuone_nautilus_finalize(GObject * object) {
   UbuntuOneNautilus * uon = UBUNTUONE_NAUTILUS(object);
 
+<<<<<<< TREE
+=======
+  __cb_data_free (uon->cb_data, TRUE);
+
+>>>>>>> MERGE-SOURCE
   if (uon->syncdaemon)
     g_object_unref (uon->syncdaemon);
 

=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2010-09-21 14:31:36 +0000
+++ tests/syncdaemon/test_action_queue.py	2010-09-23 18:06:01 +0000
@@ -51,7 +51,7 @@
     ActionQueue, ActionQueueCommand, ChangePublicAccess, CreateUDF,
     DeleteVolume, Download, ListVolumes,
     NoisyRequestQueue, RequestQueue, UploadProgressWrapper, Upload,
-    CreateShare, GetPublicFiles, GetDelta, GetDeltaFromScratch,
+    CreateShare, DeleteShare, GetPublicFiles, GetDelta, GetDeltaFromScratch,
     TRANSFER_PROGRESS_THRESHOLD, Unlink, Move, MakeFile, MakeDir,
     DeltaList, ZipQueue, DeferredMap, UniqueRequestQueue
 )
@@ -64,6 +64,7 @@
 VOLUME = uuid.UUID('12345678-1234-1234-1234-123456789abc')
 NODE = uuid.UUID('FEDCBA98-7654-3211-2345-6789ABCDEF12')
 USER = u'Dude'
+SHARE = uuid.uuid4()
 
 NO_OP = lambda *args, **kwargs: None
 
@@ -2680,6 +2681,54 @@
         self.assertEqual(len(self.queue), 0)
 
 
+class DeleteShareTestCase(ConnectedBaseTestCase):
+    """Test for DeleteShare ActionQueueCommand."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Init."""
+        yield super(DeleteShareTestCase, self).setUp()
+        request_queue = RequestQueue(name='fu', action_queue=self.action_queue)
+        self.command = DeleteShare(request_queue, SHARE)
+        vm = self.action_queue.main.vm
+        self.patch(vm, 'handle_AQ_DELETE_SHARE_OK', NO_OP)
+        self.patch(vm, 'handle_AQ_DELETE_SHARE_ERROR', NO_OP)
+
+    def test_run_returns_a_deferred(self):
+        """Test a deferred is returned."""
+        res = self.command._run()
+        self.assertTrue(isinstance(res, defer.Deferred), 'deferred returned')
+
+    def test_run_calls_protocol(self):
+        """Test protocol's delete_volume is called."""
+        self.called = False
+        def check(share_id):
+            """Take control over client's feature."""
+            self.called = True
+            self.assertEqual(SHARE, share_id)
+        self.patch(self.command.action_queue.client, 'delete_share', check)
+        self.command._run()
+        self.assertTrue(self.called, "command wasn't called")
+
+    def test_handle_success_push_event(self):
+        """Test AQ_DELETE_SHARE_OK is pushed on success."""
+        request = client.DeleteShare(self.action_queue.client, SHARE)
+        res = self.command.handle_success(success=request)
+        events = [('AQ_DELETE_SHARE_OK', (), {'share_id': SHARE})]
+        self.assertEqual(events, self.command.action_queue.event_queue.events)
+        self.assertEqual(request, res)
+
+    def test_handle_failure_push_event(self):
+        """Test AQ_DELETE_SHARE_ERROR is pushed on failure."""
+        msg = 'Something went wrong'
+        failure = Failure(DefaultException(msg))
+        res = self.command.handle_failure(failure=failure)
+        events = [('AQ_DELETE_SHARE_ERROR', (),
+                  {'share_id': SHARE, 'error': msg})]
+        self.assertEqual(events, self.command.action_queue.event_queue.events)
+        self.assertTrue(res is None)
+
+
 class SimpleAQTestCase(BasicTestCase):
     """Simple tests for AQ API."""
 

=== modified file 'tests/syncdaemon/test_dbus.py'
--- tests/syncdaemon/test_dbus.py	2010-09-13 16:55:35 +0000
+++ tests/syncdaemon/test_dbus.py	2010-09-23 18:06:01 +0000
@@ -2885,6 +2885,31 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_delete_share_from_me(self):
+        """Test for Shares.delete_share with share from_me."""
+        share_path = os.path.join(self.main.shares_dir, 'share')
+        share = Shared(path=share_path, volume_id='share_id',
+                      node_id='node_id', accepted=True)
+        self.main.vm.add_shared(share)
+        d = defer.Deferred()
+        def delete_share(volume_id):
+            """Fake delete_volume."""
+            self.main.event_q.push("AQ_DELETE_SHARE_OK", share_id=volume_id)
+        self.patch(self.main.action_q, 'delete_share', delete_share)
+        def deleted_handler(info):
+            """ShareDeleted handler."""
+            self.assertRaises(KeyError,
+                              self.main.vm.shared.__getitem__, info['volume_id'])
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_handler,
+                                             signal_name='ShareDeleted')
+        self.signal_receivers.add(match)
+        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
+        client.call_method('delete_share', share.volume_id,
+                           reply_handler=lambda _: None,
+                           error_handler=self.error_handler)
+        return d
+
     def test_delete_share_error_signal(self):
         """Test for Shares.delete_share with an error."""
         share_path = os.path.join(self.main.shares_dir, 'share')
@@ -2912,6 +2937,50 @@
                            error_handler=self.error_handler)
         return d
 
+    def test_delete_share_from_me_error(self):
+        """Test failure of Shares.delete_share with a share from_me."""
+        share_path = os.path.join(self.main.shares_dir, 'share')
+        share = Shared(path=share_path, volume_id='share_id',
+                      node_id='node_id', accepted=True)
+        self.main.vm.add_shared(share)
+        d = defer.Deferred()
+        # patch delete_share to fail
+        def delete_share(share_id):
+            """Fake delete_share."""
+            self.main.event_q.push("AQ_DELETE_SHARE_ERROR",
+                                   share_id=share_id, error="I'm broken")
+        self.patch(self.main.action_q, 'delete_share', delete_share)
+        def deleted_error_handler(info, error):
+            """FolderDeleteError handler."""
+            self.assertEquals(info['volume_id'], share.volume_id)
+            self.assertEquals(error, "I'm broken")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='ShareDeleteError')
+        self.signal_receivers.add(match)
+        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
+        client.call_method('delete_share', share.volume_id,
+                           reply_handler=lambda *args: None,
+                           error_handler=self.error_handler)
+        return d
+
+    def test_delete_share_from_me_doesnotexist(self):
+        """Test failure of Shares.delete_share with a share from_me."""
+        d = defer.Deferred()
+        # patch delete_share to fail
+        def deleted_error_handler(info, error):
+            """FolderDeleteError handler."""
+            self.assertEquals(info['volume_id'], 'missing_share_id')
+            self.assertEquals(error, "DOES_NOT_EXIST")
+            d.callback(True)
+        match = self.bus.add_signal_receiver(deleted_error_handler,
+                                             signal_name='ShareDeleteError')
+        self.signal_receivers.add(match)
+        client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
+        client.call_method('delete_share', 'missing_share_id',
+                           reply_handler=lambda *args: None,
+                           error_handler=self.error_handler)
+        return d
 
 def test_suite():
     # pylint: disable-msg=C0111

=== modified file 'tests/syncdaemon/test_vm.py'
--- tests/syncdaemon/test_vm.py	2010-09-16 20:38:05 +0000
+++ tests/syncdaemon/test_vm.py	2010-09-23 18:06:01 +0000
@@ -412,6 +412,63 @@
         share = self.vm.shared[str(expected_share_id)]
         self.assertEquals(str(expected_node_id), share.node_id)
 
+    @defer.inlineCallbacks
+    def test_delete_shared(self):
+        """Test VolumeManager.delete_share."""
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, 'node_id')
+        share = Shared(path=path, volume_id='share_id', node_id="node_id")
+        self.vm.add_shared(share)
+
+        def fake_delete_share(share_id):
+            """Fake delete_share."""
+            self.assertEqual(share_id, share.volume_id)
+            self.main.event_q.push('AQ_DELETE_SHARE_OK', share_id)
+
+        self.patch(self.main.action_q, 'delete_share', fake_delete_share)
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETED', d.callback, 1, collect=True)
+        self.vm.delete_share(share.volume_id)
+        events = yield d
+        event = events[0]
+        self.assertEqual(event[0], (share,))
+
+    @defer.inlineCallbacks
+    def test_delete_shared_error(self):
+        """Test VolumeManager.delete_share."""
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, 'node_id')
+        share = Shared(path=path, volume_id='share_id', node_id="node_id")
+        self.vm.add_shared(share)
+
+        def fake_delete_share(share_id):
+            """Fake delete_share that always fails."""
+            self.main.event_q.push('AQ_DELETE_SHARE_ERROR',
+                                   share_id, 'a fake error')
+
+        self.patch(self.main.action_q, 'delete_share', fake_delete_share)
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
+        self.vm.delete_share(share.volume_id)
+        events = yield d
+        event = events[0]
+        self.assertEqual(event[0], (share.volume_id, 'a fake error'))
+
+    @defer.inlineCallbacks
+    def test_delete_shared_error_missing_share(self):
+        """Test VolumeManager.delete_share with a non-existent share."""
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, 'node_id')
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
+        self.vm.delete_share('fake_share_id')
+        events = yield d
+        event = events[0]
+        self.assertEqual(event[0], ('fake_share_id', 'DOES_NOT_EXIST'))
+
     def test_accept_share(self):
         """ Test the accept_share method. """
         d = defer.Deferred()
@@ -680,6 +737,38 @@
         self.assertTrue(os.path.exists(share.path),
                         'share path missing on disk!')
 
+    @defer.inlineCallbacks
+    def test_handle_AQ_DELETE_SHARE_OK(self):
+        """Test for handle_AQ_DELETE_SHARE_OK."""
+        """Test VolumeManager.delete_share."""
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, 'node_id')
+        share = Shared(path=path, volume_id='share_id', node_id="node_id")
+        self.vm.add_shared(share)
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETED', d.callback, 1, collect=True)
+        self.main.event_q.push('AQ_DELETE_SHARE_OK', 'share_id')
+        events = yield d
+        event = events[0]
+        self.assertEqual(event[0], (share,))
+
+    @defer.inlineCallbacks
+    def test_handle_AQ_DELETE_SHARE_ERROR(self):
+        """Test for handle_AQ_DELETE_SHARE_ERROR."""
+        path = os.path.join(self.vm.root.path, 'shared_path')
+        self.main.fs.create(path, "")
+        self.main.fs.set_node_id(path, 'node_id')
+        share = Shared(path=path, volume_id='share_id', node_id="node_id")
+        self.vm.add_shared(share)
+        d = defer.Deferred()
+        self._listen_for('VM_SHARE_DELETE_ERROR', d.callback, 1, collect=True)
+        self.main.event_q.push('AQ_DELETE_SHARE_ERROR',
+                               'share_id', 'a fake error')
+        events = yield d
+        event = events[0]
+        self.assertEqual(event[0], (share.volume_id, 'a fake error'))
+
 
 class VolumeManagerUnicodeTests(BaseVolumeManagerTests):
     """Tests for Volume Manager unicode capabilities."""
@@ -1008,8 +1097,8 @@
         """Test the handling of the AQ_LIST_VOLUMES event."""
         share_id = uuid.uuid4()
         share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
-                                           10, 'to_me', u'ñoño'.encode("utf8"),
-                                           'username', 'visible_username',
+                                           10, 'to_me', u'ñoño',
+                                           'username', u'visible_username',
                                            True, 'View')
         udf_id = uuid.uuid4()
         udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
@@ -1028,7 +1117,7 @@
         self.assertIn(str(share_id), self.vm.shares)
         self.assertIn(str(udf_id), self.vm.udfs)
         share = self.vm.shares[str(share_id)]
-        self.assertEqual(u'ñoño'.encode("utf8"), share.name)
+        self.assertEqual(u'ñoño', share.name)
         self.assertEqual('fake_share_uuid', share.node_id)
         udf = self.vm.udfs[str(udf_id)]
         self.assertEqual('udf_uuid', udf.node_id)
@@ -1140,8 +1229,8 @@
         yield self.vm.add_udf(udf)
         share_id = uuid.uuid4()
         share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
-                                           10, 'to_me', u'ñoño'.encode("utf8"),
-                                           'username', 'visible_username',
+                                           10, 'to_me', u'ñoño',
+                                           'username', u'visible_username',
                                            True, 'View')
         dir_name = self.vm._build_share_path(share_volume.share_name,
                                           share_volume.other_visible_name)
@@ -1604,8 +1693,8 @@
         udf_volume = volumes.UDFVolume(udf_id, 'udf_uuid', None, 10, u'~/ñoño')
         share_id = uuid.uuid4()
         share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
-                                           10, 'to_me', u'ñoño'.encode("utf8"),
-                                           'username', 'visible_username',
+                                           10, 'to_me', u'ñoño',
+                                           'username', u'visible_username',
                                            True, 'View')
         # initialize the the root
         self.vm._got_root('root_uuid')
@@ -1656,8 +1745,8 @@
         """Test for handle_SV_VOLUME_DELETED."""
         share_id = uuid.uuid4()
         share_volume = volumes.ShareVolume(share_id, 'fake_share_uuid', None,
-                                           10, 'to_me', u'ñoño'.encode("utf8"),
-                                           'username', 'visible_username',
+                                           10, 'to_me', u'ñoño',
+                                           'username', u'visible_username',
                                            True, 'View')
         dir_name = self.vm._build_share_path(share_volume.share_name,
                                           share_volume.other_visible_name)
@@ -1665,8 +1754,7 @@
         share = Share.from_share_volume(share_volume, share_path)
         # create a UDF
         udf_id = uuid.uuid4()
-        udf, udf_volume = self._create_udf(udf_id, 'udf_uuid',
-                                           u'~/ñoño'.encode("utf8"))
+        udf, udf_volume = self._create_udf(udf_id, 'udf_uuid', u'~/ñoño')
         yield self.vm.add_udf(udf)
         self.vm.add_share(share)
         # initialize the the root

=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2010-09-21 14:31:36 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2010-09-23 18:06:01 +0000
@@ -1002,6 +1002,10 @@
         return CreateShare(self.meta_queue, node_id, share_to, name,
                            access_level, marker).queue()
 
+    def delete_share(self, share_id):
+        """Delete a offered share."""
+        return DeleteShare(self.meta_queue, share_id).queue()
+
     def create_udf(self, path, name, marker):
         """Create a User Defined Folder.
 
@@ -1689,6 +1693,32 @@
                                            error=failure.getErrorMessage())
 
 
+class DeleteShare(ActionQueueCommand):
+    """Delete a offered Share."""
+
+    __slots__ = ('share_id',)
+
+    def __init__(self, request_queue, share_id):
+        super(DeleteShare, self).__init__(request_queue)
+        self.share_id = share_id
+
+    def _run(self):
+        """Do the actual running."""
+        return self.action_queue.client.delete_share(self.share_id)
+
+    def handle_success(self, success):
+        """It worked! Push the event."""
+        self.action_queue.event_queue.push('AQ_DELETE_SHARE_OK',
+                                           share_id=self.share_id)
+        return success
+
+    def handle_failure(self, failure):
+        """It didn't work. Push the event."""
+        self.action_queue.event_queue.push('AQ_DELETE_SHARE_ERROR',
+                                           share_id=self.share_id,
+                                           error=failure.getErrorMessage())
+
+
 class CreateUDF(ActionQueueCommand):
     """Create a new User Defined Folder."""
 

=== modified file 'ubuntuone/syncdaemon/dbus_interface.py'
--- ubuntuone/syncdaemon/dbus_interface.py	2010-09-16 16:54:48 +0000
+++ ubuntuone/syncdaemon/dbus_interface.py	2010-09-23 18:06:01 +0000
@@ -788,6 +788,16 @@
         self.handle_default('VM_SHARE_CREATED', share_id)
         self.dbus_iface.shares.emit_new_share(share_id)
 
+    def handle_VM_SHARE_DELETED(self, share):
+        """Handle VM_SHARE_DELETED event, emit NewShare event."""
+        self.handle_default('VM_SHARE_DELETED', getattr(share, 'id', share))
+        self.dbus_iface.shares.emit_share_changed('deleted', share)
+
+    def handle_VM_SHARE_DELETE_ERROR(self, share_id, error):
+        """Handle VM_DELETE_SHARE_ERROR event, emit ShareCreateError signal."""
+        self.handle_default('VM_SHARE_DELETE_ERROR', share_id, error)
+        self.dbus_iface.shares.ShareDeleteError(dict(volume_id=share_id), error)
+
     def handle_VM_VOLUME_DELETED(self, volume):
         """Handle VM_VOLUME_DELETED event.
 
@@ -804,7 +814,7 @@
                      "volume_id=%r as it's not a share or UDF", volume.id)
 
     def handle_VM_VOLUME_DELETE_ERROR(self, volume_id, error):
-        """Handle VM_SHARE_DELETED event, emit ShareDeleted event."""
+        """Handle VM_VOLUME_DELETE_ERROR event, emit ShareDeleted event."""
         self.handle_default('VM_VOLUME_DELETE_ERROR', volume_id, error)
         try:
             volume = self.dbus_iface.volume_manager.get_volume(volume_id)
@@ -1131,21 +1141,21 @@
                                      str(share_id)))
 
     @dbus.service.method(DBUS_IFACE_SHARES_NAME,
-                         in_signature='s', out_signature='',
-                         async_callbacks=('reply_handler', 'error_handler'))
-    def delete_share(self, share_id, reply_handler=None, error_handler=None):
-        """Delete a Share."""
+                         in_signature='s', out_signature='')
+    def delete_share(self, share_id):
+        """Delete a Share, both kinds: "to me" and "from me"."""
         logger.debug('delete_share: %r', share_id)
         try:
-            self.vm.delete_volume(str(share_id))
-            reply_handler()
-        except VolumeDoesNotExist, e:
-            self.ShareDeleteError({'volume_id':share_id}, str(e))
+            try:
+                self.vm.delete_volume(str(share_id))
+            except VolumeDoesNotExist:
+                # isn't a volume! it might be a "share from me (a.k.a shared)"
+                self.vm.delete_share(str(share_id))
         except Exception, e:
-            error_handler(e)
             logger.exception('Error while deleting share: %r', share_id)
             self.ShareDeleteError({'volume_id':share_id}, str(e))
-
+            # propagate the error
+            raise
 
     @dbus.service.signal(DBUS_IFACE_SHARES_NAME,
                          signature='a{ss}')

=== modified file 'ubuntuone/syncdaemon/event_queue.py'
--- ubuntuone/syncdaemon/event_queue.py	2010-08-31 14:19:53 +0000
+++ ubuntuone/syncdaemon/event_queue.py	2010-09-23 18:06:01 +0000
@@ -69,6 +69,8 @@
     'AQ_LIST_SHARES_ERROR': ('error',),
     'AQ_CREATE_SHARE_OK': ('share_id', 'marker'),
     'AQ_CREATE_SHARE_ERROR': ('marker', 'error'),
+    'AQ_DELETE_SHARE_OK': ('share_id',),
+    'AQ_DELETE_SHARE_ERROR': ('share_id', 'error'),
     'AQ_QUERY_ERROR': ('item', 'error'),
     'AQ_ANSWER_SHARE_OK': ('share_id', 'answer'),
     'AQ_ANSWER_SHARE_ERROR': ('share_id', 'answer', 'error'),
@@ -145,6 +147,8 @@
     'VM_UDF_CREATED': ('udf',),
     'VM_UDF_CREATE_ERROR': ('path', 'error'),
     'VM_SHARE_CREATED': ('share_id',),
+    'VM_SHARE_DELETED': ('udf',),
+    'VM_SHARE_DELETE_ERROR': ('path', 'error'),
     'VM_VOLUME_DELETED': ('volume',),
     'VM_VOLUME_DELETE_ERROR': ('volume_id', 'error'),
     'VM_SHARE_CHANGED': ('share_id',),

=== modified file 'ubuntuone/syncdaemon/volume_manager.py'
--- ubuntuone/syncdaemon/volume_manager.py	2010-09-16 20:38:05 +0000
+++ ubuntuone/syncdaemon/volume_manager.py	2010-09-23 18:06:01 +0000
@@ -717,6 +717,22 @@
         if marker in self.marker_share_map:
             del self.marker_share_map[marker]
 
+    def handle_AQ_DELETE_SHARE_OK(self, share_id):
+        """Handle AQ_DELETE_SHARE_OK event."""
+        share = self.shared.get(share_id)
+        if share is not None:
+            del self.shared[share_id]
+            self.m.event_q.push('VM_SHARE_DELETED', share)
+        else:
+            # delete ok, of something we don't have.
+            self.log.warning("AQ_DELETE_SHARE_OK of a non-existing shared "
+                             "dir: %s", share_id)
+
+    def handle_AQ_DELETE_SHARE_ERROR(self, share_id, error):
+        """Gandle AQ_DELETE_SHARE_ERROR event."""
+        self.log.error("Error while deleting offered share: %s", error)
+        self.m.event_q.push('VM_SHARE_DELETE_ERROR', share_id, error)
+
     def handle_SV_SHARE_ANSWERED(self, share_id, answer):
         """ handle SV_SHARE_ANSWERED event. """
         share = self.shared.get(share_id, None)
@@ -908,6 +924,15 @@
         self.m.action_q.create_share(node_id, username, name,
                                      access_level, marker)
 
+    def delete_share(self, share_id):
+        """Reuqest the deletion of an offered share."""
+        share = self.shared.get(share_id)
+        if share is None:
+            # if the share isn't there, push the error!
+            self.m.event_q.push('VM_SHARE_DELETE_ERROR', share_id, "DOES_NOT_EXIST")
+        else:
+            self.m.action_q.delete_share(share_id)
+
     def add_shared(self, share):
         """ Add a share with direction == from_me """
         self.log.info('New shared subtree: id: %s - path: %r',