camel/camel-disco-folder.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /* camel-disco-folder.c: abstract class for a disconnectable folder */
   3
   4 /*
   5  * Authors: Dan Winship <danw@ximian.com>
   6  *
   7  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of version 2 of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  21  * USA
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <glib/gi18n-lib.h>
  29
  30 #include "camel-debug.h"
  31 #include "camel-disco-folder.h"
  32 #include "camel-disco-store.h"
  33 #include "camel-offline-settings.h"
  34 #include "camel-session.h"
  35
  36 #define CAMEL_DISCO_FOLDER_GET_PRIVATE(obj) \
  37         (G_TYPE_INSTANCE_GET_PRIVATE \
  38         ((obj), CAMEL_TYPE_DISCO_FOLDER, CamelDiscoFolderPrivate))
  39
  40 struct _CamelDiscoFolderPrivate {
  41         gboolean offline_sync;
  42 };
  43
  44 struct _cdf_sync_data {
  45         CamelFolder *folder;
  46         CamelFolderChangeInfo *changes;
  47 };
  48
  49 /* The custom property ID is a CamelArg artifact.
  50  * It still identifies the property in state files. */
  51 enum {
  52         PROP_0,
  53         PROP_OFFLINE_SYNC = 0x2400
  54 };
  55
  56 G_DEFINE_TYPE (CamelDiscoFolder, camel_disco_folder, CAMEL_TYPE_FOLDER)
  57
  58 static void
  59 cdf_sync_free (struct _cdf_sync_data *data)
  60 {
  61         if (data->changes != NULL)
  62                 camel_folder_change_info_free (data->changes);
  63         g_object_unref (data->folder);
  64
  65         g_slice_free (struct _cdf_sync_data, data);
  66 }
  67
  68 static void
  69 cdf_sync_offline (CamelSession *session,
  70                   GCancellable *cancellable,
  71                   struct _cdf_sync_data *data,
  72                   GError **error)
  73 {
  74         camel_operation_push_message (
  75                 cancellable,
  76                 _("Downloading new messages for offline mode"));
  77
  78         if (data->changes != NULL) {
  79                 GPtrArray *uid_added;
  80                 gint ii;
  81
  82                 uid_added = data->changes->uid_added;
  83
  84                 for (ii = 0; ii < uid_added->len; ii++) {
  85                         gint pc = ii * 100 / uid_added->len;
  86
  87                         camel_operation_progress (cancellable, pc);
  88                         camel_disco_folder_cache_message (
  89                                 CAMEL_DISCO_FOLDER (data->folder),
  90                                 uid_added->pdata[ii], NULL, error);
  91                 }
  92         } else {
  93                 camel_disco_folder_prepare_for_offline (
  94                         CAMEL_DISCO_FOLDER (data->folder),
  95                         "(match-all)", NULL, error);
  96         }
  97
  98         camel_operation_pop_message (cancellable);
  99 }
 100
 101 static void
 102 cdf_folder_changed (CamelFolder *folder,
 103                     CamelFolderChangeInfo *changes)
 104 {
 105         CamelService *service;
 106         CamelSession *session;
 107         CamelSettings *settings;
 108         CamelStore *parent_store;
 109         gboolean sync_folder;
 110         gboolean sync_store;
 111
 112         parent_store = camel_folder_get_parent_store (folder);
 113
 114         service = CAMEL_SERVICE (parent_store);
 115         session = camel_service_get_session (service);
 116
 117         sync_folder = camel_disco_folder_get_offline_sync (
 118                 CAMEL_DISCO_FOLDER (folder));
 119
 120         settings = camel_service_ref_settings (service);
 121
 122         sync_store = camel_offline_settings_get_stay_synchronized (
 123                 CAMEL_OFFLINE_SETTINGS (settings));
 124
 125         g_object_unref (settings);
 126
 127         if (changes->uid_added->len > 0 && (sync_folder || sync_store)) {
 128                 struct _cdf_sync_data *data;
 129
 130                 data = g_slice_new0 (struct _cdf_sync_data);
 131                 data->changes = camel_folder_change_info_new ();
 132                 camel_folder_change_info_cat (data->changes, changes);
 133                 data->folder = g_object_ref (folder);
 134
 135                 camel_session_submit_job (
 136                         session,
 137                         (CamelSessionCallback) cdf_sync_offline,
 138                         data, (GDestroyNotify) cdf_sync_free);
 139         }
 140 }
 141
 142 static void
 143 disco_folder_set_property (GObject *object,
 144                            guint property_id,
 145                            const GValue *value,
 146                            GParamSpec *pspec)
 147 {
 148         switch (property_id) {
 149                 case PROP_OFFLINE_SYNC:
 150                         camel_disco_folder_set_offline_sync (
 151                                 CAMEL_DISCO_FOLDER (object),
 152                                 g_value_get_boolean (value));
 153                         return;
 154         }
 155
 156         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 157 }
 158
 159 static void
 160 disco_folder_get_property (GObject *object,
 161                            guint property_id,
 162                            GValue *value,
 163                            GParamSpec *pspec)
 164 {
 165         switch (property_id) {
 166                 case PROP_OFFLINE_SYNC:
 167                         g_value_set_boolean (
 168                                 value, camel_disco_folder_get_offline_sync (
 169                                 CAMEL_DISCO_FOLDER (object)));
 170                         return;
 171         }
 172
 173         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 174 }
 175
 176 static gboolean
 177 disco_expunge_uids (CamelFolder *folder,
 178                     GPtrArray *uids,
 179                     GCancellable *cancellable,
 180                     GError **error)
 181 {
 182         CamelDiscoFolderClass *disco_folder_class;
 183         CamelStore *parent_store;
 184         gboolean success;
 185
 186         if (uids->len == 0)
 187                 return TRUE;
 188
 189         parent_store = camel_folder_get_parent_store (folder);
 190         disco_folder_class = CAMEL_DISCO_FOLDER_GET_CLASS (folder);
 191
 192         switch (camel_disco_store_status (CAMEL_DISCO_STORE (parent_store))) {
 193         case CAMEL_DISCO_STORE_ONLINE:
 194                 g_return_val_if_fail (disco_folder_class->expunge_uids_online != NULL, FALSE);
 195                 success = disco_folder_class->expunge_uids_online (
 196                         folder, uids, error);
 197                 CAMEL_CHECK_GERROR (
 198                         folder, expunge_uids_online, success, error);
 199                 return success;
 200
 201         case CAMEL_DISCO_STORE_OFFLINE:
 202                 g_return_val_if_fail (disco_folder_class->expunge_uids_offline != NULL, FALSE);
 203                 success = disco_folder_class->expunge_uids_offline (
 204                         folder, uids, error);
 205                 CAMEL_CHECK_GERROR (
 206                         folder, expunge_uids_offline, success, error);
 207                 return success;
 208
 209         case CAMEL_DISCO_STORE_RESYNCING:
 210                 g_return_val_if_fail (disco_folder_class->expunge_uids_resyncing != NULL, FALSE);
 211                 success = disco_folder_class->expunge_uids_resyncing (
 212                         folder, uids, error);
 213                 CAMEL_CHECK_GERROR (
 214                         folder, expunge_uids_resyncing, success, error);
 215                 return success;
 216         }
 217
 218         g_return_val_if_reached (FALSE);
 219 }
 220
 221 static gboolean
 222 disco_append_message_sync (CamelFolder *folder,
 223                            CamelMimeMessage *message,
 224                            CamelMessageInfo *info,
 225                            gchar **appended_uid,
 226                            GCancellable *cancellable,
 227                            GError **error)
 228 {
 229         CamelDiscoFolderClass *disco_folder_class;
 230         CamelStore *parent_store;
 231         gboolean success;
 232
 233         parent_store = camel_folder_get_parent_store (folder);
 234         disco_folder_class = CAMEL_DISCO_FOLDER_GET_CLASS (folder);
 235
 236         switch (camel_disco_store_status (CAMEL_DISCO_STORE (parent_store))) {
 237         case CAMEL_DISCO_STORE_ONLINE:
 238                 g_return_val_if_fail (disco_folder_class->append_online != NULL, FALSE);
 239                 success = disco_folder_class->append_online (
 240                         folder, message, info,
 241                         appended_uid, cancellable, error);
 242                 CAMEL_CHECK_GERROR (folder, append_online, success, error);
 243                 return success;
 244
 245         case CAMEL_DISCO_STORE_OFFLINE:
 246                 g_return_val_if_fail (disco_folder_class->append_offline != NULL, FALSE);
 247                 success = disco_folder_class->append_offline (
 248                         folder, message, info,
 249                         appended_uid, cancellable, error);
 250                 CAMEL_CHECK_GERROR (folder, append_offline, success, error);
 251                 return success;
 252
 253         case CAMEL_DISCO_STORE_RESYNCING:
 254                 g_return_val_if_fail (disco_folder_class->append_resyncing != NULL, FALSE);
 255                 success = disco_folder_class->append_resyncing (
 256                         folder, message, info,
 257                         appended_uid, cancellable, error);
 258                 CAMEL_CHECK_GERROR (folder, append_resyncing, success, error);
 259                 return success;
 260         }
 261
 262         g_return_val_if_reached (FALSE);
 263 }
 264
 265 static gboolean
 266 disco_expunge_sync (CamelFolder *folder,
 267                     GCancellable *cancellable,
 268                     GError **error)
 269 {
 270         GPtrArray *uids;
 271         gint i;
 272         CamelMessageInfo *info;
 273         gboolean success;
 274         GPtrArray *known_uids;
 275
 276         uids = g_ptr_array_new ();
 277         camel_folder_summary_prepare_fetch_all (folder->summary, NULL);
 278         known_uids = camel_folder_summary_get_array (folder->summary);
 279         for (i = 0; known_uids && i < known_uids->len; i++) {
 280                 const gchar *uid = g_ptr_array_index (known_uids, i);
 281
 282                 info = camel_folder_summary_get (folder->summary, uid);
 283                 if (camel_message_info_flags (info) & CAMEL_MESSAGE_DELETED)
 284                         g_ptr_array_add (uids, (gpointer) uid);
 285                 camel_message_info_free (info);
 286         }
 287
 288         success = disco_expunge_uids (folder, uids, cancellable, error);
 289
 290         g_ptr_array_free (uids, TRUE);
 291         if (known_uids)
 292                 camel_folder_summary_free_array (known_uids);
 293
 294         return success;
 295 }
 296
 297 static gboolean
 298 disco_refresh_info_sync (CamelFolder *folder,
 299                          GCancellable *cancellable,
 300                          GError **error)
 301 {
 302         CamelDiscoFolderClass *disco_folder_class;
 303         CamelStore *parent_store;
 304         gboolean success;
 305
 306         parent_store = camel_folder_get_parent_store (folder);
 307
 308         if (camel_disco_store_status (CAMEL_DISCO_STORE (parent_store)) != CAMEL_DISCO_STORE_ONLINE)
 309                 return TRUE;
 310
 311         disco_folder_class = CAMEL_DISCO_FOLDER_GET_CLASS (folder);
 312         g_return_val_if_fail (disco_folder_class->refresh_info_online != NULL, FALSE);
 313
 314         success = disco_folder_class->refresh_info_online (
 315                 folder, cancellable, error);
 316         CAMEL_CHECK_GERROR (folder, refresh_info_online, success, error);
 317
 318         return success;
 319 }
 320
 321 static gboolean
 322 disco_synchronize_sync (CamelFolder *folder,
 323                         gboolean expunge,
 324                         GCancellable *cancellable,
 325                         GError **error)
 326 {
 327         CamelDiscoFolderClass *disco_folder_class;
 328         CamelStore *parent_store;
 329         gboolean success;
 330
 331         if (expunge && !disco_expunge_sync (folder, cancellable, error))
 332                 return FALSE;
 333
 334         camel_object_state_write (CAMEL_OBJECT (folder));
 335
 336         parent_store = camel_folder_get_parent_store (folder);
 337         disco_folder_class = CAMEL_DISCO_FOLDER_GET_CLASS (folder);
 338
 339         switch (camel_disco_store_status (CAMEL_DISCO_STORE (parent_store))) {
 340         case CAMEL_DISCO_STORE_ONLINE:
 341                 g_return_val_if_fail (disco_folder_class->sync_online != NULL, FALSE);
 342                 success = disco_folder_class->sync_online (folder, error);
 343                 CAMEL_CHECK_GERROR (folder, sync_online, success, error);
 344                 return success;
 345
 346         case CAMEL_DISCO_STORE_OFFLINE:
 347                 g_return_val_if_fail (disco_folder_class->sync_offline != NULL, FALSE);
 348                 success = disco_folder_class->sync_offline (folder, error);
 349                 CAMEL_CHECK_GERROR (folder, sync_offline, success, error);
 350                 return success;
 351
 352         case CAMEL_DISCO_STORE_RESYNCING:
 353                 g_return_val_if_fail (disco_folder_class->sync_resyncing != NULL, FALSE);
 354                 success = disco_folder_class->sync_resyncing (folder, error);
 355                 CAMEL_CHECK_GERROR (folder, sync_resyncing, success, error);
 356                 return success;
 357         }
 358
 359         g_return_val_if_reached (FALSE);
 360 }
 361
 362 static gboolean
 363 disco_transfer_messages_to_sync (CamelFolder *source,
 364                                  GPtrArray *uids,
 365                                  CamelFolder *dest,
 366                                  gboolean delete_originals,
 367                                  GPtrArray **transferred_uids,
 368                                  GCancellable *cancellable,
 369                                  GError **error)
 370 {
 371         CamelDiscoFolderClass *disco_folder_class;
 372         CamelStore *parent_store;
 373         gboolean success;
 374
 375         parent_store = camel_folder_get_parent_store (source);
 376         disco_folder_class = CAMEL_DISCO_FOLDER_GET_CLASS (source);
 377
 378         switch (camel_disco_store_status (CAMEL_DISCO_STORE (parent_store))) {
 379         case CAMEL_DISCO_STORE_ONLINE:
 380                 g_return_val_if_fail (disco_folder_class->transfer_online != NULL, FALSE);
 381                 success = disco_folder_class->transfer_online (
 382                         source, uids, dest, transferred_uids,
 383                         delete_originals, cancellable, error);
 384                 CAMEL_CHECK_GERROR (source, transfer_online, success, error);
 385                 return success;
 386
 387         case CAMEL_DISCO_STORE_OFFLINE:
 388                 g_return_val_if_fail (disco_folder_class->transfer_offline != NULL, FALSE);
 389                 success = disco_folder_class->transfer_offline (
 390                         source, uids, dest, transferred_uids,
 391                         delete_originals, cancellable, error);
 392                 CAMEL_CHECK_GERROR (source, transfer_offline, success, error);
 393                 return success;
 394
 395         case CAMEL_DISCO_STORE_RESYNCING:
 396                 g_return_val_if_fail (disco_folder_class->transfer_resyncing != NULL, FALSE);
 397                 success = disco_folder_class->transfer_resyncing (
 398                         source, uids, dest, transferred_uids,
 399                         delete_originals, cancellable, error);
 400                 CAMEL_CHECK_GERROR (source, transfer_resyncing, success, error);
 401                 return success;
 402         }
 403
 404         g_return_val_if_reached (FALSE);
 405 }
 406
 407 static gboolean
 408 disco_prepare_for_offline (CamelDiscoFolder *disco_folder,
 409                            const gchar *expression,
 410                            GCancellable *cancellable,
 411                            GError **error)
 412 {
 413         CamelFolder *folder = CAMEL_FOLDER (disco_folder);
 414         GPtrArray *uids;
 415         const gchar *display_name;
 416         const gchar *message;
 417         gint i;
 418         gboolean success = TRUE;
 419
 420         message = _("Preparing folder '%s' for offline");
 421         display_name = camel_folder_get_display_name (folder);
 422         camel_operation_push_message (cancellable, message, display_name);
 423
 424         if (expression)
 425                 uids = camel_folder_search_by_expression (folder, expression, cancellable, error);
 426         else
 427                 uids = camel_folder_get_uids (folder);
 428
 429         if (!uids) {
 430                 camel_operation_pop_message (cancellable);
 431                 return FALSE;
 432         }
 433
 434         for (i = 0; i < uids->len && success; i++) {
 435                 camel_operation_progress (
 436                         cancellable, (i * 100) / uids->len);
 437                 success = camel_disco_folder_cache_message (
 438                         disco_folder, uids->pdata[i], cancellable, error);
 439         }
 440
 441         if (expression)
 442                 camel_folder_search_free (folder, uids);
 443         else
 444                 camel_folder_free_uids (folder, uids);
 445
 446         camel_operation_pop_message (cancellable);
 447
 448         return success;
 449 }
 450
 451 static gboolean
 452 disco_refresh_info_online (CamelFolder *folder,
 453                            GCancellable *cancellable,
 454                            GError **error)
 455 {
 456         return TRUE;
 457 }
 458
 459 static void
 460 camel_disco_folder_class_init (CamelDiscoFolderClass *class)
 461 {
 462         GObjectClass *object_class;
 463         CamelFolderClass *folder_class;
 464
 465         g_type_class_add_private (class, sizeof (CamelDiscoFolderPrivate));
 466
 467         object_class = G_OBJECT_CLASS (class);
 468         object_class->set_property = disco_folder_set_property;
 469         object_class->get_property = disco_folder_get_property;
 470
 471         folder_class = CAMEL_FOLDER_CLASS (class);
 472         folder_class->append_message_sync = disco_append_message_sync;
 473         folder_class->expunge_sync = disco_expunge_sync;
 474         folder_class->refresh_info_sync = disco_refresh_info_sync;
 475         folder_class->synchronize_sync = disco_synchronize_sync;
 476         folder_class->transfer_messages_to_sync = disco_transfer_messages_to_sync;
 477
 478         class->prepare_for_offline = disco_prepare_for_offline;
 479         class->refresh_info_online = disco_refresh_info_online;
 480
 481         g_object_class_install_property (
 482                 object_class,
 483                 PROP_OFFLINE_SYNC,
 484                 g_param_spec_boolean (
 485                         "offline-sync",
 486                         "Offline Sync",
 487                         _("Copy folder content locally for _offline operation"),
 488                         FALSE,
 489                         G_PARAM_READWRITE |
 490                         CAMEL_PARAM_PERSISTENT));
 491 }
 492
 493 static void
 494 camel_disco_folder_init (CamelDiscoFolder *disco_folder)
 495 {
 496         disco_folder->priv = CAMEL_DISCO_FOLDER_GET_PRIVATE (disco_folder);
 497
 498         g_signal_connect (
 499                 disco_folder, "changed",
 500                 G_CALLBACK (cdf_folder_changed), NULL);
 501 }
 502
 503 /**
 504  * camel_disco_folder_get_offline_sync:
 505  * @disco_folder: a #CamelDiscoFolder
 506  *
 507  * Since: 2.32
 508  **/
 509 gboolean
 510 camel_disco_folder_get_offline_sync (CamelDiscoFolder *disco_folder)
 511 {
 512         g_return_val_if_fail (CAMEL_IS_DISCO_FOLDER (disco_folder), FALSE);
 513
 514         return disco_folder->priv->offline_sync;
 515 }
 516
 517 /**
 518  * camel_disco_folder_set_offline_sync:
 519  * @disco_folder: a #CamelDiscoFolder
 520  * @offline_sync: whether to synchronize for offline use
 521  *
 522  * Since: 2.32
 523  **/
 524 void
 525 camel_disco_folder_set_offline_sync (CamelDiscoFolder *disco_folder,
 526                                      gboolean offline_sync)
 527 {
 528         g_return_if_fail (CAMEL_IS_DISCO_FOLDER (disco_folder));
 529
 530         if ((disco_folder->priv->offline_sync ? 1 : 0) == (offline_sync ? 1 : 0))
 531                 return;
 532
 533         disco_folder->priv->offline_sync = offline_sync;
 534
 535         g_object_notify (G_OBJECT (disco_folder), "offline-sync");
 536 }
 537
 538 /**
 539  * camel_disco_folder_expunge_uids:
 540  * @folder: a (disconnectable) folder
 541  * @uids: array of UIDs to expunge
 542  * @cancellable: optional #GCancellable object, or %NULL
 543  * @error: return location for a #GError, or %NULL
 544  *
 545  * This expunges the messages in @uids from @folder. It should take
 546  * whatever steps are needed to avoid expunging any other messages,
 547  * although in some cases it may not be possible to avoid expunging
 548  * messages that are marked deleted by another client at the same time
 549  * as the expunge_uids call is running.
 550  *
 551  * Returns: %TRUE on success, %FALSE on failure
 552  **/
 553 gboolean
 554 camel_disco_folder_expunge_uids (CamelFolder *folder,
 555                                  GPtrArray *uids,
 556                                  GCancellable *cancellable,
 557                                  GError **error)
 558 {
 559         g_return_val_if_fail (CAMEL_IS_DISCO_FOLDER (folder), FALSE);
 560         g_return_val_if_fail (uids != NULL, FALSE);
 561
 562         return disco_expunge_uids (folder, uids, cancellable, error);
 563 }
 564
 565 /**
 566  * camel_disco_folder_cache_message:
 567  * @disco_folder: the folder
 568  * @uid: the UID of the message to cache
 569  * @cancellable: optional #GCancellable object, or %NULL
 570  * @error: return location for a #GError, or %NULL
 571  *
 572  * Requests that @disco_folder cache message @uid to disk.
 573  *
 574  * Returns: %TRUE on success, %FALSE on failure
 575  **/
 576 gboolean
 577 camel_disco_folder_cache_message (CamelDiscoFolder *disco_folder,
 578                                   const gchar *uid,
 579                                   GCancellable *cancellable,
 580                                   GError **error)
 581 {
 582         CamelDiscoFolderClass *class;
 583         gboolean success;
 584
 585         g_return_val_if_fail (CAMEL_IS_DISCO_FOLDER (disco_folder), FALSE);
 586         g_return_val_if_fail (uid != NULL, FALSE);
 587
 588         class = CAMEL_DISCO_FOLDER_GET_CLASS (disco_folder);
 589         g_return_val_if_fail (class->cache_message != NULL, FALSE);
 590
 591         success = class->cache_message (
 592                 disco_folder, uid, cancellable, error);
 593         CAMEL_CHECK_GERROR (disco_folder, cache_message, success, error);
 594
 595         return success;
 596 }
 597
 598 /**
 599  * camel_disco_folder_prepare_for_offline:
 600  * @disco_folder: the folder
 601  * @expression: an expression describing messages to synchronize, or %NULL
 602  * if all messages should be sync'ed.
 603  * @cancellable: optional #GCancellable object, or %NULL
 604  * @error: return location for a #GError, or %NULL
 605  *
 606  * This prepares @disco_folder for offline operation, by downloading
 607  * the bodies of all messages described by @expression (using the
 608  * same syntax as camel_folder_search_by_expression() ).
 609  *
 610  * Returns: %TRUE on success, %FALSE on failure
 611  **/
 612 gboolean
 613 camel_disco_folder_prepare_for_offline (CamelDiscoFolder *disco_folder,
 614                                         const gchar *expression,
 615                                         GCancellable *cancellable,
 616                                         GError **error)
 617 {
 618         CamelDiscoFolderClass *class;
 619         gboolean success;
 620
 621         g_return_val_if_fail (CAMEL_IS_DISCO_FOLDER (disco_folder), FALSE);
 622
 623         class = CAMEL_DISCO_FOLDER_GET_CLASS (disco_folder);
 624         g_return_val_if_fail (class->prepare_for_offline != NULL, FALSE);
 625
 626         success = class->prepare_for_offline (
 627                 disco_folder, expression, cancellable, error);
 628         CAMEL_CHECK_GERROR (disco_folder, prepare_for_offline, success, error);
 629
 630         return success;
 631 }