Merge lp:~lucio.torre/ubuntuone-client/dont-reorder-deletes-stable into lp:ubuntuone-client

[Lucio Torre]

make sure we dont reorder deletes
with this change the conflict is avoided and integration tests pass
i dont know why this was done this way the first time.

[dobey (dobey)]

Looks like you pulled the wrong code, and committed some conflicts.

8 +<<<<<<< TREE
9 +=======

review: Needs Resubmitting

Unmerged revisions

717. By Lucio Torre on 2010-09-23

merged changes

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 'nautilus/ubuntuone-nautilus.c'
--- nautilus/ubuntuone-nautilus.c	2010-09-23 13:37:34 +0000
+++ nautilus/ubuntuone-nautilus.c	2010-09-23 15:17:41 +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_sync.py'
--- tests/syncdaemon/test_sync.py	2010-09-15 19:02:52 +0000
+++ tests/syncdaemon/test_sync.py	2010-09-23 15:17:41 +0000
@@ -1349,7 +1349,12 @@
         self.handler.records = []
 
     def test_handle_deletes_last(self):
-        """The handler for SV_FILE_DELETED is called last"""
+        """The handler for SV_FILE_DELETED is not called last
+
+        If we reorder deletes we will get a fake conflict when a
+        delete and move that overwrites the deleted file arrives.
+        """
+
         self.create_filetxt()
         self.create_dir()
 
@@ -1373,7 +1378,7 @@
         self.sync.handle_AQ_DELTA_OK(**kwargs)
 
         # check that the handlers are called in order
-        self.assertEqual(called, ['hash', 'delete'])
+        self.assertEqual(called, ['delete', 'hash'])
 
     def test_exception_mark_node_as_dirty(self):
         """We mark the node as dirty and send an event on error."""

=== modified file 'ubuntuone/syncdaemon/sync.py'
--- ubuntuone/syncdaemon/sync.py	2010-09-15 19:02:52 +0000
+++ ubuntuone/syncdaemon/sync.py	2010-09-23 15:17:41 +0000
@@ -1077,6 +1077,7 @@
                 # about it
                 if not dt.is_live:
                     to_delete.append(dt)
+                    self._handle_SV_FILE_DELETED(dt.share_id, dt.node_id)
                     # nothing else should happen with this
                     continue
 
@@ -1146,15 +1147,6 @@
                     "Node delta for %s:%s can't be applied.",
                     dt.share_id, dt.node_id)
 
-        for dt in to_delete:
-            try:
-                # delete all the nodes after applying all deltas
-                self._handle_SV_FILE_DELETED(dt.share_id, dt.node_id)
-            except Exception:
-                self.logger.exception(
-                    "Node delete for %s:%s can't be applied.",
-                    dt.share_id, dt.node_id)
-
                 # And mark the node as dirty
                 self.mark_node_as_dirty(dt.share_id, dt.node_id)