gui/src/Thread.cc

   1 ///
   2 /// \file       Thread.cc
   3 ///             Thread class for device manipulation
   4 ///
   5
   6 /*
   7     Copyright (C) 2007-2013, Net Direct Inc. (http://www.netdirect.ca/)
   8     Copyright (C) 2009, Ryan Li (ryan@ryanium.com)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "Thread.h"
  24 #include "util.h"
  25 #include "i18n.h"
  26
  27 void Thread::SetStatus(std::string mode)
  28 {
  29         m_status = mode;
  30         m_update->emit();
  31 }
  32
  33 Thread::Thread(Device dev, Glib::Dispatcher *update_signal)
  34         : ConfigFile(dev.GetPIN())
  35         , m_dev(dev)
  36         , m_interface(&m_dev)
  37         , m_update(update_signal)
  38         , m_status("")
  39         , m_recordFinished(0)
  40         , m_recordTotal(0)
  41         , m_connected(false)
  42         , m_error(false)
  43         , m_thread_state(THREAD_STATE_IDLE)
  44 {
  45         m_signal_progress.connect(
  46                 sigc::mem_fun(*this, &Thread::on_thread_progress));
  47         m_signal_error.connect(
  48                 sigc::mem_fun(*this, &Thread::on_thread_error));
  49         m_signal_done.connect(
  50                 sigc::mem_fun(*this, &Thread::on_thread_done));
  51         m_signal_erase_db.connect(
  52                 sigc::mem_fun(*this, &Thread::on_thread_erase_db));
  53         m_signal_restored_db.connect(
  54                 sigc::mem_fun(*this, &Thread::on_thread_restored_db));
  55
  56         SetStatus(_("Ready"));
  57 }
  58
  59 void Thread::LoadConfig()
  60 {
  61         ConfigFile::Load();
  62         if( m_connected )
  63                 Enlighten(m_interface.GetDBDB());
  64         m_update->emit();
  65 }
  66
  67 bool Thread::CheckFinishedMarker()
  68 {
  69         if( !m_finished_marker )
  70                 return false;
  71         m_finished_marker = false;
  72         return true;
  73 }
  74
  75 std::vector<std::string> Thread::CompareTotals() const
  76 {
  77         if( AutoSelectAll() ) {
  78                 // compare against full DBDB
  79                 return m_interface.CompareTotals(m_interface.GetDBDB());
  80         }
  81         else {
  82                 // compare against current saved backup list
  83                 return m_interface.CompareTotals(GetBackupList());
  84         }
  85 }
  86
  87 std::string Thread::GetFullname()
  88 {
  89         std::string ret = GetPIN().Str() + " (" + GetDeviceName() + ")";
  90         return ret;
  91 }
  92
  93 bool Thread::Connect()
  94 {
  95         password_required = false;
  96         bad_size = false;
  97         try {
  98                 if( !m_interface.Connect() )
  99                         return (m_connected = false);
 100         }
 101         catch( Barry::BadPassword &bp ) {
 102                 password_out_of_tries = bp.out_of_tries();
 103                 password_remaining_tries = bp.remaining_tries();
 104                 password_required = true;
 105                 return (m_connected = false);
 106         }
 107         catch( Barry::BadSize &bs ) {
 108                 bad_size_error = std::string("Barry::BadSize caught in Connect: ") + bs.what();
 109                 bad_size = true;
 110                 return (m_connected = false);
 111         }
 112         SetStatus(_("Connected"));
 113         return (m_connected = true);
 114 }
 115
 116 bool Thread::Connect(const std::string &password)
 117 {
 118         try {
 119                 if( !m_interface.Password(password.c_str()) ) {
 120                         // low level error, not a password failure
 121                         return (m_connected = false);
 122                 }
 123         }
 124         catch( Barry::BadPassword &bp ) {
 125                 password_out_of_tries = bp.out_of_tries();
 126                 password_remaining_tries = bp.remaining_tries();
 127                 bad_password_error = bp.what();
 128                 return (m_connected = false);
 129         }
 130         SetStatus(_("Connected"));
 131         return (m_connected = true);
 132 }
 133
 134 void Thread::Disconnect()
 135 {
 136         if( m_connected )
 137         {
 138                 m_interface.Disconnect();
 139                 SetStatus(_("Ready"));
 140                 m_connected = false;
 141         }
 142 }
 143
 144 void Thread::UnsetActive()
 145 {
 146         m_active = false;
 147         if( !Working() )
 148                 Disconnect();
 149 }
 150
 151 bool Thread::Backup(std::string label)
 152 {
 153         // only start a backup if currently idle
 154         if( Working() )
 155                 return false;
 156
 157         // grab copy of backup list
 158         Barry::ConfigFile::DBListType list;
 159         if( AutoSelectAll() ) {
 160                 // set list to full DBDB
 161                 list = m_interface.GetDBDB();
 162         }
 163         else {
 164                 // copy our current saved list
 165                 list = GetBackupList();
 166         }
 167
 168         m_recordTotal = m_interface.GetRecordTotal(list);
 169         m_recordFinished = 0;
 170
 171         bool started = m_interface.StartBackup(
 172                 DeviceInterface::AppComm(&m_signal_progress,
 173                         &m_signal_error,
 174                         &m_signal_done,
 175                         &m_signal_erase_db,
 176                         &m_signal_restored_db),
 177                 list, GetPath(), label);
 178         if( started ) {
 179                 m_thread_state = THREAD_STATE_BACKUP;
 180                 SetStatus(_("Backup..."));
 181         }
 182         return started;
 183 }
 184
 185 bool Thread::Restore(std::string filename)
 186 {
 187         // only start a restore if currently idle
 188         if( Working() )
 189                 return false;
 190
 191         m_recordTotal = m_interface.GetRecordTotal(GetRestoreList(), filename);
 192         m_recordFinished = 0;
 193
 194         bool started = m_interface.StartRestore(
 195                 DeviceInterface::AppComm(&m_signal_progress,
 196                         &m_signal_error,
 197                         &m_signal_done,
 198                         &m_signal_erase_db,
 199                         &m_signal_restored_db),
 200                 GetRestoreList(), filename);
 201         if( started ) {
 202                 m_thread_state = THREAD_STATE_RESTORE;
 203                 SetStatus(_("Restore..."));
 204         }
 205         return started;
 206 }
 207
 208 void Thread::on_thread_progress()
 209 {
 210         ++m_recordFinished;
 211         m_update->emit();
 212 }
 213
 214 void Thread::on_thread_error()
 215 {
 216         m_error = true;
 217         // Do not change state, since backup/restores continue processing
 218         // on error... wait for on_thread_done() to change state.
 219         //m_thread_state |= THREAD_STATE_IDLE;
 220
 221         Gtk::MessageDialog msg(m_status + _(" error: ") + m_interface.get_last_thread_error());
 222         msg.run();
 223 }
 224
 225 void Thread::on_thread_done()
 226 {
 227         if( m_active )
 228                 SetStatus(_("Connected"));
 229         else
 230                 Disconnect();
 231         m_thread_state |= THREAD_STATE_IDLE;
 232         m_finished_marker = true;
 233 }
 234
 235 void Thread::on_thread_erase_db()
 236 {
 237         m_erasing_db_name = m_interface.GetThreadDBName();
 238         std::cerr << _("Erasing database: ") << m_erasing_db_name << std::endl;
 239 }
 240
 241 void Thread::on_thread_restored_db()
 242 {
 243         if( m_erasing_db_name.size() ) {
 244                 std::cerr << _("Restored database: ") << m_erasing_db_name << std::endl;
 245                 m_erasing_db_name.clear();
 246         }
 247 }
 248