TwoWaySync.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef TWO_WAY_SYNC_HPP
#define TWO_WAY_SYNC_HPP

#include <pthread.h>
#include "plugin/sync/Sync.hpp"

struct OpenAB_Sync_params
{
    std::string                     local_plugin; 
    OpenAB_Source::Parameters          local_input_params; 
    OpenAB_Storage::Parameters         local_storage_params; 
    std::string                     remote_plugin;    
    OpenAB_Source::Parameters          remote_input_params; 
    OpenAB_Storage::Parameters         remote_storage_params; 
    OpenAB_Sync::Sync::SyncCallback *  cb;           
    enum SyncType
    {
      eSyncIncremental,
      eSyncAll,
      eSyncText
    }                               sync_type;
    float                           sync_progress_time;
    unsigned int                    batch_size;
    std::string                     metadata;
};

class TwoWaySync : public OpenAB_Sync::Sync
{
  public:
    TwoWaySync(OpenAB_Sync_params&);
    ~TwoWaySync();

    enum OpenAB_Sync::Sync::eInit init();

    void synchronize();

    enum OpenAB_Sync::Sync::eCancel cancel();

    enum OpenAB_Sync::Sync::eSuspend suspend();

    enum OpenAB_Sync::Sync::eResume resume();

    void getStats(unsigned int& locallyAdded,
                  unsigned int& locallyModified,
                  unsigned int& locallyRemoved,
                  unsigned int& remotelyAdded,
                  unsigned int& remotelyModified,
                  unsigned int& remotelyRemoved);

  private:
    TwoWaySync(TwoWaySync const &other);

    TwoWaySync& operator=(TwoWaySync const &other);

    void buildLocalIndexDB();
    void cleanLocalIndexDB();

    void initMetadata();
    void saveMetadata();


    bool checkRemoteChanges();
    bool checkLocalChanges();

    void firstTimeSync();
    void fullSync();

    void addLocalItem(const OpenAB::SmartPtr<OpenAB::PIMItem>& item);
    void modifyLocalItem(const std::string& id, const OpenAB::SmartPtr<OpenAB::PIMItem>& item);
    void removeLocalItem(const std::string& id);

    void addRemoteItem(const OpenAB::SmartPtr<OpenAB::PIMItem>& item);
    void modifyRemoteItem(const std::string& id, const OpenAB::SmartPtr<OpenAB::PIMItem>& item);
    void removeRemoteItem(const std::string& id);

    bool flushLocalInsertions();
    bool flushLocalModifications();
    bool flushLocalRemovals();

    bool flushRemoteInsertions();
    bool flushRemoteModifications();
    bool flushRemoteRemovals();

    enum eSync doSynchronize();
    static void* threadSync(void*);

    struct SyncStats {
        void clean(){
          locallyAdded    = 0;
          locallyModified = 0;
          locallyRemoved  = 0;

          remotelyAdded   = 0;
          remotelyModified = 0;
          remotelyRemoved  = 0;
        };
        unsigned int locallyAdded;
        unsigned int locallyModified;
        unsigned int locallyRemoved;

        unsigned int remotelyAdded;
        unsigned int remotelyModified;
        unsigned int remotelyRemoved;

        pthread_mutex_t mutex;

    };

    SyncStats globalStats;

    OpenAB_Sync_params       params;

    OpenAB_Storage::Storage* localStorage;

    OpenAB_Storage::Storage* remoteStorage;

    typedef std::vector< OpenAB::SmartPtr<OpenAB_Storage::StorageItem> > vectorElem;
    typedef std::map< OpenAB::SmartPtr<OpenAB::PIMItemIndex> , vectorElem > dbIndexElem;
    dbIndexElem indexDB;

    //typedef std::map<std::string, OpenAB::SmartPtr<OpenAB_Storage::StorageItem> LocalIndex;
    //LocalIndex localIndex;
   // std::vector<OpenAB::SmartPtr<OpenAB_Storage::StorageItem> > localChanges;

    struct ItemDesc
    {
        ItemDesc(const std::string& _id, OpenAB::SmartPtr<OpenAB::PIMItem> vcard) :
        id (_id),
        item (vcard){}

      std::string id;
      OpenAB::SmartPtr<OpenAB::PIMItem> item;
    };

    std::vector<ItemDesc> localItemsToBeAdded;
    std::vector<ItemDesc> localItemsToBeModified;
    std::vector<std::string> localItemsToBeRemoved;

    std::vector<ItemDesc> remoteItemsToBeAdded;
    std::vector<ItemDesc> remoteItemsToBeModified;
    std::vector<std::string> remoteItemsToBeRemoved;

    std::vector<OpenAB::SmartPtr<OpenAB::PIMItem> > localyAddedItems;
    std::map<std::string, OpenAB::SmartPtr<OpenAB::PIMItem> > localyModifiedItems;

    std::vector<OpenAB::SmartPtr<OpenAB::PIMItem> > remotelyAddedItems;
    std::map<std::string, OpenAB::SmartPtr<OpenAB::PIMItem> > remotelyModifiedItems;

    bool dbError;
    bool inputError;

    pthread_t syncThread;
    pthread_mutex_t syncMutex;
    bool threadCreated;
    bool syncInProgress;
    eSync lastSyncResult;
    bool cancelSync;

    OpenAB_Sync::SyncMetadata metadata;
};

#endif /* TWO_WAY_SYNC_HPP */