[evolution-data-server] I#22 - [Camel] Store disconnect can abort just started downsync for offline

[Milan Crha <mcrha src gnome org>]

commit 990cb0333be4f736fb11608f7cf61d5598e09751
Author: Milan Crha <mcrha redhat com>
Date:   Wed Jul 18 19:29:23 2018 +0200

    I#22 - [Camel] Store disconnect can abort just started downsync for offline
    
    Closes https://gitlab.gnome.org/GNOME/evolution-data-server/issues/22

 src/camel/camel-offline-folder.c | 49 +++++++++++++++++++++++++++++--
 src/camel/camel-offline-store.c  | 62 ++++++++++++++++++++++++++++++++++------
 2 files changed, 100 insertions(+), 11 deletions(-)
---
diff --git a/src/camel/camel-offline-folder.c b/src/camel/camel-offline-folder.c
index f0af9b77e..b4935157b 100644
--- a/src/camel/camel-offline-folder.c
+++ b/src/camel/camel-offline-folder.c
@@ -446,11 +446,29 @@ offline_folder_downsync_sync (CamelOfflineFolder *offline,
 
                uids = camel_folder_search_by_expression (folder, search_sexp, cancellable, NULL);
 
+               if (camel_debug ("downsync")) {
+                       printf ("[downsync]       %p: (%s : %s): got %d uids for limit expr '%s'\n", 
camel_folder_get_parent_store (folder),
+                               camel_service_get_display_name (CAMEL_SERVICE (camel_folder_get_parent_store 
(folder))), camel_folder_get_full_name (folder),
+                               uids ? uids->len : -1, search_sexp);
+               }
+
                g_free (search_sexp);
        } else if (expression) {
                uids = camel_folder_search_by_expression (folder, expression, cancellable, NULL);
+
+               if (camel_debug ("downsync")) {
+                       printf ("[downsync]       %p: (%s : %s): got %d uids for expr '%s'\n", 
camel_folder_get_parent_store (folder),
+                               camel_service_get_display_name (CAMEL_SERVICE (camel_folder_get_parent_store 
(folder))), camel_folder_get_full_name (folder),
+                               uids ? uids->len : -1, expression);
+               }
        } else {
                uids = camel_folder_get_uids (folder);
+
+               if (camel_debug ("downsync")) {
+                       printf ("[downsync]       %p: (%s : %s): got all %d uids\n", 
camel_folder_get_parent_store (folder),
+                               camel_service_get_display_name (CAMEL_SERVICE (camel_folder_get_parent_store 
(folder))), camel_folder_get_full_name (folder),
+                               uids ? uids->len : -1);
+               }
        }
 
        if (!uids)
@@ -463,6 +481,12 @@ offline_folder_downsync_sync (CamelOfflineFolder *offline,
        else
                camel_folder_free_uids (folder, uids);
 
+       if (camel_debug ("downsync")) {
+               printf ("[downsync]       %p: (%s : %s): claimed %d uncached uids\n", 
camel_folder_get_parent_store (folder),
+                       camel_service_get_display_name (CAMEL_SERVICE (camel_folder_get_parent_store 
(folder))), camel_folder_get_full_name (folder),
+                       uncached_uids ? uncached_uids->len : -1);
+       }
+
        if (!uncached_uids)
                goto done;
 
@@ -474,8 +498,14 @@ offline_folder_downsync_sync (CamelOfflineFolder *offline,
                        CamelMessageInfo *mi;
 
                        mi = camel_folder_get_message_info (folder, uid);
-                       if (!mi)
+                       if (!mi) {
+                               if (camel_debug ("downsync")) {
+                                       printf ("[downsync]          %p: (%s : %s): mi for uid '%s' not 
found, skipping\n", camel_folder_get_parent_store (folder),
+                                               camel_service_get_display_name (CAMEL_SERVICE 
(camel_folder_get_parent_store (folder))), camel_folder_get_full_name (folder),
+                                               uid);
+                               }
                                continue;
+                       }
 
                        download = camel_message_info_get_date_sent (mi) > limit_time;
 
@@ -483,6 +513,7 @@ offline_folder_downsync_sync (CamelOfflineFolder *offline,
                }
 
                if (download) {
+                       GError *local_error = NULL;
                        /* Translators: The first “%d” is the sequence number of the message, the second “%d”
                           is the total number of messages to synchronize.
                           The first “%s” is replaced with an account name and the second “%s”
@@ -494,12 +525,26 @@ offline_folder_downsync_sync (CamelOfflineFolder *offline,
                                camel_folder_get_full_name (folder));
 
                        /* Stop on failure */
-                       if (!camel_folder_synchronize_message_sync (folder, uid, cancellable, NULL)) {
+                       if (!camel_folder_synchronize_message_sync (folder, uid, cancellable, &local_error)) {
+                               if (camel_debug ("downsync")) {
+                                       printf ("[downsync]          %p: (%s : %s): aborting, failed to 
download uid:%s error:%s\n", camel_folder_get_parent_store (folder),
+                                               camel_service_get_display_name (CAMEL_SERVICE 
(camel_folder_get_parent_store (folder))), camel_folder_get_full_name (folder),
+                                               uid, local_error ? local_error->message : "Unknown error");
+                               }
+                               g_clear_error (&local_error);
                                camel_operation_pop_message (cancellable);
                                break;
+                       } else if (camel_debug ("downsync")) {
+                               printf ("[downsync]          %p: (%s : %s): uid '%s' downloaded\n", 
camel_folder_get_parent_store (folder),
+                                       camel_service_get_display_name (CAMEL_SERVICE 
(camel_folder_get_parent_store (folder))), camel_folder_get_full_name (folder),
+                                       uid);
                        }
 
                        camel_operation_pop_message (cancellable);
+               } else if (camel_debug ("downsync")) {
+                       printf ("[downsync]       %p: (%s : %s): skipping download of uid '%s'\n", 
camel_folder_get_parent_store (folder),
+                               camel_service_get_display_name (CAMEL_SERVICE (camel_folder_get_parent_store 
(folder))), camel_folder_get_full_name (folder),
+                               uid);
                }
 
                camel_operation_progress (cancellable, i * 100 / uncached_uids->len);
diff --git a/src/camel/camel-offline-store.c b/src/camel/camel-offline-store.c
index 78cda4363..148c6e5b0 100644
--- a/src/camel/camel-offline-store.c
+++ b/src/camel/camel-offline-store.c
@@ -21,6 +21,7 @@
 
 #include <glib/gi18n-lib.h>
 
+#include "camel-debug.h"
 #include "camel-folder.h"
 #include "camel-network-service.h"
 #include "camel-offline-folder.h"
@@ -50,39 +51,69 @@ enum {
 G_DEFINE_TYPE (CamelOfflineStore, camel_offline_store, CAMEL_TYPE_STORE)
 
 static void
-offline_store_downsync_folders_thread (CamelSession *session,
-                                      GCancellable *cancellable,
-                                      gpointer user_data,
-                                      GError **error)
+offline_store_downsync_folders_sync (CamelStore *store,
+                                    GCancellable *cancellable,
+                                    GError **error)
 {
-       CamelStore *store = user_data;
        GPtrArray *folders;
        guint ii;
 
        g_return_if_fail (CAMEL_IS_OFFLINE_STORE (store));
 
        folders = camel_offline_store_dup_downsync_folders (CAMEL_OFFLINE_STORE (store));
+
+       if (camel_debug ("downsync"))
+               printf ("[downsync] %p (%s): got %d folders to downsync\n", store, 
camel_service_get_display_name (CAMEL_SERVICE (store)), folders ? folders->len : -1);
+
        if (!folders)
                return;
 
        for (ii = 0; ii < folders->len && !g_cancellable_is_cancelled (cancellable); ii++) {
                CamelFolder *folder = folders->pdata[ii];
                CamelOfflineFolder *offline_folder;
+               GError *local_error = NULL;
 
-               if (!CAMEL_IS_OFFLINE_FOLDER (folder))
+               if (!CAMEL_IS_OFFLINE_FOLDER (folder)) {
+                       if (camel_debug ("downsync"))
+                               printf ("[downsync]    %p: [%d] not an offline folder\n", store, ii);
                        continue;
+               }
 
                offline_folder = CAMEL_OFFLINE_FOLDER (folder);
 
-               if (camel_offline_folder_can_downsync (offline_folder) &&
-                   !camel_offline_folder_downsync_sync (offline_folder, NULL, cancellable, error))
+               if (!camel_offline_folder_can_downsync (offline_folder)) {
+                       if (camel_debug ("downsync"))
+                               printf ("[downsync]    %p: [%d] skipping folder '%s', not for downsync\n", 
store, ii, camel_folder_get_full_name (folder));
+                       continue;
+               }
+
+               if (!camel_offline_folder_downsync_sync (offline_folder, NULL, cancellable, &local_error)) {
+                       if (camel_debug ("downsync"))
+                               printf ("[downsync]    %p: [%d] failed to downsync folder '%s'; cancelled:%d 
error: %s\n", store, ii, camel_folder_get_full_name (folder), g_cancellable_is_cancelled (cancellable), 
local_error ? local_error->message : "Unknown error");
+                       if (local_error)
+                               g_propagate_error (error, local_error);
                        break;
+               }
+
+               if (camel_debug ("downsync"))
+                       printf ("[downsync]    %p: [%d] finished downsync of folder '%s'\n", store, ii, 
camel_folder_get_full_name (folder));
        }
 
        g_ptr_array_foreach (folders, (GFunc) g_object_unref, NULL);
        g_ptr_array_free (folders, TRUE);
 }
 
+static void
+offline_store_downsync_folders_thread (CamelSession *session,
+                                      GCancellable *cancellable,
+                                      gpointer user_data,
+                                      GError **error)
+{
+       CamelStore *store = user_data;
+
+       offline_store_downsync_folders_sync (store, cancellable, error);
+}
+
 static void
 offline_store_constructed (GObject *object)
 {
@@ -262,7 +293,10 @@ camel_offline_store_set_online_sync (CamelOfflineStore *store,
                session = camel_service_ref_session (service);
                folders = session ? camel_offline_store_dup_downsync_folders (store) : NULL;
 
-               if (folders && session) {
+               /* Schedule job only if the store is going online, otherwise, when going offline,
+                  the download could be cancelled due to the switch to the disconnect, thus
+                  synchronize immediately. */
+               if (folders && session && online) {
                        gchar *description;
 
                        description = g_strdup_printf (_("Syncing messages in account “%s” to disk"),
@@ -273,6 +307,16 @@ camel_offline_store_set_online_sync (CamelOfflineStore *store,
                                g_object_ref (store), g_object_unref);
 
                        g_free (description);
+               } else if (folders && session) {
+                       GError *local_error = NULL;
+
+                       /* Ignore errors, because the move to offline won't fail here */
+                       offline_store_downsync_folders_sync (CAMEL_STORE (store), cancellable, &local_error);
+
+                       if (local_error && camel_debug ("downsync"))
+                               printf ("[downsync]    %p (%s): Finished with error when going offline: 
%s\n", store, camel_service_get_display_name (CAMEL_SERVICE (store)), local_error->message);
+
+                       g_clear_error (&local_error);
                }
 
                g_clear_object (&session);