gui/src/DeviceIface.h

   1 ///
   2 /// \file       DeviceIface.h
   3 ///             Interface class for device backup and restore
   4 ///
   5
   6 /*
   7     Copyright (C) 2007-2010, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #ifndef __BARRYBACKUP_DEVICEIFACE_H__
  23 #define __BARRYBACKUP_DEVICEIFACE_H__
  24
  25 #include <barry/barry.h>
  26 #include <string>
  27 #include <memory>
  28 #include <stdint.h>
  29 #include "tarfile.h"
  30
  31 #define DI_THREAD_DONE 100
  32 #define DI_THREAD_PROGRESS 101
  33
  34 namespace Glib {
  35         class Dispatcher;
  36         class Mutex;
  37 }
  38
  39 class Device
  40 {
  41         Barry::ProbeResult result;
  42
  43 public:
  44         Device();
  45         Device(Barry::ProbeResult);
  46
  47         Barry::Pin GetPIN() const { return Barry::Pin(result.m_pin); };
  48
  49         friend class DeviceInterface;
  50 };
  51
  52 class DeviceInterface :
  53         public Barry::Parser,
  54         public Barry::Builder
  55 {
  56 public:
  57         struct AppComm                          // app communication
  58         {
  59                 Glib::Dispatcher *m_erase_db;   // to notify the app about the
  60                                                 // db erase stage of restore
  61                 Glib::Dispatcher *m_restored_db;// to notify the app that the
  62                                                 // previous erase_db was
  63                                                 // restored... do not rely
  64                                                 // on the current db name ==
  65                                                 // the name found at erase time
  66                 Glib::Dispatcher *m_progress;
  67                 Glib::Dispatcher *m_error;
  68                 Glib::Dispatcher *m_done;
  69
  70                 AppComm() :
  71                         m_erase_db(0),
  72                         m_restored_db(0),
  73                         m_progress(0),
  74                         m_error(0),
  75                         m_done(0)
  76                         {}
  77                 AppComm(Glib::Dispatcher *progress,
  78                         Glib::Dispatcher *error,
  79                         Glib::Dispatcher *done,
  80                         Glib::Dispatcher *erase_db,
  81                         Glib::Dispatcher *restored_db) :
  82                         m_erase_db(erase_db),
  83                         m_restored_db(restored_db),
  84                         m_progress(progress),
  85                         m_error(error),
  86                         m_done(done)
  87                         {}
  88                 bool IsValid() const
  89                         { return m_erase_db && m_restored_db && m_progress && m_error && m_done; }
  90                 void Invalidate()
  91                         { m_erase_db = m_restored_db = m_progress = m_error = m_done = 0; }
  92         };
  93
  94         class Quit      // quit exception to break out of upload/download
  95         {
  96         };
  97
  98 private:
  99         Device *m_dev;
 100         Barry::Controller *m_con;
 101         Barry::Mode::Desktop *m_desktop;
 102         std::string m_last_error;
 103         std::string m_last_thread_error;
 104
 105         AppComm m_AppComm;
 106         std::auto_ptr<reuse::TarFile> m_tar, m_tarback;
 107
 108         // parser and builder data (only one side uses these at a time)
 109         Barry::ConfigFile::DBListType m_dbList;
 110         mutable Glib::Mutex *m_dbnameMutex;
 111         std::string m_current_dbname_not_thread_safe;
 112         std::string m_current_dbname;
 113         uint8_t m_rec_type;
 114         uint32_t m_unique_id;
 115         std::string m_tar_id_text;
 116         std::string m_record_data;
 117         bool m_end_of_tar;
 118         bool m_tar_record_loaded;
 119
 120         // thread quit flag... not locked, only a byte
 121         volatile bool m_thread_quit;
 122
 123 protected:
 124         bool False(const std::string &msg);
 125
 126         // threads
 127         void BackupThread();
 128         void RestoreThread();
 129         void RestoreAndBackupThread();
 130
 131         // helpers
 132         std::string MakeFilename(const std::string &label = "") const;
 133         int CountFiles(reuse::TarFile &tar, const Barry::ConfigFile::DBListType &restoreList) const;
 134         bool SplitTarPath(const std::string &tarpath, std::string &dbname,
 135                 std::string &dbid_text, uint8_t &dbrectype, uint32_t &dbid) const;
 136
 137         // Sets the name of the database the thread is currently working on
 138         void SetThreadDBName(const std::string &dbname);
 139
 140 public:
 141         DeviceInterface(Device *dev = 0);
 142         ~DeviceInterface();
 143
 144         const std::string& get_last_error() const { return m_last_error; }
 145         const std::string& get_last_thread_error() const { return m_last_thread_error; }
 146
 147         void Reset();
 148         bool Connect();
 149         bool Password(const char *password);
 150         void Disconnect();
 151
 152         const Barry::DatabaseDatabase& GetDBDB() const { return m_desktop->GetDBDB(); }
 153         unsigned int GetRecordTotal(const Barry::ConfigFile::DBListType &backupList) const;
 154         unsigned int GetRecordTotal(const Barry::ConfigFile::DBListType &restoreList, const std::string &filename) const;
 155
 156         void QuitThread()       { m_thread_quit = true; }
 157
 158         /// returns name of database the thread is currently working on
 159         std::string GetThreadDBName() const;
 160
 161         bool StartBackup(AppComm comm,
 162                 const Barry::ConfigFile::DBListType &backupList,
 163                 const std::string &directory, const std::string &backupLabel);
 164         bool StartRestore(AppComm comm,
 165                 const Barry::ConfigFile::DBListType &restoreList,
 166                 const std::string &tarfilename);
 167         // this is for debugging... starts a restore, and then does an
 168         // immediate backup of the same DB before moving on to the next
 169         bool StartRestoreAndBackup(AppComm comm,
 170                 const Barry::ConfigFile::DBListType &restoreAndBackupList,
 171                 const std::string &tarfilename,
 172                 const std::string &directory);
 173
 174         // Barry::Parser overrides
 175         virtual void Clear();
 176         virtual void SetIds(const std::string &DbName,
 177                 uint8_t RecType, uint32_t UniqueId);
 178         virtual void ParseHeader(const Barry::Data &data, size_t &offset);
 179         virtual void ParseFields(const Barry::Data &data, size_t &offset,
 180                 const Barry::IConverter *ic);
 181         virtual void Store();
 182
 183         // Barry::Builder overrides
 184         virtual bool Retrieve();
 185         virtual std::string GetDBName() const;
 186         virtual uint8_t GetRecType() const;
 187         virtual uint32_t GetUniqueId() const;
 188         virtual bool EndOfFile() const { return false; } // not used
 189         virtual void BuildHeader(Barry::Data &data, size_t &offset);
 190         virtual void BuildFields(Barry::Data &data, size_t &offset, const Barry::IConverter *ic);
 191         void SkipCurrentDB() throw();   // helper function for halding restore errors
 192 };
 193
 194 #endif
 195